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

package/models/models/software-info/software-info-registration.d.ts

@@ -0,0 +1,84 @@
+import { SoftwareInfoModel, SoftwareInfoOptions } from './types';
+import { KosModelRegistrationBean } from '../../../core/types';
+
+/**
+ * # SoftwareInfo
+ *
+ * The registration bean includes convenience methods for creating and working with SoftwareInfoModel 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: SoftwareInfo.type, id: "softwareInfoId"})
+ * private softwareInfoModel: SoftwareInfoModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new SoftwareInfoModel 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 = SoftwareInfo.factory("softwareInfoId")({
+ *   // 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 SoftwareInfoModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (SoftwareInfo.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to SoftwareInfoModel
+ *    // and the compiler will know that the model has the SoftwareInfoModel 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 { SoftwareInfo } from "@kos-ui/kos-dispenser-model";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...SoftwareInfo.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The softwareInfo 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 SoftwareInfo: Readonly<KosModelRegistrationBean<SoftwareInfoModel, SoftwareInfoOptions>>;
+//# sourceMappingURL=software-info-registration.d.ts.map

package/models/models/software-info/software-info-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"software-info-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/software-info/software-info-registration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAGpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8EK;AACL,eAAO,MAAM,YAAY,EAAE,QAAQ,CACjC,wBAAwB,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAajE,CAAC"}

package/models/models/software-info/types/index.d.ts

@@ -0,0 +1,67 @@
+import { SoftwareInfoModelImpl } from '../software-info-model';
+import { PublicModelInterface } from '../../../../core';
+
+
+/**
+ * Configuration options for SoftwareInfo model instances.
+ *
+ * This interface defines the configuration options for the SoftwareInfo model.
+ * Currently, no specific configuration options are required as the model
+ * automatically loads software information from the system manifest API.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * const softwareInfo = SoftwareInfo.instance('system-info').build();
+ * ```
+ *
+ * @category Model Configuration
+ * @category System Integration
+ */
+export interface SoftwareInfoOptions {
+  /** Reserved for future extensibility - currently no options required */
+  [key: string]: never;
+}
+
+/**
+ * @interface
+ * @useDeclaredType
+ */
+export type SoftwareInfoModel = PublicModelInterface<SoftwareInfoModelImpl>;
+
+/**
+ * Software artifact information representing an individual component or package.
+ *
+ * This interface describes a software artifact (component, package, or module)
+ * installed on a KOS device node, including its identification, grouping, and version.
+ *
+ * @group KOS Model
+ * @category Types
+ */
+export interface ArtifactsType {
+  /** Unique identifier/name of the software artifact */
+  name: string;
+  /** Functional group classification (core, ui, services, etc.) */
+  group: string;
+  /** Semantic version string of the artifact */
+  version: string;
+}
+
+/**
+ * Node software information representing all software components on a device node.
+ *
+ * This interface describes the complete software configuration of a single KOS device node,
+ * including the node identification, KOS framework version, and all installed artifacts
+ * organized by functional groups.
+ *
+ * @group KOS Model
+ * @category Types
+ */
+export interface NodeInfoType {
+  /** Node identifier (primary, secondary, etc.) */
+  nodeName: string;
+  /** KOS framework version running on this node */
+  kosVersion?: string;
+  /** Artifacts organized by functional groups */
+  group: Record<string, ArtifactsType[]>;
+}
+

package/models/models/state-bean/index.d.ts

@@ -0,0 +1,4 @@
+export { StateBean } from './state-bean-registration';
+export type * from './types';
+export * as StateBeanServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/state-bean/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/state-bean/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,mBAAmB,SAAS,CAAC;AAC7B,OAAO,KAAK,iBAAiB,MAAM,YAAY,CAAC"}

package/models/models/state-bean/services/index.d.ts

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

package/models/models/state-bean/services/index.d.ts.map

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

package/models/models/state-bean/services/state-bean-services.d.ts

@@ -0,0 +1,14 @@
+export interface StateBeanResponse {
+    [k: string]: string | number | boolean;
+}
+interface StateBeanOptions {
+    path: string;
+}
+/**
+ * @category Service
+ * @internal
+ * Retrieves the initial state-bean data.
+ */
+export declare const getStateBeanData: ({ path }: StateBeanOptions) => Promise<import('../../../../core').KosServiceResponse<StateBeanResponse> | undefined>;
+export {};
+//# sourceMappingURL=state-bean-services.d.ts.map

package/models/models/state-bean/services/state-bean-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-bean-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/state-bean/services/state-bean-services.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,iBAAiB;IAChC,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;CACxC;AAED,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;CACd;AACD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,aAAoB,gBAAgB,0FAMhE,CAAC"}

