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

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

@@ -0,0 +1,373 @@
+import { FutureContainer, IFutureModel } from '../../future/future-types';
+import { FutureResponse } from '../../../services/future';
+import { IKosDataModel } from '../../../core';
+
+
+/**
+ * Configuration options for creating or updating a Trouble model.
+ *
+ * This interface defines all the properties that can be set when initializing
+ * a trouble instance. Troubles represent issues, alerts, or conditions that
+ * require attention in the KOS system.
+ *
+ * @template AdditionalData - Optional type parameter for domain-specific trouble data
+ *
+ * @example
+ * ```typescript
+ * const troubleOptions: TroubleOptions = {
+ *   id: 'low-fluid-001',
+ *   type: 'FLUID_LEVEL',
+ *   reason: 'Fluid level below minimum threshold',
+ *   rank: 7,
+ *   role: 'operator',
+ *   color: 'orange',
+ *   resolvable: true,
+ *   ifaces: ['fluid-monitor', 'alert-system'],
+ *   tags: ['maintenance', 'fluid', 'warning'],
+ *   createTime: new Date().toISOString()
+ * };
+ * ```
+ *
+ * @group KOS Model
+ * @category Types
+ */
+export interface TroubleOptions<AdditionalData extends object = any> {
+  /** Whether this trouble can be resolved through user action */
+  resolvable?: boolean;
+  /** Human-readable description of why the trouble occurred */
+  reason?: string;
+  /** ISO timestamp when the trouble was created */
+  createTime?: string;
+  /** List of interface identifiers this trouble affects */
+  ifaces: string[];
+  /** Unique identifier for the trouble instance */
+  id: string;
+  /** Priority rank from 1-10 (10 being most critical) */
+  rank: number;
+  /** User role required to view/resolve this trouble */
+  role: string;
+  /** Display color for UI representation (e.g., 'red', 'yellow', 'orange') */
+  color: string;
+  /** Client-specific data attached to the trouble */
+  clientData: unknown;
+  /** Classification type of the trouble (e.g., 'ERROR', 'WARNING', 'INFO') */
+  type: string;
+  /** Searchable tags for categorizing troubles */
+  tags: string[];
+  /** Additional information about the trouble state */
+  info: unknown;
+  /** Optional grouping identifier for related troubles */
+  group?: string;
+  /** Service path for the trouble instance */
+  servicePath?: string;
+  /** Index signature for additional domain-specific data */
+  [key: keyof AdditionalData]: AdditionalData[key];
+}
+
+/**
+ * Represents a trouble (issue, alert, or condition) in the KOS system.
+ *
+ * TroubleModel is the core interface for managing system issues, warnings, and
+ * alerts throughout the KOS platform. It provides a unified way to track,
+ * display, resolve, and defer various types of operational issues.
+ *
+ * ## Key Features
+ * - **Priority ranking** - Troubles are ranked 1-10 for severity
+ * - **Role-based visibility** - Troubles can be filtered by user role
+ * - **Resolution support** - Resolvable troubles can be cleared through actions
+ * - **Deferral capability** - Troubles can be temporarily deferred
+ * - **Future integration** - Async resolution through futures
+ * - **Type categorization** - Troubles grouped by type for filtering
+ * - **Visual indicators** - Color coding for UI representation
+ *
+ * @template AdditionalData - Type parameter for domain-specific trouble data
+ *
+ * @interface
+ * @example Basic Usage
+ * ```typescript
+ * function handleTrouble(trouble: TroubleModel) {
+ *   if (trouble.rank >= 8) {
+ *     console.error(`Critical trouble: ${trouble.reason}`);
+ *   }
+ *
+ *   if (trouble.resolvable) {
+ *     const futureResponse = await trouble.resolve();
+ *   }
+ * }
+ * ```
+ *
+ * @useDeclaredType
+ * @group KOS Model
+ * @category Trouble Management
+ *
+ * @see {@link TroubleAware} - Interface for models that can have troubles
+ * @see {@link DeferAware} - Deferral capabilities
+ * @see {@link ResolveAware} - Resolution capabilities
+ */
+export interface TroubleModel<AdditionalData extends object = any>
+  extends IKosDataModel,
+    DeferAware,
+    FutureContainer {
+  /** Unique identifier for the trouble instance */
+  id: string;
+  /** Whether this trouble can be resolved through user action */
+  resolvable?: boolean;
+  /** Human-readable description of why the trouble occurred */
+  reason?: string;
+  /** ISO timestamp when the trouble was created */
+  createTime?: string;
+  /** List of interface identifiers this trouble affects */
+  ifaces: string[];
+  /** Client-specific data attached to the trouble */
+  clientData: unknown;
+  /** Associated future for async resolution operations */
+  future?: IFutureModel;
+  /** Classification type of the trouble (e.g., 'ERROR', 'WARNING', 'INFO') */
+  type: string;
+  /** Searchable tags for categorizing troubles */
+  tags: string[];
+  /** Additional information about the trouble state */
+  info: unknown;
+  /** Original trouble ID before any transformations */
+  rawId: string;
+  /** Resolves the trouble, returning a promise with the resolution response */
+  resolve: () => Promise<FutureResponse | undefined>;
+  /** Domain-specific additional data attached to the trouble */
+  data: AdditionalData;
+  /** Priority rank from 1-10 (10 being most critical) */
+  rank: number;
+  /** User role required to view/resolve this trouble */
+  role: string;
+  /** Display color for UI representation (e.g., 'red', 'yellow', 'orange') */
+  color: string;
+  /** Whether this trouble has been deferred */
+  deferred: boolean;
+  /** Optional grouping identifier for related troubles */
+  group?: string;
+}
+
+/**
+ * Domain-specific trouble data for handle-related issues.
+ *
+ * @group KOS Model
+ * @category Domain Data
+ */
+export interface HandleTroubleData {
+  /** Path to the affected handle component */
+  path: string;
+}
+
+/**
+ * Domain-specific trouble data for nozzle-related issues.
+ *
+ * @group KOS Model
+ * @category Domain Data
+ */
+export interface NozzleTroubleData {
+  /** Path to the affected nozzle component */
+  nozzlePath: string;
+}
+
+/**
+ * Domain-specific trouble data for container-related issues.
+ *
+ * @group KOS Model
+ * @category Domain Data
+ */
+export interface ContainerTroubleData {
+  /** Identifier of the affected container */
+  containerId: string;
+  /** List of ingredients involved in the trouble */
+  ingredients: string[];
+}
+
+/**
+ * Interface for objects that can be resolved asynchronously.
+ *
+ * Provides a standard resolution mechanism for troubles and other
+ * resolvable conditions in the KOS system. Resolution typically
+ * involves sending a command to clear the condition.
+ *
+ * @example
+ * ```typescript
+ * class ResolvableTrouble implements ResolveAware {
+ *   async resolve(tracker?: string) {
+ *     console.log(`Resolving with tracker: ${tracker}`);
+ *     const response = await sendResolveCommand(this.id, tracker);
+ *     return response;
+ *   }
+ * }
+ * ```
+ *
+ * @group KOS Model
+ * @category Capabilities
+ */
+export interface ResolveAware {
+  /**
+   * Resolves the condition asynchronously.
+   *
+   * @param tracker - Optional tracking identifier for the resolution operation
+   * @returns Promise resolving to the future response, or undefined if resolution fails
+   */
+  resolve: (tracker?: string) => Promise<FutureResponse | undefined>;
+}
+
+/**
+ * Interface for objects that support deferral of actions.
+ *
+ * Deferral allows temporary postponement of trouble handling or
+ * other actions. Deferred items can be cleared to restore normal
+ * processing. This is useful for managing low-priority issues
+ * during critical operations.
+ *
+ * @example
+ * ```typescript
+ * class DeferrableTrouble implements DeferAware {
+ *   shouldDefer = false;
+ *   deferred = false;
+ *
+ *   defer() {
+ *     this.deferred = true;
+ *     console.log('Trouble deferred');
+ *   }
+ *
+ *   clearDefer() {
+ *     this.deferred = false;
+ *     console.log('Deferral cleared');
+ *   }
+ * }
+ *
+ * // Usage
+ * if (trouble.shouldDefer && !trouble.deferred) {
+ *   trouble.defer();
+ * }
+ * ```
+ *
+ * @group KOS Model
+ * @category Capabilities
+ */
+export interface DeferAware {
+  /** Whether this item should be deferred based on current conditions */
+  shouldDefer: boolean;
+  /** Current deferral state */
+  deferred: boolean;
+  /** Defers the item, preventing normal processing */
+  defer: VoidFunction;
+  /** Clears the deferral, allowing normal processing to resume */
+  clearDefer: VoidFunction;
+}
+/**
+ * Interface for models that can track and expose trouble states.
+ *
+ * TroubleAware provides a standardized way for KOS models to expose
+ * their trouble states, making it easy to monitor, display, and react
+ * to issues throughout the system. Any model implementing this interface
+ * can be monitored for troubles and integrated with trouble management UI.
+ *
+ * ## Key Concepts
+ * - **Trouble aggregation** - Models can aggregate troubles from multiple sources
+ * - **Status summary** - Provides a single status string for quick checks
+ * - **Type grouping** - Troubles organized by type for filtering and display
+ * - **Read-only access** - Troubles are exposed as readonly for safety
+ *
+ * @example
+ * ```typescript
+ * // Check if a model has troubles
+ * function checkModelHealth(model: TroubleAware) {
+ *   if (model.troubles.length > 0) {
+ *     console.warn(`Model has ${model.troubles.length} troubles`);
+ *     console.warn(`Status: ${model.troubleStatus}`);
+ *
+ *     // Check specific trouble types
+ *     const errors = model.troublesByType['ERROR'] || [];
+ *     const warnings = model.troublesByType['WARNING'] || [];
+ *
+ *     if (errors.length > 0) {
+ *       handleCriticalErrors(errors);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // React component using TroubleAware
+ * const TroubleIndicator: React.FC<{ model: TroubleAware }> = ({ model }) => {
+ *   const troubles = model.troubles;
+ *   const highPriority = troubles.filter(t => t.rank >= 7);
+ *
+ *   if (troubles.length === 0) {
+ *     return <StatusIcon color="green" />;
+ *   }
+ *
+ *   return (
+ *     <div className="trouble-indicator">
+ *       <StatusIcon color={highPriority.length > 0 ? 'red' : 'yellow'} />
+ *       <span>{model.troubleStatus}</span>
+ *       <Badge count={troubles.length} />
+ *     </div>
+ *   );
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Implementing TroubleAware
+ * class MyModel implements TroubleAware {
+ *   private _troubles: TroubleModel[] = [];
+ *
+ *   get troubles(): readonly TroubleModel[] {
+ *     return this._troubles;
+ *   }
+ *
+ *   get troubleStatus(): string {
+ *     if (this._troubles.length === 0) return 'OK';
+ *     const highest = this._troubles.reduce((max, t) =>
+ *       t.rank > max.rank ? t : max
+ *     );
+ *     return highest.reason || 'Unknown issue';
+ *   }
+ *
+ *   get troublesByType(): Record<string, TroubleModel[]> {
+ *     return this._troubles.reduce((groups, trouble) => {
+ *       const type = trouble.type;
+ *       groups[type] = groups[type] || [];
+ *       groups[type].push(trouble);
+ *       return groups;
+ *     }, {} as Record<string, TroubleModel[]>);
+ *   }
+ * }
+ * ```
+ *
+ * @group KOS Model
+ * @category Interfaces
+ *
+ * @see {@link TroubleModel} - The trouble model interface
+ * @see {@link isTroubleAware} - Type guard for checking TroubleAware
+ * @see {@link useTroubleDecoration} - Hook for trouble-based styling
+ */
+export interface TroubleAware {
+  /**
+   * Array of troubles directly related to this model.
+   * Troubles are typically sorted by rank (highest priority first).
+   */
+  readonly troubles: TroubleModel[];
+
+  /**
+   * Summary status string representing the highest priority trouble.
+   * Returns a human-readable status or 'OK' if no troubles exist.
+   */
+  readonly troubleStatus: string;
+
+  /**
+   * Troubles organized by their type property.
+   * Useful for filtering and categorized display of issues.
+   *
+   * @example
+   * ```typescript
+   * const errorTroubles = model.troublesByType['ERROR'] || [];
+   * const warningTroubles = model.troublesByType['WARNING'] || [];
+   * ```
+   */
+  readonly troublesByType: Record<string, TroubleModel[]>;
+}

