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

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

@@ -0,0 +1,179 @@
+import { ConfigPropertyTypes } from '../types';
+import { ConfigBeanUpdateResponse } from '../../services/config-bean';
+import { ConfigBeanKeys, IConfigBeanModelOptions } from './config-bean-types';
+import { IKosDataModel, KosData, PublicModelInterface, KosModelRegistrationFactory } from '../../../core';
+
+/**
+ * ConfigBean - Reactive hierarchical configuration management for KOS devices.
+ *
+ * The ConfigBean model provides reactive access to hierarchical configuration data from KOS devices
+ * with real-time synchronization via WebSocket topics, schema-based validation, and transactional
+ * updates. Essential for building configuration interfaces and managing device operational parameters.
+ *
+ * ## Key Features
+ * - **Hierarchical Configuration** - Access nested configuration structures using path notation
+ * - **Real-Time Synchronization** - Automatic updates via `/kos/config/{path}` WebSocket topic
+ * - **Schema-Based Validation** - Built-in validation using device configuration schemas
+ * - **Transactional Updates** - Atomic configuration changes with rollback support
+ * - **Type-Safe Access** - Strongly typed property access with TypeScript support
+ * - **Reactive Properties** - Automatic UI updates when configuration changes
+ *
+ * ## Configuration Path Patterns
+ * ConfigBean supports hierarchical paths that mirror device system organization:
+ * - **System Level**: `system:app` - Machine identity, operational modes
+ * - **Service Level**: `kos:service:CANPumpMgr` - KOS service configurations
+ * - **Hardware Level**: `assembly:core:board:macro:pump:water` - Component settings
+ * - **Application Level**: `app:scheduling:dayWiseLockConfigMap` - Application-specific settings
+ *
+ * ## Common Use Cases
+ * - **Configuration Interfaces** - Build reactive configuration management screens
+ * - **Operational Parameter Control** - Real-time adjustment of device behavior
+ * - **Schema-Driven Forms** - Generate configuration UIs from device schemas
+ * - **System Administration** - Centralized device configuration management
+ * - **Bulk Configuration Updates** - Transactional updates across multiple properties
+ *
+ * @example Basic Configuration Management
+ * ```typescript
+ * const systemConfig = ConfigBean.instance('system-config')
+ *   .options({ path: 'system:app' })
+ *   .build();
+ *
+ * // Access current configuration values
+ * const machineId = systemConfig.values.machineId;
+ * const debugMode = systemConfig.values.debugMode;
+ *
+ * // Update configuration properties
+ * await systemConfig.updateProperty('debugMode', true);
+ * await systemConfig.updateProperty('machineId', 'MACHINE-001');
+ * ```
+ *
+ * @interface
+ * @group KOS Model
+ * @category Configuration
+ * @useDeclaredType
+ *
+ * @see {@link IConfigBeanModelOptions} - Configuration options for ConfigBean instances
+ * @see {@link ConfigBeanKeys} - Type-safe property key access
+ * @see {@link ConfigPropertyTypes} - Supported configuration property types
+ */
+export type IConfigBeanModel<T extends {} = any> = PublicModelInterface<ConfigBeanModelImpl<T>>;
+export declare const CONFIG_BEAN_MODEL_TYPE = "config-bean-model";
+/**
+ * @ignore
+ * @internal
+ */
+declare class ConfigBeanModelImpl<T extends {} = any> implements IKosDataModel {
+    /** Service function for modifying configuration beans */
+    private _modifyConfigBean;
+    /** Service function for retrieving configuration beans */
+    private _getConfigBean;
+    /** Schema response containing configuration property definitions */
+    private _schema?;
+    /** Unique identifier for this configuration model instance */
+    id: string;
+    /** Hierarchical configuration path (e.g., 'system:app', 'kos:service:CANPumpMgr') */
+    path: string;
+    /** Observable configuration properties with current values */
+    props: KosData<Record<ConfigBeanKeys<T>, ConfigPropertyTypes>>;
+    /** Observable configuration properties with previous values (before last update) */
+    prevProps: KosData<Record<ConfigBeanKeys<T>, ConfigPropertyTypes>>;
+    /** Optional custom base path for configuration service endpoints */
+    serviceBasePath?: string;
+    /**
+     * @category Constructor
+     *
+     * @param modelId - the unique modelId for this Config Bean
+     * @param options - any options that should be merged into the Config Bean
+     * @params options.id - the unique id of the Config Bean
+     * @params options.name - the name of the Config Bean
+     *
+     */
+    constructor(modelId: string, options: IConfigBeanModelOptions);
+    /**
+     * Gets current configuration property values.
+     *
+     * @returns Object containing all configuration properties with their current values
+     *
+     * @example Access Configuration Values
+     * ```typescript
+     * const currentValues = systemConfig.values;
+     * console.log('Machine ID:', currentValues.machineId);
+     * console.log('Debug Mode:', currentValues.debugMode);
+     * ```
+     */
+    get values(): Record<keyof T, unknown>[keyof T][];
+    /**
+     * @internal
+     */
+    ready(): Promise<void>;
+    /**
+     * @internal
+     *
+     * @remarks
+     * No action is taken as part of the load lifecycle method.
+     *
+     * In future additional information about the workspace could be loaded
+     */
+    load(): Promise<void>;
+    /**
+     * Gets all available schema property keys.
+     *
+     * @returns Array of property keys from the configuration schema
+     */
+    get schemaKeys(): string[];
+    /**
+     * Retrieves schema definition for a specific property.
+     *
+     * @param key - Property key to get schema for
+     * @returns Schema definition if found, undefined otherwise
+     *
+     * @example Get Property Schema
+     * ```typescript
+     * const schema = systemConfig.getSchemaForProperty('debugMode');
+     * if (schema) {
+     *   console.log('Type:', schema.type);
+     *   console.log('Description:', schema.description);
+     * }
+     * ```
+     */
+    getSchemaForProperty(key: string): import('../../services/config-bean').SchemaNodeDef | undefined;
+    /**
+     * Updates a specific configuration property value.
+     *
+     * @category Action
+     *
+     * @param key - The configuration property key to update
+     * @param value - The new value to set for the property
+     *
+     * @example Update Configuration Property
+     * ```typescript
+     * await systemConfig.updateProperty('debugMode', true);
+     * await systemConfig.updateProperty('machineId', 'MACHINE-001');
+     * ```
+     */
+    updateProperty(key: ConfigBeanKeys<T>, value: ConfigPropertyTypes): Promise<void>;
+    /**
+     * @category Action
+     *
+     * @remark
+     * Updates the current Config Bean representation in the backend.
+     *
+     * If a service was passed in as part of the options in the constructor
+     * then it will be used.  Otherwise the default services will be invoked.
+     *
+     * @see modifyConfigBeanService
+     */
+    updateConfigBean(): Promise<void>;
+    /**
+     * @category Subscription
+     * Updates the Config Bean model when a `/kos/config/{path}` event
+     * is received from the server.
+     *
+     * @param configBean - the Config Bean that was updated.
+     * @see ConfigBeanResponse
+     */
+    handleConfigBeanUpdated(configBean: ConfigBeanUpdateResponse): void;
+}
+export declare const ConfigBean: KosModelRegistrationFactory<IConfigBeanModel<any>, IConfigBeanModelOptions>;
+export {};
+//# sourceMappingURL=config-bean-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config-bean-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/config-bean/config-bean-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,OAAO,EACP,oBAAoB,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAIL,2BAA2B,EAG5B,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,cAAc,EACd,uBAAuB,EACxB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAGL,KAAK,wBAAwB,EAE9B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAO/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI,oBAAoB,CACrE,mBAAmB,CAAC,CAAC,CAAC,CACvB,CAAC;AAYF,eAAO,MAAM,sBAAsB,sBAAsB,CAAC;AAK1D;;;GAGG;AACH,cACM,mBAAmB,CAAC,CAAC,SAAS,EAAE,GAAG,GAAG,CAAE,YAAW,aAAa;IACpE,yDAAyD;IACzD,OAAO,CAAC,iBAAiB,CAAiC;IAE1D,0DAA0D;IAC1D,OAAO,CAAC,cAAc,CAA8B;IAEpD,oEAAoE;IACpE,OAAO,CAAC,OAAO,CAAC,CAAiB;IACjC,8DAA8D;IAC9D,EAAE,EAAE,MAAM,CAAC;IACX,qFAAqF;IACrF,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAE/D,oFAAoF;IACpF,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAEnE,oEAAoE;IACpE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;OAQG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB;IAqB7D;;;;;;;;;;;OAWG;IACH,IAAI,MAAM,wCAET;IAED;;OAEG;IACG,KAAK;IAIX;;;;;;;OAOG;IACG,IAAI;IAgBV;;;;OAIG;IACH,IAAI,UAAU,aAEb;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAC,GAAG,EAAE,MAAM;IAahC;;;;;;;;;;;;;OAaG;IACG,cAAc,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,mBAAmB;IAIvE;;;;;;;;;;OAUG;IACG,gBAAgB;IAOtB;;;;;;;OAOG;IAKH,uBAAuB,CAAC,UAAU,EAAE,wBAAwB;CAG7D;AAED,eAAO,MAAM,UAAU,6EAMrB,CAAC"}