package/models/models/state-bean/state-bean-model.d.ts

@@ -0,0 +1,106 @@
+import { StateBeanModel, StateBeanOptions, StatePropsMap } from './types';
+import { StateBeanResponse } from './services';
+import { StatePropertyTypes } from '../types';
+import { PublicModelInterface } from '../../../core/types';
+import { IKosModelLogger, KosContextLogger, KosCreationContext } from '../../../core';
+
+export declare const MODEL_TYPE = "state-bean-model";
+/**
+ * StateBean - Reactive state management for KOS device state properties.
+ *
+ * The StateBean model provides real-time access to KOS device state information through
+ * reactive properties that automatically synchronize with device state changes via WebSocket
+ * topics. This model is essential for applications that need to monitor device state,
+ * track property changes, or build reactive UIs that respond to device status updates.
+ *
+ * ## Key Features
+ * - **Real-time Synchronization** - Automatic updates via `/kos/state/{path}` WebSocket topics
+ * - **Type-safe Properties** - Strongly typed state properties with automatic type conversion
+ * - **Observable State Map** - Reactive Map-based property storage for efficient updates
+ * - **Automatic Type Conversion** - Smart conversion of string values to boolean/number types
+ * - **Path-based Organization** - Hierarchical state organization using dot-notation paths
+ * - **Lifecycle Management** - Proper initialization and loading of state data
+ *
+ * ## Topic-Based Reactivity
+ * The model listens to KOS topics for real-time synchronization:
+ * - **`/kos/state/{path}`** - Receives state updates for the specified path, triggering automatic property updates across all connected clients
+ *
+ * ## State Property Types
+ * Supports all common KOS state property types:
+ * - **string** - Text values, configuration strings, identifiers
+ * - **number** - Numeric values, counters, measurements, percentages
+ * - **boolean** - Status flags, enabled/disabled states, operational flags
+ * - **object** - Complex state objects, nested configurations
+ *
+ * ## Common Use Cases
+ * - **Device Status Monitoring** - Track operational states, error conditions, health metrics
+ * - **Configuration State** - Monitor dynamic configuration changes and feature flags
+ * - **System Status Dashboards** - Build real-time status displays and monitoring interfaces
+ * - **Conditional UI Logic** - Show/hide UI elements based on device state
+ * - **State-dependent Operations** - Enable/disable functionality based on device state
+ * - **Multi-client Synchronization** - Keep multiple clients in sync with device state
+ *
+ * @interface
+ * @example Basic Usage
+ * ```typescript
+ * const deviceState = StateBean.instance('device-status')
+ *   .options({ path: 'device.operational.status' })
+ *   .build();
+ *
+ * // Access reactive state properties
+ * const isOnline = deviceState.props.get('online') as boolean;
+ * const temperature = deviceState.props.get('temperature') as number;
+ * ```
+ *
+ * @group KOS Model
+ * @category State Management
+ * @useDeclaredType
+ *
+ * @see {@link StateBeanOptions} - Configuration options for StateBean model
+ * @see {@link StatePropertyTypes} - Supported state property value types
+ * @see {@link StateProp} - Individual property access model
+ * @see {@link getStateBeanData} - Service function for loading state data
+ */
+export type StateBean<T extends Record<string, StatePropertyTypes> = Record<string, StatePropertyTypes>> = PublicModelInterface<StateBeanModelImpl<T>>;
+/**
+ * @ignore
+ * @internal
+ */
+export declare class StateBeanModelImpl<T extends Record<string, StatePropertyTypes> = Record<string, StatePropertyTypes>> implements StateBeanModel<T>, IKosModelLogger {
+    /** Unique identifier for the model instance */
+    id: string;
+    /** State path being monitored for updates */
+    path: string;
+    /** Reactive Map of state properties with automatic type conversion */
+    props: StatePropsMap<T>;
+    /** Context logger for debugging and diagnostics */
+    logger: KosContextLogger;
+    constructor(modelId: string, options: StateBeanOptions, context: KosCreationContext);
+    /**
+     * Updates the model configuration with new options.
+     * @param options New configuration options to apply
+     */
+    updateModel(options: StateBeanOptions): void;
+    /**
+     * Handles WebSocket state updates from the KOS topic system.
+     * Automatically converts string values to appropriate types (boolean, number).
+     * @param stateBean State data received from WebSocket topic
+     * @internal
+     */
+    handleConfigBeanUpdated(stateBean: StateBeanResponse): void;
+    /**
+     * @internal
+     */
+    init(): Promise<void>;
+    /**
+     * Updates multiple properties at once with type conversion.
+     * @param props Properties to update
+     * @private
+     */
+    updateProps(props: Record<string, StatePropertyTypes>): void;
+    /**
+     * @internal
+     */
+    load(): Promise<void>;
+}
+//# sourceMappingURL=state-bean-model.d.ts.map