package/models/models/trouble/utils/is-trouble-aware.d.ts

@@ -0,0 +1,98 @@
+import { TroubleAware } from '../types';
+
+/**
+ * Type guard function to check if an object implements the TroubleAware interface.
+ *
+ * This function performs runtime validation to determine whether a given object
+ * has the necessary properties and structure to be considered trouble-aware.
+ * It checks for the presence of both the `troubles` array and `troublesByType`
+ * object, which are required by the TroubleAware interface.
+ *
+ * @category Utilities
+ * @category Trouble Management
+ *
+ * @param obj - The object to check for trouble awareness. Can be any type.
+ *
+ * @returns `true` if the object implements TroubleAware interface, `false` otherwise.
+ *          When this function returns true, TypeScript will narrow the type of `obj`
+ *          to `TroubleAware` in the current scope.
+ *
+ * @example
+ * ```typescript
+ * // Basic type guard usage
+ * function processModel(model: IKosDataModel) {
+ *   if (isTroubleAware(model)) {
+ *     // TypeScript now knows model has troubles property
+ *     console.log(`Found ${model.troubles.length} troubles`);
+ *     console.log(`Trouble status: ${model.troubleStatus}`);
+ *   } else {
+ *     console.log('Model is not trouble-aware');
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with React hooks for conditional trouble handling
+ * const TroubleDisplay: React.FC<{ model: IKosDataModel }> = ({ model }) => {
+ *   if (!isTroubleAware(model)) {
+ *     return <div>No trouble tracking available</div>;
+ *   }
+ *
+ *   // Safe to access trouble properties here
+ *   const criticalTroubles = model.troubles.filter(t => t.rank > 8);
+ *   const troubleTypes = Object.keys(model.troublesByType);
+ *
+ *   return (
+ *     <div>
+ *       <h3>Trouble Status: {model.troubleStatus}</h3>
+ *       <p>Critical issues: {criticalTroubles.length}</p>
+ *       <p>Types: {troubleTypes.join(', ')}</p>
+ *     </div>
+ *   );
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Filtering trouble-aware models from a collection
+ * const models: IKosDataModel[] = getAllModels();
+ * const troubleAwareModels = models.filter(isTroubleAware);
+ *
+ * // TypeScript knows troubleAwareModels is TroubleAware[]
+ * troubleAwareModels.forEach(model => {
+ *   const troublesByType = model.troublesByType;
+ *   Object.entries(troublesByType).forEach(([type, troubles]) => {
+ *     console.log(`Type ${type}: ${troubles.length} troubles`);
+ *   });
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Early return pattern for non-trouble-aware models
+ * function calculateTroubleSeverity(model: any): number {
+ *   if (!isTroubleAware(model)) {
+ *     return 0; // No troubles means no severity
+ *   }
+ *
+ *   // Calculate weighted severity based on trouble ranks
+ *   return model.troubles.reduce((total, trouble) => {
+ *     return total + (trouble.rank * (trouble.deferred ? 0.5 : 1));
+ *   }, 0);
+ * }
+ * ```
+ *
+ * @remarks
+ * - This is a runtime check, not a compile-time check
+ * - The function checks for structural compatibility, not nominal typing
+ * - It validates that `troubles` is specifically an Array instance, not just array-like
+ * - The `troublesByType` property must be an object (not null or undefined)
+ * - Does not validate the contents of the arrays or object, only their presence and type
+ * - This function is commonly used as a guard before accessing trouble-related properties
+ *
+ * @see {@link TroubleAware} - The interface this function checks for
+ * @see {@link useTroubleDecoration} - Hook that uses this guard internally
+ */
+export declare function isTroubleAware(obj?: any): obj is TroubleAware;
+//# sourceMappingURL=is-trouble-aware.d.ts.map

