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

package/models/models/device/device-registration.d.ts

@@ -0,0 +1,102 @@
+import { DeviceOptions } from './types';
+import { DeviceModel } from './device-model';
+import { SingletonKosModelRegistrationFactory } from '../../../core';
+
+/**
+ * # Device Model Registration Factory
+ *
+ * **KOS Device Identity and Node Configuration Management**
+ *
+ * The Device registration factory provides convenient methods for creating and working with DeviceModel instances.
+ * Device models handle device identity, hardware serial numbers, and node configuration within KOS deployments.
+ *
+ * ## Core Registration Properties
+ *
+ * ### type
+ *
+ * Model type identifier used for dependency injection and type narrowing.
+ * Essential for declaring model dependencies in other components.
+ *
+ * @example Model Dependency Declaration
+ * ```typescript
+ * @kosDependency({modelType: Device.type, id: "deviceId"})
+ * private deviceModel: DeviceModel;
+ * ```
+ *
+ * ### factory
+ *
+ * Creates DeviceModel instances with singleton behavior. Multiple calls return the same instance,
+ * ensuring system-wide device identity consistency.
+ *
+ * **Singleton Behavior**: Subsequent factory calls return existing instance; options ignored after first creation.
+ *
+ * @example Device Creation and Identity Access
+ * ```typescript
+ * const device = Device.factory({
+ *   serialNumber: 'KOS-DEVICE-001',
+ *   name: 'Production Dispenser Alpha',
+ *   nodeId: 'primary-controller'
+ * });
+ *
+ * // Access device identity
+ * console.log(`Device: ${device.name} (${device.serialNumber})`);
+ * console.log(`Node: ${device.nodeType}-${device.nodeName}`);
+ * ```
+ *
+ * @example Multi-node System Coordination
+ * ```typescript
+ * const primaryDevice = Device.factory({ nodeId: 'primary-main' });
+ * const backupDevice = Device.factory({ nodeId: 'secondary-backup' });
+ *
+ * // Coordinate based on node roles
+ * if (primaryDevice.nodeType === 'primary') {
+ *   // Handle primary node responsibilities
+ * }
+ * ```
+ *
+ * ### predicate
+ *
+ * [TypeScript type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates)
+ * for identifying and narrowing models to DeviceModel instances.
+ *
+ * @example Type Narrowing for Device Operations
+ * ```typescript
+ * const model: IKosDataModel = getModel(); // some model
+ *
+ * if (Device.predicate(model)) {
+ *   // Compiler now knows model is DeviceModel
+ *   console.log(`Device Serial: ${model.serialNumber}`);
+ *   model.updateModel({ name: 'Updated Name' });
+ * }
+ * ```
+ *
+ * ### registration
+ *
+ * Registration object for model registry integration. Provides all required information
+ * for registering the DeviceModelImpl implementation with the model registry.
+ *
+ * @example Model Registry Configuration
+ * ```typescript
+ * // registration.ts
+ * import { Device } from "@kos-ui/project-models";
+ * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
+ *
+ * KosModelRegistry.dispense
+ *   .models()
+ *   .model(Device);
+ * ```
+ *
+ * ## Singleton Architecture
+ *
+ * **Device models use singleton pattern** ensuring system-wide consistency:
+ * - Each device type has exactly one instance
+ * - Subsequent factory calls return existing instance
+ * - Options are ignored after initial creation
+ * - Uses model type as unique identifier
+ * - Guarantees device identity consistency across system
+ *
+ * @group KOS Model
+ * @category Device Data
+ */
+export declare const Device: SingletonKosModelRegistrationFactory<DeviceModel, DeviceOptions>;
+//# sourceMappingURL=device-registration.d.ts.map

package/models/models/device/device-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/device/device-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,eAAO,MAAM,MAAM,kEAMjB,CAAC"}

package/models/models/device/index.d.ts

@@ -0,0 +1,5 @@
+export { Device } from './device-registration';
+export type * from './types';
+export type { DeviceModel } from './device-model';
+export * as DeviceServices from './services';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/device/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,cAAc,MAAM,YAAY,CAAC"}

package/models/models/device/services/device-services.d.ts

