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

package/models/models/storage-device/storage-device-model.d.ts

@@ -0,0 +1,109 @@
+import { StorageDeviceOptions } from './types';
+import { IKosDataModel, IKosIdentifiable, KosCreationContext, PublicModelInterface } from '../../../core';
+
+export declare const MODEL_TYPE = "storage-device-model";
+/**
+ * StorageDevice - Manages individual USB/external storage device information and state.
+ *
+ * The StorageDevice model represents individual storage devices (USB drives, SD cards,
+ * external drives) connected to the KOS system. It tracks device hardware information,
+ * mount status, and provides access to device metadata including vendor, model, runtime
+ * statistics, and file system details.
+ *
+ * ## Key Features
+ * - **Hardware Information** - Vendor, model, and system path details
+ * - **Mount Management** - Track mount directory and removal status
+ * - **Runtime Statistics** - Device runtime and usage metrics
+ * - **Node Awareness** - Multi-node device distribution tracking
+ * - **File System Integration** - Label and mount point management
+ * - **Parent-Aware Architecture** - Designed for container model management
+ *
+ * ## Device Properties
+ * Storage devices expose comprehensive hardware and state information:
+ * - **Physical Details**: vendor, model, syspath for hardware identification
+ * - **Mount Information**: mountDir, label for file system access
+ * - **Status Tracking**: removed flag, local/remote node distribution
+ * - **Runtime Metrics**: runTimeMs for usage analytics
+ *
+ * ## Common Use Cases
+ * - **Storage Management UI** - Display available storage devices and capacity
+ * - **File Transfer Operations** - Access mount points for file operations
+ * - **System Monitoring** - Track device insertion/removal events
+ * - **Backup Management** - Identify backup destination devices
+ * - **Multi-node Systems** - Manage storage across distributed KOS nodes
+ * - **Device Diagnostics** - Runtime statistics and health monitoring
+ *
+ * @interface
+ * @example Basic Usage
+ * ```typescript
+ * const usbDrive = StorageDevice.instance('usb-drive-1')
+ *   .options({
+ *     mountDir: '/media/usb1',
+ *     vendor: 'SanDisk',
+ *     model: 'Ultra USB 3.0',
+ *     label: 'BACKUP_DRIVE',
+ *     nodeId: 'primary',
+ *     local: true,
+ *     removed: false,
+ *     runTimeMs: 1800000,
+ *     syspath: '/sys/devices/usb1'
+ *   })
+ *   .build();
+ *
+ * // Access device properties
+ * console.log(`${usbDrive.vendor} ${usbDrive.model} at ${usbDrive.mountDir}`);
+ * ```
+ *
+ * @group KOS Model
+ * @category Device Management
+ * @useDeclaredType
+ *
+ * @see {@link StorageDeviceOptions} - Configuration options for StorageDevice instances
+ * @see {@link StorageDeviceContainerModel} - Container for managing multiple storage devices
+ * @see {@link StorageDeviceResponse} - API response structure for device data
+ */
+export type StorageDevice = PublicModelInterface<StorageDeviceModelImpl>;
+export type StorageDeviceModel = PublicModelInterface<StorageDeviceModelImpl>;
+/**
+ * @ignore
+ * @internal
+ */
+export declare class StorageDeviceModelImpl implements IKosDataModel, IKosIdentifiable {
+    /** Unique identifier for the storage device model instance */
+    id: string;
+    /** File system mount directory path where device is accessible */
+    mountDir: string;
+    /** Whether the device has been physically removed from the system */
+    removed: boolean;
+    /** Device manufacturer name (e.g., 'SanDisk', 'Western Digital') */
+    vendor: string;
+    /** Total device runtime in milliseconds for usage tracking */
+    runTimeMs: number;
+    /** Device model name or identifier (e.g., 'Ultra USB 3.0', 'My Passport') */
+    model: string;
+    /** KOS node identifier where this device is connected */
+    nodeId: string;
+    /** Whether the device is connected to the local node */
+    local: boolean;
+    /** File system label or volume name for the device */
+    label: string;
+    /** System path for hardware identification and low-level access */
+    syspath: string;
+    /** Context logger for debugging and diagnostics */
+    private logger;
+    constructor(modelId: string, options: StorageDeviceOptions, context: KosCreationContext);
+    /**
+     * Updates the storage device model with new configuration options.
+     * @param options New configuration options to apply to the device
+     */
+    updateModel(options: StorageDeviceOptions): void;
+    /**
+     * @internal
+     */
+    init(): Promise<void>;
+    /**
+     * @internal
+     */
+    load(): Promise<void>;
+}
+//# sourceMappingURL=storage-device-model.d.ts.map