package/models/models/config-bean/config-bean-types.d.ts

@@ -0,0 +1,69 @@
+import { ConfigBeanRequest, ConfigBeanResponse } from '../../services/config-bean';
+import { KosServiceResponse } from '../../../core';
+
+/**
+ * Actions that can be optionally passed into a ConfigBeanModel via
+ * the options parameter and can override the default service to be called.
+ *
+ * @remarks
+ * It is expected that implementations of `IKosDataModel` will have default
+ * implementations of services that can be used in the event that these overrides are
+ * not provided
+ *
+ * @group KOS Model
+ * @category Configuration
+ */
+export interface IConfigBeanModelOptionsActions {
+    /**
+     * Service to update an ConfigBeanModel on the backend.
+     *
+     * @remarks
+     * it is expected that the response will not provide any additional data and the
+     * system should only assume that a successful response means that the request was
+     * accepted by the backend.  Successful modification of the model will be broadcast
+     * via the appropriate Event Topic.
+     *
+     * @returns - a Promise that resolves to an empty `KosServiceResponse`
+     * @category Service
+     */
+    modifyConfigBean?: (id: string, model: ConfigBeanRequest) => Promise<KosServiceResponse<unknown> | undefined>;
+    /**
+     * Service to get a ConfigBeanModel on the backend.
+     *
+     * @remarks
+     * it is expected that the response will not provide any additional data and the
+     * system should only assume that a successful response means that the request was
+     * accepted by the backend.  Successful modification of the model will be broadcast
+     * via the appropriate Event Topic.
+     *
+     * @returns - a Promise that resolves to an empty `KosServiceResponse`
+     * @category Service
+     */
+    getConfigBean?: (id: string) => Promise<KosServiceResponse<ConfigBeanResponse> | undefined>;
+}
+/**
+ * Additional properties that can be passed into the constructor in order
+ * to set initial values
+ *
+ * @remarks
+ * Used to identify additional data that can be set on the model during
+ * instantiation.  It is expected that implementers will set these properties
+ * in the constructor.  The value <strong>might</strong> be overriden by
+ * subsequent lifecycle methods or updates.
+ *
+ * @group KOS Model
+ * @category Configuration
+ * @internal
+ */
+export interface IConfigBeanModelOptions extends Partial<IConfigBeanModelOptionsActions> {
+    serviceBasePath?: string;
+    path: string;
+}
+export type ConfigBeanKeys<T> = keyof T;
+/**
+ * Represents the public interface of a `IConfigBeanModel`
+ *
+ * @group KOS Model
+ * @category Configuration
+ */
+//# sourceMappingURL=config-bean-types.d.ts.map