package/models/models/trouble/utils/is-trouble-aware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-trouble-aware.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble/utils/is-trouble-aware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AACH,wBAAgB,cAAc,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,GAAG,IAAI,YAAY,CAO7D"}

package/models/models/trouble/utils/trouble-data-extension.d.ts

@@ -0,0 +1,5 @@
+import { TroubleModel } from '../types';
+
+export declare const EXTENSION_TROUBLE_DATA_MAPPER = "troubleDataMapper";
+export type TroubleDataMapper = (trouble: TroubleModel) => Promise<Record<string, any>>;
+//# sourceMappingURL=trouble-data-extension.d.ts.map

package/models/models/trouble/utils/trouble-data-extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trouble-data-extension.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble/utils/trouble-data-extension.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,eAAO,MAAM,6BAA6B,sBAAsB,CAAC;AACjE,MAAM,MAAM,iBAAiB,GAAG,CAC9B,OAAO,EAAE,YAAY,KAClB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC"}

package/models/models/trouble/utils/trouble-extension.d.ts

@@ -0,0 +1,5 @@
+import { TroubleModel } from '../types';
+
+export declare const EXTENSION_TROUBLE_MAPPER = "troubleMapper";
+export type TroubleMapper = (trouble: TroubleModel) => Promise<string[]>;
+//# sourceMappingURL=trouble-extension.d.ts.map