package/models/models/state-bean/state-bean-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-bean-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/state-bean/state-bean-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,eAAe,CAAC;AAQvB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE/E,eAAO,MAAM,UAAU,qBAAqB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,MAAM,MAAM,SAAS,CACnB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAAG,MAAM,CACnD,MAAM,EACN,kBAAkB,CACnB,IACC,oBAAoB,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;AAIhD;;;GAGG;AACH,qBACa,kBAAkB,CAC7B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAAG,MAAM,CACnD,MAAM,EACN,kBAAkB,CACnB,CACD,YAAW,cAAc,CAAC,CAAC,CAAC,EAAE,eAAe;IAE7C,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,6CAA6C;IAC7C,IAAI,EAAG,MAAM,CAAC;IACd,sEAAsE;IACtE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACxB,mDAAmD;IACnD,MAAM,EAAE,gBAAgB,CAAC;gBAEvB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,kBAAkB;IAQ7B;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAI5C;;;;;OAKG;IAKH,uBAAuB,CAAC,SAAS,EAAE,iBAAiB;IAkBpD;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;;OAIG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC;IAMrD;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAO5B"}

package/models/models/state-bean/state-bean-registration.d.ts

@@ -0,0 +1,84 @@
+import { StateBeanModel, StateBeanOptions } from './types';
+import { KosModelRegistrationBean } from '../../../core';
+
+/**
+ * # StateBean
+ *
+ * The registration bean includes convenience methods for creating and working with StateBeanModel 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: StateBean.type, id: "stateBeanId"})
+ * private stateBeanModel: StateBeanModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new StateBeanModel 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 = StateBean.factory("stateBeanId")({
+ *   // 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 StateBeanModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (StateBean.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to StateBeanModel
+ *    // and the compiler will know that the model has the StateBeanModel 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 { StateBean } from "@kosdev-code/kos-dispense-sdk";
+ * ...
+ * import { ExtensionManager, IKosRegistry } from "@kosdev-code/kos-ui-sdk";
+ * export const kosModels: IKosRegistry["models"] = {
+ *  ...StateBean.registration,
+ * };
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The stateBean 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 StateBean: Readonly<KosModelRegistrationBean<StateBeanModel, StateBeanOptions>>;
+//# sourceMappingURL=state-bean-registration.d.ts.map

package/models/models/state-bean/state-bean-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-bean-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/state-bean/state-bean-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAG9D,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8EK;AACL,eAAO,MAAM,SAAS,EAAE,QAAQ,CAC9B,wBAAwB,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAW3D,CAAC"}

package/models/models/state-bean/types/index.d.ts

@@ -0,0 +1,132 @@
+import { StatePropertyTypes } from '../../types';
+
+
+/**
+ * Configuration options for StateBean model instances.
+ *
+ * This interface defines the configuration options for the StateBean model,
+ * specifying which state path the model should monitor for real-time updates.
+ *
+ * @example Basic StateBean Model Creation
+ * ```typescript
+ * // Monitor device operational status
+ * const deviceState = StateBean.instance('device-status')
+ *   .options({ path: 'device.operational.status' })
+ *   .build();
+ *
+ * // Monitor system health metrics
+ * const healthState = StateBean.instance('system-health')
+ *   .options({ path: 'system.health.metrics' })
+ *   .build();
+ * ```
+ *
+ * @example Path Patterns
+ * ```typescript
+ * // Different path patterns for different use cases
+ * const networkOptions: StateBeanOptions = {
+ *   path: 'network.interfaces.primary' // Network interface state
+ * };
+ *
+ * const pumpOptions: StateBeanOptions = {
+ *   path: 'assembly.pumps.status' // Pump system state
+ * };
+ *
+ * const brewingOptions: StateBeanOptions = {
+ *   path: 'beverage.brewing.process' // Brewing process state
+ * };
+ * ```
+ *
+ * @example Hierarchical State Organization
+ * ```typescript
+ * // Use dot notation for hierarchical state paths
+ * const parentState = StateBean.instance('parent')
+ *   .options({ path: 'system' })
+ *   .build();
+ *
+ * const childState = StateBean.instance('child')
+ *   .options({ path: 'system.subsystem.component' })
+ *   .build();
+ * ```
+ *
+ * @category Model Configuration
+ * @category State Management
+ */
+export interface StateBeanOptions {
+  /**
+   * State path to monitor for updates using dot notation hierarchy.
+   * This path corresponds to the WebSocket topic `/kos/state/{path}` for real-time updates.
+   *
+   * @example "device.operational.status"
+   * @example "network.interfaces.primary"
+   * @example "assembly.pumps.status"
+   */
+  path: string;
+}
+
+/**
+ * Type-safe keys for state properties within a StateBean.
+ *
+ * @template T - The state property type mapping
+ */
+type StateKeys<T extends Record<string, StatePropertyTypes>> = keyof T;
+
+/**
+ * Reactive Map-based storage for state properties with type safety.
+ *
+ * This Map provides efficient storage and retrieval of state properties with automatic
+ * reactivity through MobX observables. The Map structure allows for dynamic property
+ * addition/removal while maintaining type safety for known properties.
+ *
+ * @example Accessing State Properties
+ * ```typescript
+ * // Define typed state interface
+ * interface PumpState {
+ *   active: boolean;
+ *   flowRate: number;
+ *   temperature: number;
+ *   lastMaintenance: string;
+ * }
+ *
+ * const pumpState = StateBean.instance('pump-monitor')
+ *   .options({ path: 'assembly.pumps.pump1' })
+ *   .build() as StateBean<PumpState>;
+ *
+ * // Type-safe property access
+ * const isActive = pumpState.props.get('active') as boolean;
+ * const currentFlow = pumpState.props.get('flowRate') as number;
+ * const temp = pumpState.props.get('temperature') as number;
+ * const maintenance = pumpState.props.get('lastMaintenance') as string;
+ * ```
+ *
+ * @template T - The state property type mapping
+ *
+ * @group KOS Model
+ * @category Types
+ */
+export type StatePropsMap<T> = Map<StateKeys<T>, T[keyof T]>;
+
+/**
+ * State Bean Model interface - maintains the state of KOS device state properties.
+ *
+ * This interface represents the public API for StateBean models, providing reactive
+ * access to device state properties through an observable Map structure. The interface
+ * supports real-time synchronization with device state via WebSocket topics.
+ *
+ * @group KOS Model
+ * @category Model Interface
+ */
+export interface StateBeanModel<
+  T extends Record<string, StatePropertyTypes> = Record<
+    string,
+    StatePropertyTypes
+  >
+> {
+  /** Unique model identifier */
+  id: string;
+  /** State path being monitored */
+  path: string;
+  /** Reactive Map of state properties */
+  props: StatePropsMap<T>;
+  /** Update model configuration */
+  updateModel(options: StateBeanOptions): void;
+}