package/models/models/config-bean/config-bean-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-bean-types.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/config-bean/config-bean-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,8BAA8B;IAC7C;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,CACjB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,iBAAiB,KACrB,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,CAAC;IAEtD;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,EAAE,CACd,EAAE,EAAE,MAAM,KACP,OAAO,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,GAAG,SAAS,CAAC,CAAC;CAClE;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,uBACf,SAAQ,OAAO,CAAC,8BAA8B,CAAC;IAC/C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC;AACxC;;;;;GAKG"}

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

@@ -0,0 +1,4 @@
+export { ConfigBean, type IConfigBeanModel } from './config-bean-model';
+export * from './config-bean-model-builder';
+export type { IConfigBeanModelOptions } from './config-bean-types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/config-bean/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACxE,cAAc,6BAA6B,CAAC;AAC5C,YAAY,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC"}

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

@@ -0,0 +1,33 @@
+import { ConfigBeanRequest, ConfigBeanResponse } from '../../../services/config-bean';
+import { KosServiceResponse } from '../../../../core';
+
+
+/**
+ * Configuration options for ConfigBeanModel instances.
+ *
+ * Specifies which configuration path to access and optionally provides custom
+ * service implementations for testing or alternative backends.
+ *
+ * @category Model Configuration
+ * @category System Integration
+ */
+export interface IConfigBeanModelOptions {
+  /** The hierarchical configuration path using colon-separated notation (e.g., 'system:app', 'kos:service:CANPumpMgr') */
+  path: string;
+
+  /** Optional custom base path for configuration service endpoints */
+  serviceBasePath?: string;
+
+  /** Optional custom service implementation for retrieving configuration data */
+  getConfigBean?: (
+    path: string,
+    serviceBasePath?: string
+  ) => Promise<KosServiceResponse<ConfigBeanResponse> | undefined>;
+
+  /** Optional custom service implementation for updating configuration data */
+  modifyConfigBean?: (
+    path: string,
+    data: ConfigBeanRequest,
+    serviceBasePath?: string
+  ) => Promise<KosServiceResponse<unknown> | undefined>;
+}