package/models/models/trouble/utils/trouble-extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trouble-extension.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble/utils/trouble-extension.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,eAAO,MAAM,wBAAwB,kBAAkB,CAAC;AACxD,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC"}

package/models/models/trouble/utils/trouble-reducer.d.ts

@@ -0,0 +1,4 @@
+import { TroubleModel } from '../types';
+
+export declare const troubleByTypeReducer: (acc: Record<string, TroubleModel[]>, trouble: TroubleModel) => Record<string, TroubleModel<any>[]>;
+//# sourceMappingURL=trouble-reducer.d.ts.map

package/models/models/trouble/utils/trouble-reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trouble-reducer.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble/utils/trouble-reducer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,eAAO,MAAM,oBAAoB,QAC1B,OAAO,MAAM,EAAE,YAAY,EAAE,CAAC,WAC1B,YAAY,wCAQtB,CAAC"}

package/models/models/trouble-container/index.d.ts

@@ -0,0 +1,5 @@
+import { TroubleContainerModelImpl } from './trouble-container-model';
+export { Troubles, type TroubleContainerModel, } from './trouble-container-model';
+export type { TroubleContainerOptions } from './types';
+export declare const TroubleContainer: import('../../..').KosModelRegistrationType<TroubleContainerModelImpl, import('./types').TroubleContainerOptions>;
+//# sourceMappingURL=index.d.ts.map