package/models/models/storage-device/storage-device-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-device-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/storage-device/storage-device-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEhB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,eAAO,MAAM,UAAU,yBAAyB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,MAAM,aAAa,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AAEzE,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;AAE9E;;;GAGG;AACH,qBAEa,sBAAuB,YAAW,aAAa,EAAE,gBAAgB;IAC5E,8DAA8D;IAC9D,EAAE,EAAE,MAAM,CAAC;IACX,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB,oEAAoE;IACpE,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,KAAK,EAAE,OAAO,CAAC;IACf,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,OAAO,CAAC,MAAM,CAAmB;gBAE/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,kBAAkB;IAe7B;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAchD;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

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

@@ -0,0 +1,87 @@
+import { StorageDeviceOptions } from './types';
+import { StorageDeviceModel } from './storage-device-model';
+import { KosModelRegistrationFactory } from '../../../core';
+
+/**
+ * # StorageDevice
+ *
+ * The registration bean includes convenience methods for creating and working with StorageDeviceModel 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: StorageDevice.type, id: "storageDeviceId"})
+ * private storageDeviceModel: StorageDeviceModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new StorageDeviceModel 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 = StorageDevice.factory("storageDeviceId")({
+ *   // 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 StorageDeviceModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (StorageDevice.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to StorageDeviceModel
+ *    // and the compiler will know that the model has the StorageDeviceModel 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 { StorageDevice } from "@kos-ui/project-models";
+ * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
+ *
+ * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
+ *
+ * KosModelRegistry.dispense
+ * .models()
+ * .model(StorageDevice);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The storageDevice 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 StorageDevice: KosModelRegistrationFactory<StorageDeviceModel, StorageDeviceOptions>;
+//# sourceMappingURL=storage-device-registration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storage-device-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/storage-device/storage-device-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,aAAa,uEAMxB,CAAC"}

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

@@ -0,0 +1,132 @@
+import { KosParentAware } from '../../../../core';
+
+
+// ---------------  StorageDevice ---------------
+
+/**
+ * Configuration options for StorageDevice model instances.
+ *
+ * This interface defines the complete configuration structure for individual storage devices,
+ * including hardware identification, mount information, and runtime metrics. These options
+ * are typically populated from storage device discovery services and WebSocket updates.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * const device = StorageDevice.instance('usb-backup')
+ *   .options({
+ *     mountDir: '/media/usb-drive',
+ *     vendor: 'SanDisk',
+ *     model: 'Ultra USB 3.0',
+ *     label: 'BACKUP_DRIVE',
+ *     nodeId: 'primary',
+ *     local: true,
+ *     removed: false,
+ *     runTimeMs: 1800000,
+ *     syspath: '/sys/devices/usb1'
+ *   })
+ *   .build();
+ * ```
+ *
+ * @category Model Configuration
+ * @category Device Management
+ */
+export interface StorageDeviceOptions extends KosParentAware {
+  /**
+   * File system mount directory path where the device is accessible.
+   * Empty string indicates the device is not currently mounted.
+   *
+   * @example "/media/usb-drive"
+   * @example "/mnt/backup-storage"
+   * @example "" // Not mounted
+   */
+  mountDir: string;
+
+  /**
+   * Indicates whether the storage device has been physically removed.
+   * When true, the device is no longer accessible and mount operations will fail.
+   *
+   * @default false
+   */
+  removed: boolean;
+
+  /**
+   * Hardware vendor/manufacturer name of the storage device.
+   * Used for device identification and display purposes.
+   *
+   * @example "SanDisk"
+   * @example "Western Digital"
+   * @example "Samsung"
+   */
+  vendor: string;
+
+  /**
+   * Total runtime in milliseconds since the device was first connected.
+   * Tracks cumulative usage time for analytics and maintenance scheduling.
+   *
+   * @example 1800000 // 30 minutes
+   * @example 3600000 // 1 hour
+   */
+  runTimeMs: number;
+
+  /**
+   * Hardware model name/number of the storage device.
+   * Combined with vendor for complete device identification.
+   *
+   * @example "Ultra USB 3.0"
+   * @example "My Passport"
+   * @example "EVO Select 64GB"
+   */
+  model: string;
+
+  /**
+   * KOS node identifier where this storage device is physically connected.
+   * Used in multi-node systems to track device distribution.
+   *
+   * @example "primary"
+   * @example "secondary"
+   * @example "embedded-node-1"
+   */
+  nodeId: string;
+
+  /**
+   * Indicates if the device is connected to the local node (true) or remote node (false).
+   * Determines accessibility and operation capabilities from current context.
+   *
+   * @default true
+   */
+  local: boolean;
+
+  /**
+   * File system label/name assigned to the storage device.
+   * Used for user-friendly identification and mount point organization.
+   *
+   * @example "BACKUP_DRIVE"
+   * @example "CONFIG_STORAGE"
+   * @example "DATA_ARCHIVE"
+   */
+  label: string;
+
+  /**
+   * System device path in the Linux device tree.
+   * Low-level hardware identifier for device tracking and diagnostics.
+   *
+   * @example "/sys/devices/pci0000:00/usb1/1-2"
+   * @example "/sys/devices/mmc0/mmc0:0001"
+   * @example "/sys/devices/platform/sdhci"
+   */
+  syspath: string;
+}
+
+// ---------------  StorageDeviceContainer ---------------
+
+/**
+ * Configuration options for StorageDeviceContainer model instances.
+ *
+ * The container model manages collections of storage devices and handles real-time
+ * updates via WebSocket topics. Currently uses an empty configuration object as
+ * the container's behavior is primarily driven by discovered storage devices.
+ *
+ * @category Model Configuration
+ * @category Device Management
+ */
+export type StorageDeviceContainerOptions = object;