@@ -0,0 +1,21 @@
+type SerialNumberResponse = [string | undefined, string | undefined];
+type DeviceResponse = [string, undefined] | [undefined, DevicePayload];
+type DevicePayload = {
+    serialNumber: string;
+    name: string;
+    nodeId: string;
+};
+/**
+ * @category Service
+ * @internal
+ * Retrieves the device serial number.
+ */
+export declare const getSerialNumber: () => Promise<SerialNumberResponse>;
+/**
+ * @category Service
+ * @internal
+ * Retrieves the initial device data.
+ */
+export declare const getDeviceDetails: () => Promise<DeviceResponse>;
+export {};
+//# sourceMappingURL=device-services.d.ts.map

package/models/models/device/services/device-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/device/services/device-services.ts"],"names":[],"mappings":"AAgBA,KAAK,oBAAoB,GAAG,CAAC,MAAM,GAAG,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAErE,KAAK,cAAc,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;AACvE,KAAK,aAAa,GAAG;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AACF;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAAa,QAAQ,oBAAoB,CAgBpE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,QAAa,QAAQ,cAAc,CAmB/D,CAAC"}

package/models/models/device/services/index.d.ts

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

package/models/models/device/services/index.d.ts.map

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

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

@@ -0,0 +1,46 @@
+/**
+ * Configuration options for Device model instances.
+ *
+ * Defines device identity and node-specific parameters for KOS device modeling.
+ * Device models represent the physical device identity and node configuration
+ * within a KOS system deployment.
+ *
+ * @example Basic Device Configuration
+ * ```typescript
+ * const deviceOptions: DeviceOptions = {
+ *   serialNumber: 'KOS-DEVICE-12345',
+ *   name: 'Main Beverage Dispenser',
+ *   nodeId: 'primary-node-01'
+ * };
+ *
+ * const device = Device.factory(deviceOptions);
+ * ```
+ *
+ * @group KOS Model
+ * @category Service Integration
+ */
+export interface DeviceOptions {
+  /**
+   * Unique device serial number from hardware.
+   *
+   * Retrieved from the device's hardware identification system.
+   * Used for warranty tracking, support, and device-specific configuration.
+   */
+  serialNumber?: string;
+
+  /**
+   * Human-readable device name for identification.
+   *
+   * Typically configured during device setup and used in administrative
+   * interfaces for device identification and management.
+   */
+  name?: string;
+
+  /**
+   * Node identifier within the KOS deployment.
+   *
+   * Identifies the specific node role and instance within a multi-node
+   * KOS deployment. Format typically follows 'type-instance' pattern.
+   */
+  nodeId?: string;
+}

package/models/models/future/future-aware.d.ts