package/models/models/state-prop/index.d.ts

@@ -0,0 +1,4 @@
+export { StateProp } from './state-prop-registration';
+export type * from './types';
+export * as StatePropServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/state-prop/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/state-prop/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,mBAAmB,SAAS,CAAC;AAC7B,OAAO,KAAK,iBAAiB,MAAM,YAAY,CAAC"}

package/models/models/state-prop/services/index.d.ts

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

package/models/models/state-prop/services/index.d.ts.map

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

package/models/models/state-prop/services/state-prop-services.d.ts

@@ -0,0 +1,11 @@
+interface StatePropResponse {
+    id: string;
+}
+/**
+ * @category Service
+ * @internal
+ * Retrieves the initial state-prop data.
+ */
+export declare const getStateProps: () => Promise<import('../../../../core').KosServiceResponse<StatePropResponse[]> | undefined>;
+export {};
+//# sourceMappingURL=state-prop-services.d.ts.map

package/models/models/state-prop/services/state-prop-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-prop-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/state-prop/services/state-prop-services.ts"],"names":[],"mappings":"AAaA,UAAU,iBAAiB;IACzB,EAAE,EAAE,MAAM,CAAC;CACZ;AACD;;;;GAIG;AACH,eAAO,MAAM,aAAa,+FAIzB,CAAC"}

package/models/models/state-prop/state-prop-model.d.ts