package/models/models/studio-properties/index.d.ts

@@ -0,0 +1,5 @@
+export { StudioProperties } from './studio-properties-registration';
+export type * from './types';
+export type { StudioPropertiesModel } from './studio-properties-model';
+export * as StudioPropertiesServices from './services';
+//# sourceMappingURL=index.d.ts.map

package/models/models/studio-properties/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/studio-properties/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,mBAAmB,SAAS,CAAC;AAC7B,YAAY,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,KAAK,wBAAwB,MAAM,YAAY,CAAC"}

package/models/models/studio-properties/services/index.d.ts

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

package/models/models/studio-properties/services/index.d.ts.map

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

package/models/models/studio-properties/services/studio-properties-services.d.ts

@@ -0,0 +1,15 @@
+import { ApiPath, ApiResponse } from '../../../utils/service';
+import { ServiceResponse } from '../../../../core';
+
+declare const SERVICE_PATH: ApiPath;
+export type StudioPropertiesClientResponse = ApiResponse<typeof SERVICE_PATH, "get">;
+export interface StudioPropertiesResponse {
+    data?: Record<string, any>;
+}
+/**
+ * @category Service
+ * Retrieves the initial  studio-properties data.
+ */
+export declare const getStudioProperties: (connectionId: string) => Promise<ServiceResponse<StudioPropertiesResponse>>;
+export {};
+//# sourceMappingURL=studio-properties-services.d.ts.map

package/models/models/studio-properties/services/studio-properties-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"studio-properties-services.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/studio-properties/services/studio-properties-services.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAY,EAAE,KAAK,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAO7E,QAAA,MAAM,YAAY,EAAE,OAAsC,CAAC;AAC3D,MAAM,MAAM,8BAA8B,GAAG,WAAW,CAAC,OAAO,YAAY,EAAE,KAAK,CAAC,CAAC;AACrF,MAAM,WAAW,wBAAwB;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC5B;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,iBAChB,MAAM,KACnB,QAAQ,gBAAgB,wBAAwB,CAAC,CAcnD,CAAC"}

package/models/models/studio-properties/studio-properties-model.d.ts