package/models/models/config-bean-prop/config-bean-prop-model.d.ts

@@ -0,0 +1,197 @@
+import { ConfigBeanPropOptions, ConfigPropConverter, FormatOptions, KosConfigProperty, OptionsExpander, OptionsType } from './types';
+import { ConfigPropertyTypes } from '../types';
+import { UnitSource } from '../region-info/types';
+import { RegionInfoModel } from '../region-info';
+import { IConfigBeanModel } from '../config-bean/config-bean-model';
+import { UnitConverter } from '../../decorators/kos-config-bean-prop';
+
+/**
+ * @ignore
+ * @internal
+ */
+declare class KosConfigPropertyImpl implements KosConfigProperty {
+    id: string;
+    path: string;
+    attribute: string;
+    converter?: ConfigPropConverter;
+    formatter?: FormatOptions;
+    optionsExpander?: OptionsExpander;
+    serviceBasePath?: string;
+    regionInfo: RegionInfoModel;
+    bean: IConfigBeanModel;
+    constructor(modelId: string, options: ConfigBeanPropOptions);
+    /**
+     * For cases where the default unit system is used, this method will return
+     * the number of decimal places to use for the given measure.
+     * @param measure the measure to get the default decimal places for
+     * @param unitSystem the unit system to use
+     * @returns the number of decimal places to use for the given measure
+     * @throws Error if measure is not provided
+     **/
+    getDefaultUnitDecimalPlaces(measure: string, unitSystem: string, unit?: string): number;
+    /**
+     * For cases where the default unit system is used, this method will return
+     * the default unit for the given measure.
+     * @param measure the measure to get the default unit for
+     * @param unitSystem the unit system to use
+     * @returns the default unit for the given measure
+     * @throws Error if measure is not provided
+     * @throws Error if unitSystem is not provided
+     * @throws Error if the default unit for the given measure is not found
+     **/
+    getDefaultUnitForMeasure(measure: string, unitSystem: string): string;
+    /**
+     * Gets the schema data type for this property.
+     *
+     * @returns Schema type string (e.g., "String", "Number", "Boolean", "enum")
+     */
+    get schemaType(): import('../../services/config-bean').SchemaNodeType | "enum";
+    /**
+     * Gets the schema format hint for this property.
+     *
+     * @returns Format string (e.g., "second", "milliliter", "hour") or empty string if not specified
+     */
+    get schemaFormat(): string;
+    /**
+     * Gets available options for enumerated properties.
+     *
+     * @returns Array of options with label/value pairs for dropdowns and selection controls
+     *
+     * @example Get Property Options
+     * ```typescript
+     * const options = statusProperty.options;
+     * // Returns: [
+     * //   { label: "Active", value: "active" },
+     * //   { label: "Inactive", value: "inactive" }
+     * // ]
+     * ```
+     */
+    get options(): OptionsType[];
+    convertUnit(converter?: UnitConverter, defaultSystem?: string, defaultMeasure?: string): {
+        measure: string | undefined;
+        system: string | undefined;
+        unit: string | undefined;
+    };
+    getConverterUnits(): {
+        backend: UnitSource;
+        display: {
+            measure: string | undefined;
+            system: string | undefined;
+            unit: string | undefined;
+        };
+    };
+    /**
+     * Sets the configuration property value with automatic unit conversion.
+     *
+     * @param value - The new value to set (in regional units)
+     *
+     * @example Update Property Value
+     * ```typescript
+     * pumpRateProperty.value = 1.2; // Sets rate to 1.2 mL/s (converted to backend units)
+     * ```
+     */
+    set value(value: ConfigPropertyTypes);
+    /**
+     * Gets the configuration property value converted to regional units.
+     *
+     * @returns Property value in regional display units
+     *
+     * @example Get Property Value
+     * ```typescript
+     * const currentRate = pumpRateProperty.value; // Gets rate in mL/s (regional units)
+     * ```
+     */
+    get value(): ConfigPropertyTypes;
+    /**
+     * Gets the raw backend value without unit conversion.
+     *
+     * @returns Raw property value as stored in backend (typically SI units)
+     */
+    get rawValue(): unknown;
+    /**
+     * Gets the property value with appropriate decimal precision for display.
+     *
+     * @returns Property value formatted with significant digits based on regional settings
+     */
+    get significantValue(): unknown;
+    /**
+     * Gets the previous property value before the last update.
+     *
+     * @returns Previous property value in regional display units
+     *
+     * @example Track Value Changes
+     * ```typescript
+     * const oldValue = pumpRateProperty.previousValue; // Previous rate value
+     * const newValue = pumpRateProperty.value; // Current rate value
+     * console.log(`Rate changed from ${oldValue} to ${newValue}`);
+     * ```
+     */
+    get previousValue(): {};
+    getValue(current: boolean): {};
+    /**
+     * @internal
+     */
+    activate(): Promise<void>;
+    /**
+     * Gets the formatted display string with units and localization.
+     *
+     * @returns Localized string representation with appropriate units (e.g., "1.2 mL/s", "150 °F")
+     *
+     * @example Display Formatted Value
+     * ```typescript
+     * const display = temperatureProperty.displayValue; // "72.5 °F"
+     * const rate = pumpRateProperty.displayValue; // "1.2 mL/s"
+     * ```
+     */
+    get displayValue(): string;
+    /**
+     * Gets the unit of measure for the property value.
+     *
+     * @returns Unit string (e.g., "°F", "mL/s", "seconds") or empty string for unitless properties
+     *
+     * @example Get Property Unit
+     * ```typescript
+     * const unit = temperatureProperty.unit; // "°F" or "°C" based on regional settings
+     * const rateUnit = pumpRateProperty.unit; // "mL/s"
+     * ```
+     */
+    get unit(): string | undefined;
+    /**
+     * Gets display formatting options from the backend schema.
+     *
+     * @returns Display options object with formatting preferences (decimals, style, etc.)
+     */
+    get displayOptions(): import('../../services/config-bean').SchemaOptionsType | undefined;
+    private getMeasureFromFormat;
+    private getConverterFromFormat;
+    private getDefaultUnit;
+    getFormatterOptions(converter?: ConfigPropConverter): Intl.NumberFormat | null;
+    private getConverter;
+    /**
+     * Updates the configuration property value with automatic unit conversion.
+     *
+     * @param value - The new value to set (in regional display units)
+     *
+     * @example Update Property
+     * ```typescript
+     * // Set temperature in Fahrenheit (regional unit)
+     * await temperatureProperty.updateProperty(75.5);
+     *
+     * // Set pump rate in mL/s (regional unit)
+     * await pumpRateProperty.updateProperty(1.2);
+     * ```
+     */
+    updateProperty(value: ConfigPropertyTypes): Promise<void>;
+}
+declare const Registration: {
+    registration: {
+        "config-bean-prop-model": {
+            class: typeof KosConfigPropertyImpl;
+            singleton: boolean;
+        };
+    };
+    type: string;
+    factory: (id: string) => (options?: ConfigBeanPropOptions | undefined, parentId?: string | undefined) => KosConfigProperty<unknown>;
+};
+export default Registration;
+//# sourceMappingURL=config-bean-prop-model.d.ts.map