@@ -0,0 +1,115 @@
+import { FutureAwareContainer, FutureContainer, IFutureModel, MultiFutureAware } from './future-types';
+
+/**
+ * Future handler for managing multiple concurrent long-running operations.
+ *
+ * Provides comprehensive lifecycle management for models that coordinate multiple
+ * device operations simultaneously. Each Future is tracked with its own alias
+ * and receives automatic progress updates and cleanup when operations complete.
+ *
+ * @example Managing Multiple Operations
+ * ```typescript
+ * @kosModel("device-maintenance-model")
+ * export class DeviceMaintenanceModel implements FutureContainer {
+ *   futureHandler: MultipleFutureHandler;
+ *
+ *   constructor(modelId: string, options: any, context: KosCreationContext) {
+ *     this.id = modelId;
+ *     this.futureHandler = new MultipleFutureHandler(this);
+ *   }
+ *
+ *   async startCalibration(deviceId: string): Promise<CalibrationResult> {
+ *     const future = await this.createFuture('/device/calibrate', { deviceId });
+ *     this.futureHandler.addFuture(future, `calibration-${deviceId}`);
+ *     return future;
+ *   }
+ *
+ *   async startCleaning(deviceId: string): Promise<CleaningResult> {
+ *     const future = await this.createFuture('/device/clean', { deviceId });
+ *     this.futureHandler.addFuture(future, `cleaning-${deviceId}`);
+ *     return future;
+ *   }
+ *
+ *   onFutureUpdate(future: IFutureModel): void {
+ *     // Handle progress updates from any managed Future
+ *     console.log(`${future.id}: ${future.progress}% complete`);
+ *   }
+ * }
+ * ```
+ *
+ * @group KOS Model
+ * @category Asynchronous Operations
+ */
+export declare class MultipleFutureHandler<T extends {} = Record<string, unknown>> implements FutureAwareContainer<T>, MultiFutureAware<T> {
+    private futures;
+    private defaultContext;
+    private context;
+    private disposers;
+    private container?;
+    constructor(container?: FutureContainer<T>, defaultContext?: string);
+    get allFutures(): IFutureModel<T>[];
+    get future(): IFutureModel<T> | undefined;
+    addFuture(future: IFutureModel<T>, alias?: string): void;
+    removeFuture(alias?: string): void;
+    getFuture(alias?: string): IFutureModel<T> | undefined;
+    get futureMap(): Map<string, IFutureModel<T>>;
+}
+/**
+ * Future handler for managing single long-running operations with simplified API.
+ *
+ * Provides streamlined lifecycle management for models that typically handle
+ * one operation at a time. Automatically tracks progress and provides reactive
+ * status information for UI integration.
+ *
+ * @example Single Operation Management
+ * ```typescript
+ * @kosModel("brewing-system-model")
+ * export class BrewingSystemModel implements FutureContainer {
+ *   futureHandler: FutureHandler;
+ *
+ *   constructor(modelId: string, options: any, context: KosCreationContext) {
+ *     this.id = modelId;
+ *     this.futureHandler = new FutureHandler(this);
+ *   }
+ *
+ *   async startBrewingCycle(recipe: Recipe): Promise<BrewingResult> {
+ *     const future = await this.createFuture('/brewing/start', { recipe });
+ *     this.futureHandler.addFuture(future);
+ *     return future;
+ *   }
+ *
+ *   get isOperationActive(): boolean {
+ *     return this.futureHandler.status !== 'NOT_RESOLVED';
+ *   }
+ *
+ *   get operationProgress(): number {
+ *     return this.futureHandler.progress;
+ *   }
+ *
+ *   onFutureUpdate(future: IFutureModel): void {
+ *     // Handle progress updates from the active Future
+ *     console.log(`Brewing: ${future.progress}% complete`);
+ *   }
+ * }
+ * ```
+ *
+ * @group KOS Model
+ * @category Asynchronous Operations
+ */
+export declare class FutureHandler<T extends object = Record<string, unknown>> implements FutureAwareContainer<T> {
+    private disposer?;
+    private _future?;
+    private container?;
+    constructor(container?: FutureContainer<T>);
+    removeFuture(): void;
+    get future(): IFutureModel<T> | undefined;
+    getFuture(): IFutureModel<T> | undefined;
+    addFuture(future: IFutureModel<T>): void;
+    onFutureUpdate?: ((future: IFutureModel<T>) => void) | undefined;
+    get allFutures(): IFutureModel<T>[];
+    get timeRemaining(): string;
+    get status(): string;
+    get progress(): number;
+    cancel(): Promise<void>;
+}
+//# sourceMappingURL=future-aware.d.ts.map

package/models/models/future/future-aware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"future-aware.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/future/future-aware.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,YAAY,EACZ,KAAK,gBAAgB,EACtB,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,qBAAqB,CAAC,CAAC,SAAS,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACvE,YAAW,oBAAoB,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAEvD,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,SAAS,CAAC,CAAqB;gBAC3B,SAAS,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,EAAE,MAAM;IAQnE,IAAI,UAAU,sBAEb;IAED,IAAI,MAAM,gCAET;IACD,SAAS,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM;IAWjD,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM;IAM3B,SAAS,CAAC,KAAK,CAAC,EAAE,MAAM;IAKxB,IAAI,SAAS,iCAEZ;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACnE,YAAW,oBAAoB,CAAC,CAAC,CAAC;IAElC,OAAO,CAAC,QAAQ,CAAC,CAAa;IAE9B,OAAO,CAAC,OAAO,CAAC,CAAkB;IAClC,OAAO,CAAC,SAAS,CAAC,CAAqB;gBAC3B,SAAS,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC;IAK1C,YAAY;IAMZ,IAAI,MAAM,gCAET;IACD,SAAS,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS;IAIxC,SAAS,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAWjC,cAAc,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAEjE,IAAI,UAAU,sBAEb;IACD,IAAI,aAAa,WAEhB;IAED,IAAI,MAAM,WAET;IAED,IAAI,QAAQ,WAEX;IAEK,MAAM;CAUb"}