@@ -0,0 +1,96 @@
+import { KosStateProp, StatePropOptions } from './types';
+import { StatePropertyTypes } from '../types';
+import { StateBeanModel } from '../state-bean/types';
+import { PublicModelInterface } from '../../../core/types';
+import { IKosModelLogger, KosContextLogger, KosCreationContext } from '../../../core';
+
+export declare const MODEL_TYPE = "state-prop-model";
+/**
+ * StateProp - Focused access to individual state properties with dependency on StateBean.
+ *
+ * The StateProp model provides targeted access to a single property within a StateBean,
+ * offering a focused interface for components or services that only need to monitor
+ * specific state values. This model automatically manages its dependency on the underlying
+ * StateBean and provides reactive access to individual property values.
+ *
+ * ## Key Features
+ * - **Single Property Focus** - Access one specific property from a StateBean path
+ * - **Automatic StateBean Dependency** - Manages StateBean dependency transparently
+ * - **Type-safe Value Access** - Strongly typed property value with generic support
+ * - **Reactive Updates** - Automatically updates when underlying StateBean changes
+ * - **Simplified Interface** - Clean `.value` accessor for property values
+ * - **String Conversion** - Built-in `toString()` method for display purposes
+ *
+ * ## StateBean Integration
+ * StateProp models automatically create and manage dependencies on StateBean models:
+ * - **Automatic Dependency** - Creates StateBean with matching path automatically
+ * - **Shared StateBean** - Multiple StateProp models can share the same StateBean
+ * - **Lifecycle Management** - Proper initialization and cleanup of dependencies
+ * - **Real-time Synchronization** - Inherits WebSocket updates from StateBean
+ *
+ * ## Common Use Cases
+ * - **Single Value Components** - React components that only need one state property
+ * - **Conditional Logic** - Enable/disable functionality based on specific state
+ * - **Status Indicators** - Display individual status flags or measurements
+ * - **Property Validation** - Monitor specific properties for validation rules
+ * - **Focused Updates** - Reduce re-renders by tracking only needed properties
+ * - **Service Dependencies** - Services that depend on specific state values
+ *
+ * @interface
+ * @example Basic Usage
+ * ```typescript
+ * const deviceOnline = StateProp.instance('device-online')
+ *   .options({
+ *     path: 'device.operational.status',
+ *     attribute: 'online'
+ *   })
+ *   .build();
+ *
+ * // Access focused property value with type safety
+ * const isOnline = deviceOnline.value as boolean;
+ * console.log(`Status: ${deviceOnline.toString()}`);
+ * ```
+ *
+ * @group KOS Model
+ * @category State Management
+ * @useDeclaredType
+ *
+ * @see {@link StatePropOptions} - Configuration options for StateProp model
+ * @see {@link StatePropertyTypes} - Supported property value types
+ * @see {@link StateBean} - Underlying state collection model
+ * @see {@link StateBeanOptions} - StateBean configuration options
+ */
+export type StateProp<T extends StatePropertyTypes = StatePropertyTypes> = PublicModelInterface<StatePropModelImpl<T>>;
+/**
+ * @ignore
+ * @internal
+ */
+export declare class StatePropModelImpl<T extends StatePropertyTypes = StatePropertyTypes> implements KosStateProp<T>, IKosModelLogger {
+    /** Unique identifier for the model instance */
+    id: string;
+    /** State path being monitored (same as dependent StateBean) */
+    path: string;
+    /** Specific attribute name to access within the state path */
+    attribute: string;
+    /** Context logger for debugging and diagnostics */
+    logger: KosContextLogger;
+    /** Automatic dependency on StateBean for the specified path */
+    stateBean: StateBeanModel;
+    constructor(modelId: string, options: StatePropOptions, context: KosCreationContext);
+    /** The current value of the specific attribute, with type safety */
+    get value(): T | undefined;
+    /**
+     * @internal
+     */
+    init(): Promise<void>;
+    /**
+     * @internal
+     */
+    load(): Promise<void>;
+    /**
+     * Converts the current property value to string for display purposes.
+     * @returns String representation of the property value, or empty string if undefined
+     */
+    toString(): string;
+}
+//# sourceMappingURL=state-prop-model.d.ts.map

package/models/models/state-prop/state-prop-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-prop-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/state-prop/state-prop-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,OAAO,KAAK,EAAE,cAAc,EAAoB,MAAM,qBAAqB,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE9D,eAAO,MAAM,UAAU,qBAAqB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,kBAAkB,GAAG,kBAAkB,IACrE,oBAAoB,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;AAI9C;;;GAGG;AACH,qBACa,kBAAkB,CAC7B,CAAC,SAAS,kBAAkB,GAAG,kBAAkB,CACjD,YAAW,YAAY,CAAC,CAAC,CAAC,EAAE,eAAe;IAE3C,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,MAAM,EAAE,gBAAgB,CAAC;IAEzB,+DAA+D;IAM/D,SAAS,EAAG,cAAc,CAAC;gBAGzB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,kBAAkB;IAW7B,oEAAoE;IACpE,IAAI,KAAK,IAAI,CAAC,GAAG,SAAS,CAEzB;IAID;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;OAGG;IACH,QAAQ,IAAI,MAAM;CAGnB"}