package/models/models/config-bean-prop/config-bean-prop-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-bean-prop-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/config-bean-prop/config-bean-prop-model.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAS3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAc,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAKpD,OAAO,KAAK,EACV,qBAAqB,EACrB,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,WAAW,EACZ,MAAM,SAAS,CAAC;AAmDjB;;;GAGG;AACH,cACM,qBAAsB,YAAW,iBAAiB;IACtD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,UAAU,EAAG,eAAe,CAAC;IAG7B,IAAI,EAAG,gBAAgB,CAAC;gBAEZ,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB;IAY3D;;;;;;;QAOI;IACJ,2BAA2B,CACzB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,IAAI,CAAC,EAAE,MAAM;IAgBf;;;;;;;;;QASI;IACJ,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAW5D;;;;OAIG;IACH,IAAI,UAAU,iEAOb;IAED;;;;OAIG;IACH,IAAI,YAAY,WAMf;IAED;;;;;;;;;;;;;OAaG;IACH,IAAI,OAAO,kBAwBV;IAED,WAAW,CACT,SAAS,CAAC,EAAE,aAAa,EACzB,aAAa,CAAC,EAAE,MAAM,EACtB,cAAc,CAAC,EAAE,MAAM;;;;;IAazB,iBAAiB;;;;;;;;IAajB;;;;;;;;;OASG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,mBAAmB,EAEnC;IAED;;;;;;;;;OASG;IACH,IAAI,KAAK,IAdQ,mBAAmB,CAgBnC;IAED;;;;OAIG;IACH,IAAI,QAAQ,YAEX;IAED;;;;OAIG;IACH,IAAI,gBAAgB,YA8BnB;IAED;;;;;;;;;;;OAWG;IACH,IAAI,aAAa,OAEhB;IAED,QAAQ,CAAC,OAAO,EAAE,OAAO;IAczB;;OAEG;IACG,QAAQ;IAId;;;;;;;;;;OAUG;IACH,IAAI,YAAY,WA2Bf;IAED;;;;;;;;;;OAUG;IACH,IAAI,IAAI,uBAWP;IAED;;;;OAIG;IACH,IAAI,cAAc,uEAMjB;IAED,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,sBAAsB;IAW9B,OAAO,CAAC,cAAc;IAgBtB,mBAAmB,CAAC,SAAS,CAAC,EAAE,mBAAmB;IAuDnD,OAAO,CAAC,YAAY;IAsDpB;;;;;;;;;;;;;OAaG;IACG,cAAc,CAAC,KAAK,EAAE,mBAAmB;CAgBhD;AAED,QAAA,MAAM,YAAY;;;;;;;;;CAWjB,CAAC;AACF,eAAe,YAAY,CAAC"}