@@ -0,0 +1,97 @@
+import { StudioPropertiesOptions } from './types';
+import { PublicModelInterface } from '../../../core/types';
+import { IKosIdentifiable } from '../../../core/core/types';
+import { IKosDataModel, KosCreationContext } from '../../../core/core/kosModel';
+
+export declare const MODEL_TYPE = "studio-properties-model";
+/**
+ * StudioPropertiesModel - Real-time KOS Studio properties management with WebSocket synchronization.
+ *
+ * This model provides centralized access to KOS Studio's runtime properties and configuration
+ * values, enabling applications to access Studio-specific settings, tool states, and integration
+ * parameters. Properties are synchronized in real-time via WebSocket topics, ensuring all
+ * connected clients maintain consistent Studio state information.
+ *
+ * ## Key Features
+ * - **Real-time synchronization** - Properties update automatically via `/kos/studio/properties` topic
+ * - **Connection-scoped access** - Properties are specific to individual Studio VM connections
+ * - **Fallback handling** - Graceful degradation with default values when Studio is unavailable
+ * - **Observable properties** - Create reactive computed values for any property key
+ * - **Session management** - Automatic WebSocket session lifecycle with proper cleanup
+ *
+ * ## Topic-Based Reactivity
+ * The model listens to this KOS topic for real-time synchronization:
+ * - **`/kos/studio/properties`** - Broadcasts Studio property changes with connection-specific routing
+ *
+ * ## Common Use Cases
+ * - **Studio integration status** - Check if legacy tools or specific Studio features are enabled
+ * - **Tool configuration** - Access Studio tool settings and preferences for UI adaptation
+ * - **Connection management** - Track Studio connection state and properties for diagnostics
+ * - **Feature flags** - Access Studio-specific feature toggles and experimental settings
+ *
+ * @interface
+ * @example Basic Usage
+ * ```typescript
+ * const studioProps = StudioPropertiesModel.instance('studio-conn-1')
+ *   .options({ connectionId: 'vm-connection-abc123' })
+ *   .build();
+ *
+ * await studioProps.initializePropertiesSession();
+ * const legacyToolSupport = studioProps.get('kos.studio.tool.legacy');
+ * ```
+ *
+ * @group KOS Model
+ * @category System Integration
+ * @useDeclaredType
+ *
+ * @see {@link StudioPropertiesOptions} - Configuration options for StudioPropertiesModel instances
+ */
+export type StudioPropertiesModel = PublicModelInterface<StudioPropertiesModelImpl>;
+/**
+ * @ignore
+ * @internal
+ */
+export declare class StudioPropertiesModelImpl implements IKosDataModel, IKosIdentifiable {
+    /** Unique identifier for the model instance */
+    id: string;
+    /** Studio VM connection identifier for property routing */
+    connectionId: string;
+    /** WebSocket subscription cleanup function */
+    private unsubscribe;
+    /** Context logger for debugging and diagnostics */
+    private logger;
+    /** Observable data store for Studio properties */
+    private data;
+    constructor(modelId: string, options: StudioPropertiesOptions, context: KosCreationContext);
+    /**
+     * @internal
+     */
+    init(): Promise<void>;
+    /**
+     * @internal
+     */
+    load(): Promise<void>;
+    /**
+     * Terminates the WebSocket session for Studio properties.
+     * Cleans up subscriptions to prevent memory leaks.
+     */
+    terminatePropertiesSession(): Promise<void>;
+    /**
+     * Initializes WebSocket session for real-time Studio property synchronization.
+     * Loads initial properties and subscribes to update topics.
+     */
+    initializePropertiesSession(): Promise<void>;
+    /**
+     * Retrieves a Studio property value by key.
+     * @param key Property key to retrieve
+     * @returns The property value or undefined if not set
+     */
+    get(key: string): any;
+    /**
+     * Creates an observable computed property for reactive updates.
+     * @param key Property key to observe
+     * @returns Observable that emits when the property changes
+     */
+    createObservableProperty(key: string): import('mobx').IComputedValue<any>;
+}
+//# sourceMappingURL=studio-properties-model.d.ts.map

package/models/models/studio-properties/studio-properties-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"studio-properties-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/studio-properties/studio-properties-model.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,aAAa,EAEb,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEvD,eAAO,MAAM,UAAU,4BAA4B,CAAC;AAIpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,MAAM,qBAAqB,GAC/B,oBAAoB,CAAC,yBAAyB,CAAC,CAAC;AAMlD;;;GAGG;AACH,qBACa,yBACX,YAAW,aAAa,EAAE,gBAAgB;IAE1C,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,OAAO,CAAC,WAAW,CAA6B;IAChD,mDAAmD;IACnD,OAAO,CAAC,MAAM,CAAmB;IACjC,kDAAkD;IAClD,OAAO,CAAC,IAAI,CAA+B;gBAEzC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,kBAAkB;IAW7B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;OAGG;IACG,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjD;;;OAGG;IACG,2BAA2B;IA8BjC;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG;IAIrB;;;;OAIG;IACH,wBAAwB,CAAC,GAAG,EAAE,MAAM;CAGrC"}