package/models/models/trouble-container/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble-container/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,KAAK,qBAAqB,GAC3B,MAAM,2BAA2B,CAAC;AAEnC,YAAY,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEvD,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,eAAO,MAAM,gBAAgB,mHAAyC,CAAC"}

package/models/models/trouble-container/trouble-container-model.d.ts

@@ -0,0 +1,27 @@
+import { TroubleContainerOptions } from './types';
+import { TroubleModel } from '../trouble/types';
+import { TroubleResponse } from '../trouble/services';
+import { IKosDataModel, IKosIdentifiable, KosContainerAwareWithProp, KosLoggerAware, KosModelRegistrationType, PublicModelInterface } from '../../../core';
+
+export declare const MODEL_TYPE = "trouble-container-model";
+export type TroubleContainerModel = PublicModelInterface<TroubleContainerModelImpl>;
+export interface TroubleContainerModelImpl extends KosContainerAwareWithProp<TroubleModel, "troubles">, KosLoggerAware {
+}
+export declare class Troubles {
+    static readonly INDEX_TROUBLES_BY_IFACE = "byIface";
+    static readonly INDEX_TROUBLES_BY_TYPE = "byType";
+    static readonly INDEX_TROUBLES_BY_GROUP = "byGroup";
+    static readonly INDEX_TROUBLES_BY_DEFERRED = "byDeferred";
+    static readonly SORT_KEY_RANK = "rank";
+    static readonly TROUBLES_DEFERRED = "true";
+}
+export declare class TroubleContainerModelImpl implements IKosIdentifiable, IKosDataModel {
+    static Registration: KosModelRegistrationType<TroubleContainerModelImpl, TroubleContainerOptions>;
+    id: string;
+    servicePath: string;
+    constructor(modelId: string, options: TroubleContainerOptions);
+    load(): Promise<void>;
+    handleTroubleRemoved(id: string): void;
+    handleTroubleAdded(trouble: TroubleResponse): void;
+}
+//# sourceMappingURL=trouble-container-model.d.ts.map

package/models/models/trouble-container/trouble-container-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trouble-container-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble-container/trouble-container-model.ts"],"names":[],"mappings":"AACA,OAAO,EAQL,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EAC1B,MAAM,eAAe,CAAC;AAQvB,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAExE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAqCvD,eAAO,MAAM,UAAU,4BAA4B,CAAC;AAEpD,MAAM,MAAM,qBAAqB,GAC/B,oBAAoB,CAAC,yBAAyB,CAAC,CAAC;AAClD,MAAM,WAAW,yBACf,SAAQ,yBAAyB,CAAC,YAAY,EAAE,UAAU,CAAC,EACzD,cAAc;CAAG;AACrB,qBAAa,QAAQ;IACnB,MAAM,CAAC,QAAQ,CAAC,uBAAuB,aAAa;IACpD,MAAM,CAAC,QAAQ,CAAC,sBAAsB,YAAY;IAClD,MAAM,CAAC,QAAQ,CAAC,uBAAuB,aAAa;IACpD,MAAM,CAAC,QAAQ,CAAC,0BAA0B,gBAAgB;IAC1D,MAAM,CAAC,QAAQ,CAAC,aAAa,UAAU;IACvC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,UAAU;CAC5C;AACD,qBAca,yBACX,YAAW,gBAAgB,EAAE,aAAa;IAE1C,MAAM,CAAC,YAAY,EAAE,wBAAwB,CAC3C,yBAAyB,EACzB,uBAAuB,CACxB,CAAC;IACF,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,SAAuB;gBACtB,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB;IAOvD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA4B3B,oBAAoB,CAAC,EAAE,EAAE,MAAM;IAW/B,kBAAkB,CAAC,OAAO,EAAE,eAAe;CAgB5C"}