package/models/models/future/future-factory.d.ts

@@ -0,0 +1,5 @@
+import { IFutureModel, IFutureModelOptions } from './future-types';
+
+export declare const FUTURE_MODEL_TYPE = "future-model";
+export declare const FutureFactory: import('../../../core').ModelFactory<IFutureModel<Record<string, unknown>>, IFutureModelOptions<Record<string, unknown>>>;
+//# sourceMappingURL=future-factory.d.ts.map

package/models/models/future/future-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"future-factory.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/future/future-factory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAExE,eAAO,MAAM,iBAAiB,iBAAiB,CAAC;AAChD,eAAO,MAAM,aAAa,2HAEzB,CAAC"}

package/models/models/future/future-model-builder.d.ts

@@ -0,0 +1,76 @@
+import { IFutureModel, IFutureModelOptions } from './future-types';
+import { FutureResponse } from '../../services/future';
+import { ModelFactory } from '../../../core';
+
+/**
+ * Maps a `FutureResponse` DTO to an `IFutureModelOptions` object.
+ *
+ * @remarks
+ * This function will perform any type conversion or data mapping required
+ * by the IKosDataModel.  For example, date conversion or changes in interfaces
+ * can be managed at this layer rather than having the models deal with the
+ * various versions of the interface directly.
+ *
+ * @params dto - the Data Transfer Object received from the backend
+ * @returns - a valid `IFutureModelOptions` that can be used to
+ * instantiate a new model.
+ * @internal
+ * @category future
+ */
+export declare const mapDtoToFutureOptions: (dto: FutureResponse) => IFutureModelOptions<Record<string, unknown>>;
+/**
+ * Maps a `FutureResponse` DTO to an `IFutureModel` object.
+ *
+ * @remarks
+ * This function will run as a mobx action ensuring that all observers are notified
+ * if any changes are made.
+ *
+ * @params dto - the Data Transfer Object received from the backend
+ * @params model - the IModel to be update
+ * @internal
+ * @category future
+ */
+export declare const mapDtoToFutureModel: (dto: FutureResponse, model: IFutureModel) => void;
+/**
+ * Curried function that will produce a function that can be used to retrieve or create
+ * new instances of a `IFutureModel` given an ID and options.
+ *
+ * @remarks
+ * This serves as a convenience allowing for models to consumers to use a shorthand method when
+ * multiple models need to be created.
+ * The first level of function will accept a KOS Model Factory and return a function that can accept a single
+ * model ID parameter.  This will return a factory function that can accept a model options parameter and
+ * instantiate a new instance of a model or retrieve a an existing model.
+ *
+ * @param factory - the model factory to be used
+ * @returns - an instance of the `IFutureModel` that was either created
+ * or retrieved from the KOS Model framework if already existing.
+ *
+ * @internal
+ * @category future
+ */
+export declare const buildFutureModel: (factory: ModelFactory<IFutureModel, IFutureModelOptions>) => (modelId: string) => (futureOptions: IFutureModelOptions) => IFutureModel<Record<string, unknown>>;
+/**
+ * Factory function that simplifies the creation of a new model
+ *
+ * @remarks
+ * This method will map the response object to an `IFutureModelOptions` instance and
+ * construct a new instance of a model using the provided factory.  This will provide a shorthand
+ * for consumers when creating instances of models and allows for additional operations to be performed
+ * as part of the creation process.
+ *
+ * @example
+ * // create a new (potentially static) instance of the factory that can be used throughout the code.
+ * const buildFutureModel = buildFuture((FutureModel.Factory));
+ *
+ * // use the builder to create a new instance of the model from an options instance.
+ * const future: IFutureResponse = someFunctionToGetResponseFromServer();
+ * const futureModel = buildFutureModel(future);
+ *
+ * @param factory - The model factory that can be used to
+ *
+ * @internal
+ * @category future
+ */
+export declare const buildFuture: (factory: ModelFactory<IFutureModel, IFutureModelOptions>) => (future: FutureResponse) => any;
+//# sourceMappingURL=future-model-builder.d.ts.map