package/models/models/config-bean-prop/config-options-factory.d.ts

@@ -0,0 +1,6 @@
+import { UnitConversionSource } from '../../utils/conversion-utils';
+import { SchemaNodeDef } from '../../services/config-bean';
+
+export declare const configOptionsFactory: (schema?: SchemaNodeDef, unitSystem?: string, from?: UnitConversionSource, to?: UnitConversionSource) => string[];
+export declare const displayOptionsFactory: (schema?: SchemaNodeDef, unitSystem?: string) => import('../../services/config-bean').SchemaOptionsType | undefined;
+//# sourceMappingURL=config-options-factory.d.ts.map

package/models/models/config-bean-prop/config-options-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-options-factory.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/config-bean-prop/config-options-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,aAAa,EACd,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAW,MAAM,8BAA8B,CAAC;AAgG7E,eAAO,MAAM,oBAAoB,YACtB,aAAa,eACT,MAAM,SACZ,oBAAoB,OACtB,oBAAoB,KACxB,MAAM,EA+BR,CAAC;AAEF,eAAO,MAAM,qBAAqB,YACvB,aAAa,eACT,MAAM,uEAgCpB,CAAC"}

package/models/models/config-bean-prop/index.d.ts

@@ -0,0 +1,3 @@
+export { default as KosConfigPropertySpec } from './config-bean-prop-model';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/models/models/config-bean-prop/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/config-bean-prop/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAC5E,mBAAmB,SAAS,CAAC"}