package/models/models/studio-properties/studio-properties-registration.d.ts

@@ -0,0 +1,87 @@
+import { StudioPropertiesModel } from './studio-properties-model';
+import { StudioPropertiesOptions } from './types';
+import { KosModelRegistrationFactory } from '../../../core/core/registration';
+
+/**
+ * # StudioProperties
+ *
+ * The registration bean includes convenience methods for creating and working with StudioPropertiesModel 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: StudioProperties.type, id: "studioPropertiesId"})
+ * private studioPropertiesModel: StudioPropertiesModel;
+ * ```
+ *
+ *
+ * ## factory
+ *
+ * The factory method creates a factory function that can be used to create new StudioPropertiesModel 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 = StudioProperties.factory("studioPropertiesId")({
+ *   // 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 StudioPropertiesModel.
+ *
+ * @example
+ * ```typescript
+ *
+ * const model: IKosDataModel = ...; // some model
+ *
+ * if (StudioProperties.predicate(model)) {
+ *    // if the function evaluates to true, the model is narrowed down to StudioPropertiesModel
+ *    // and the compiler will know that the model has the StudioPropertiesModel 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 { StudioProperties } from "@kos-ui/project-models";
+ * import { KosModelRegistry } from "@kosdev-code/kos-dispense-sdk";
+ *
+ * import { initKosProvider } from "@kosdev-code/kos-ui-sdk";
+ *
+ * KosModelRegistry.dispense
+ * .models()
+ * .model(StudioProperties);
+ * ```
+ *
+ * ## registration.singleton
+ 
+ * The studioProperties 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 StudioProperties: KosModelRegistrationFactory<StudioPropertiesModel, StudioPropertiesOptions>;
+//# sourceMappingURL=studio-properties-registration.d.ts.map

package/models/models/studio-properties/studio-properties-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"studio-properties-registration.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/studio-properties/studio-properties-registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAKvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgFK;AACL,eAAO,MAAM,gBAAgB,6EAM3B,CAAC"}

package/models/models/studio-properties/types/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Configuration options for StudioPropertiesModel instances.
+ *
+ * This interface defines the configuration structure for Studio properties models,
+ * which manage real-time access to KOS Studio runtime properties and settings.
+ * The connection ID serves as the primary routing mechanism for Studio-specific
+ * property synchronization.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * const studioProps = StudioPropertiesModel.instance('dev-studio')
+ *   .options({ connectionId: 'vm-development-001' })
+ *   .build();
+ * ```
+ *
+ * @category Model Configuration
+ * @category System Integration
+ */
+export interface StudioPropertiesOptions {
+  /**
+   * Studio VM connection identifier for property routing and WebSocket targeting.
+   * 
+   * This ID corresponds to an active Studio connection and determines which Studio
+   * instance provides the properties. Each Studio VM connection has unique runtime
+   * properties and configuration values.
+   *
+   * @example "vm-development-local-001"
+   * @example "studio-connection-abc123" 
+   * @example "primary-studio-instance"
+   */
+  connectionId: string;
+}

package/models/models/translation/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CONTEXT_LANG_RESOLVER = "langResolver";
+//# sourceMappingURL=constants.d.ts.map

package/models/models/translation/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/translation/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,iBAAiB,CAAC"}

package/models/models/translation/index.d.ts

@@ -0,0 +1,9 @@
+export { getKosLocalizationDescriptor, getLocalizationDescriptor, getTranslations, } from './services';
+export type { Localization } from './services';
+export type { TranslationContainerModel } from './translation-container-model';
+export { TranslationContainer } from './translation-container-registration';
+export * from './translation-context';
+export type { ResolveTranslationOptions, TranslationModel, } from './translation-model';
+export { Translation } from './translation-registration';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/models/models/translation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,yBAAyB,EACzB,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,YAAY,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,cAAc,uBAAuB,CAAC;AACtC,YAAY,EACV,yBAAyB,EACzB,gBAAgB,GACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,mBAAmB,SAAS,CAAC"}

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

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

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

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