package/models/models/future/future-model-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"future-model-builder.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/future/future-model-builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,YAAY,EAAmB,MAAM,eAAe,CAAC;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAExE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,QAAS,cAAc,iDAcxD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,QACzB,cAAc,SACZ,YAAY,SA6BpB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,YACjB,aAAa,YAAY,EAAE,mBAAmB,CAAC,eAC/C,MAAM,qBACA,mBAAmB,0CAGlC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,WAAW,YACZ,aAAa,YAAY,EAAE,mBAAmB,CAAC,cAChD,cAAc,QAIZ,CAAC"}

package/models/models/future/future-model.d.ts

@@ -0,0 +1,95 @@
+import { IFutureModel, IFutureModelOptions } from './future-types';
+import { FutureEndState, FutureResponse } from '../../services/future';
+import { KosCreationContext } from '../../../core';
+
+interface FutureModel extends IFutureModel {
+}
+/**
+ * @category future
+ * @name FutureModel
+ * @version 1.0.0
+ * @author Matthew Holman <maholman@coca-cola.com>
+ *
+ * Represents a future.
+ */
+declare class FutureModel implements IFutureModel {
+    private logger;
+    private _cancelFuture;
+    futureId: string;
+    /**
+     * @category Constructor
+     *
+     * @param modelId - the unique modelId for this Future
+     * @param options - any options that should be merged into the Future
+     * @params options.id - the unique id of the Future
+     * @params options.name - the name of the Future
+     *
+     */
+    constructor(modelId: string, options: IFutureModelOptions, context: KosCreationContext);
+    /**
+     * @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>;
+    /**
+     * @internal
+     */
+    unload(): void;
+    /**
+     * @category Action
+     *
+     * @remark
+     * Cancels the current future.
+     *
+     * 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 cancelFutureService
+     */
+    cancelFuture(): Promise<void>;
+    /**
+     * Gets the current status of the future operation.
+     *
+     * @returns Status string: "NOT_ACTIVE", "IN_PROGRESS", "Success", or "Fail"
+     *
+     * @example Monitor Status
+     * ```typescript
+     * if (future.status === "IN_PROGRESS") {
+     *   console.log(`Operation running: ${future.progress}% complete`);
+     * } else if (future.status === "Success") {
+     *   console.log("Operation completed successfully!");
+     * }
+     * ```
+     */
+    get status(): FutureEndState | "IN_PROGRESS" | "NOT_ACTIVE";
+    /**
+     * Gets human-readable time remaining for the operation.
+     *
+     * @returns Formatted time string (e.g., "5 minutes", "30 seconds") or empty string if unknown
+     *
+     * @example Display Time Remaining
+     * ```typescript
+     * const timeLeft = future.timeRemaining;
+     * if (timeLeft) {
+     *   console.log(`${timeLeft} remaining`);
+     * }
+     * ```
+     */
+    get timeRemaining(): string;
+    /**
+     * @internal
+     * @category Subscription
+     * Updates the Future model when a `kos.future/{ID}` event
+     * is received from the server.
+     *
+     * @param future - the Future that was updated.
+     * @see FutureResponse
+     */
+    handleFutureUpdated(future: FutureResponse): void;
+}
+export default FutureModel;
+//# sourceMappingURL=future-model.d.ts.map

package/models/models/future/future-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"future-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/future/future-model.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,KAAK,kBAAkB,EACxB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,cAAc,EAGd,KAAK,cAAc,EACpB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAOxE,UAAU,WAAY,SAAQ,YAAY;CAAG;AAI7C;;;;;;;GAOG;AACH,cACM,WAAY,YAAW,YAAY;IACvC,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,aAAa,CAGuB;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;;OAQG;gBAED,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,kBAAkB;IAwB7B;;;;;;;OAOG;IACG,IAAI;IAIV;;OAEG;IACH,MAAM;IAMN;;;;;;;;;;OAUG;IACG,YAAY;IASlB;;;;;;;;;;;;;OAaG;IACH,IAAI,MAAM,kDAMT;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,aAAa,WAoChB;IAID;;;;;;;;OAQG;IAIH,mBAAmB,CAAC,MAAM,EAAE,cAAc;CAM3C;AAED,eAAe,WAAW,CAAC"}