package/models/models/trouble-container/trouble-utils.d.ts

@@ -0,0 +1,5 @@
+import { TroubleModel } from '../trouble/types';
+
+export declare const troublePathFactory: (trouble: TroubleModel) => Promise<string[]>;
+export declare const troubleDataFactory: (trouble: TroubleModel) => Promise<any>;
+//# sourceMappingURL=trouble-utils.d.ts.map

package/models/models/trouble-container/trouble-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trouble-utils.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/trouble-container/trouble-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,YAAY,EACb,MAAM,kBAAkB,CAAC;AAC1B,OAAO,yCAAyC,CAAC;AAEjD,OAAO,oCAAoC,CAAC;AAa5C,eAAO,MAAM,kBAAkB,YAAmB,YAAY,sBAqB7D,CAAC;AAEF,eAAO,MAAM,kBAAkB,YAAmB,YAAY,iBA2B7D,CAAC"}

package/models/models/trouble-container/types/index.d.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface TroubleContainerOptions {
+  servicePath?: string;
+}

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

@@ -0,0 +1,3 @@
+export type StatePropertyTypes = string | number | boolean | object | any;
+export type ConfigPropertyTypes = string | number | boolean | string[] | number[] | boolean[] | undefined | null | unknown;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,GAAG,CAAC;AAE1E,MAAM,MAAM,mBAAmB,GAC3B,MAAM,GACN,MAAM,GACN,OAAO,GACP,MAAM,EAAE,GACR,MAAM,EAAE,GACR,OAAO,EAAE,GACT,SAAS,GACT,IAAI,GACJ,OAAO,CAAC"}

package/models/models/usb-update/index.d.ts

@@ -0,0 +1,7 @@
+export { UsbUpdateContainer } from './usb-update-container-registration';
+export { UsbUpdate } from './usb-update-registration';
+export type * from './types';
+export type { UsbUpdateModel } from './usb-update-model';
+export type { UsbUpdateContainerModel } from './usb-update-container-model';
+export * as UsbUpdateServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/usb-update/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/usb-update/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,YAAY,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,KAAK,iBAAiB,MAAM,YAAY,CAAC"}

package/models/models/usb-update/services/index.d.ts

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

package/models/models/usb-update/services/index.d.ts.map

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

package/models/models/usb-update/services/usb-update-services.d.ts

@@ -0,0 +1,22 @@
+import { FutureResponse } from '../../../services/future';
+
+export interface UpdateNote {
+    summary: string;
+    details: string[];
+}
+export interface UsbUpdateResponse {
+    active: boolean;
+    blocked: boolean;
+    createTime: Date;
+    deviceId: string;
+    manifestId: string;
+    notes: UpdateNote[];
+}
+/**
+ * @category Service
+ * @internal
+ * Retrieves the initial usb-update data.
+ */
+export declare const getAvailableUpdates: () => Promise<UsbUpdateResponse[]>;
+export declare const installUpdate: (manifestId: string, deviceId: string, tracker: string) => Promise<FutureResponse>;
+//# sourceMappingURL=usb-update-services.d.ts.map

package/models/models/usb-update/services/usb-update-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usb-update-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/usb-update/services/usb-update-services.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAY/D,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,IAAI,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,oCAY/B,CAAC;AAEF,eAAO,MAAM,aAAa,eACZ,MAAM,YACR,MAAM,WACP,MAAM,KACd,QAAQ,cAAc,CAgBxB,CAAC"}

package/models/models/usb-update/types/index.d.ts

@@ -0,0 +1,14 @@
+import { UpdateNote } from '../services';
+
+
+export interface UsbUpdateOptions {
+  active: boolean;
+  blocked: boolean;
+  createTime: Date;
+  deviceId: string;
+  manifestId: string;
+  notes: UpdateNote[];
+}
+
+// ---------------  UsbUpdateContainer ---------------
+export interface UsbUpdateContainerOptions {}