@kosdev-code/kos-ui-sdk 2.0.45 → 2.0.46

package/core/core/decorators/kos-view-model.d.ts

@@ -1,176 +0,0 @@
-import { KosContextLogger } from '../kosModel';
-
-/**
- * Configuration options for the @kosViewModel decorator.
- *
- * @kosService core.view-model
- * @kosApiLevel 20
- */
-export interface KosViewModelOptions {
-    /**
-     * Optional type identifier for this ViewModel.
-     * Used for logging, debugging, and optional DevTools registration.
-     * If not provided, defaults to the class name.
-     */
-    typeId?: string;
-    /**
-     * When true, registers this ViewModel with KOS DevTools for inspection.
-     * Default: false (ViewModels are not tracked by default)
-     */
-    devToolsEnabled?: boolean;
-}
-/**
- * Interface for ViewModels that support cleanup.
- * Implement this to have automatic disposal when using useViewModel.
- *
- * @kosService core.view-model
- * @kosApiLevel 20
- */
-export interface IKosViewModelDisposable {
-    dispose(): void | Promise<void>;
-}
-/**
- * Interface for ViewModels that require async initialization.
- * Implement this to await model readiness or perform async setup.
- *
- * When a ViewModel implements this interface, the useViewModel hook will:
- * - Call ready() after construction
- * - Track ready state and any errors
- * - Return { viewModel, ready, error } instead of just the viewModel
- *
- * @example
- * ```typescript
- * @kosViewModel({ typeId: 'order-summary' })
- * class OrderSummaryViewModel implements IKosViewModelReady {
- *   constructor(
- *     private order: IOrderModel,
- *     private inventory: IInventoryModel
- *   ) {}
- *
- *   async ready(): Promise<void> {
- *     // Await model readiness before ViewModel is considered ready
- *     await Promise.all([
- *       this.order.whenReady?.(),
- *       this.inventory.whenReady?.()
- *     ]);
- *   }
- * }
- * ```
- *
- * @kosService core.view-model
- * @kosApiLevel 20
- */
-export interface IKosViewModelReady {
-    ready(): Promise<void>;
-}
-/**
- * Type guard to check if an object implements IKosViewModelReady.
- */
-export declare function hasReadyHook(obj: unknown): obj is IKosViewModelReady;
-/**
- * Interface for models using @kosLoggerAware decorator with @kosViewModel.
- * Use TypeScript interface merging to add the logger property to your ViewModel class.
- *
- * @example
- * ```typescript
- * interface MyViewModel extends KosLoggerAware {}
- *
- * @kosViewModel({ typeId: 'my-view-model' })
- * @kosLoggerAware()
- * export class MyViewModel {
- *   constructor(private readonly model: IMyModel) {}
- *
- *   doSomething() {
- *     this.logger.info('Doing something');
- *   }
- * }
- * ```
- *
- * @kosService core.view-model
- * @kosApiLevel 20
- */
-export interface KosViewModelLoggerAware {
-    logger: KosContextLogger;
-}
-/**
- * Type guard to check if an object implements IKosViewModelDisposable.
- */
-export declare function isDisposable(obj: unknown): obj is IKosViewModelDisposable;
-/**
- * Lightweight model decorator that provides observability without
- * the full KOS model lifecycle machinery.
- *
- * Use @kosViewModel when:
- * - You need observable state for React components
- * - Dependencies are passed directly via constructor (no @kosDependency resolution)
- * - You don't need lifecycle methods (init, load, ready, activate)
- * - You want to instantiate with `new` rather than through factories
- *
- * @param options Configuration options for the ViewModel
- * @returns A class decorator
- *
- * @example
- * ```typescript
- * // Basic usage
- * @kosViewModel({ typeId: 'counter' })
- * export class CounterViewModel {
- *   count = 0;
- *
- *   increment() {
- *     this.count++;
- *   }
- * }
- *
- * // With logger support
- * interface OrderSummaryViewModel extends KosViewModelLoggerAware {}
- *
- * @kosViewModel({ typeId: 'order-summary' })
- * @kosLoggerAware()
- * export class OrderSummaryViewModel implements IKosViewModelDisposable {
- *   constructor(
- *     private readonly order: IOrderModel,
- *     private readonly inventory: IInventoryModel
- *   ) {
- *     this.logger.info('ViewModel created');
- *   }
- *
- *   get total(): number {
- *     return this.order.items.reduce((sum, i) => sum + i.price, 0);
- *   }
- *
- *   get hasStockIssues(): boolean {
- *     return this.order.items.some(item =>
- *       this.inventory.getStock(item.productId) < item.quantity
- *     );
- *   }
- *
- *   dispose(): void {
- *     this.logger.info('ViewModel disposed');
- *   }
- * }
- *
- * // Usage in React component
- * function OrderSummary({ orderId }: Props) {
- *   const { model: order } = useKosModel<IOrderModel>({ modelId: orderId });
- *   const { model: inventory } = useKosModel<IInventoryModel>({ modelId: 'inventory' });
- *
- *   const vm = useViewModel(
- *     () => new OrderSummaryViewModel(order!, inventory!),
- *     [order, inventory]
- *   );
- *
- *   return (
- *     <div>
- *       <p>Total: ${vm.total}</p>
- *       {vm.hasStockIssues && <Warning>Some items may be unavailable</Warning>}
- *     </div>
- *   );
- * }
- * ```
- *
- * @category KOS ViewModel Decorator
- * @kosService core.view-model
- * @kosApiLevel 20
- */
-export declare function kosViewModel(options?: KosViewModelOptions): ClassDecorator;
-//# sourceMappingURL=kos-view-model.d.ts.map

package/core/core/decorators/kos-view-model.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kos-view-model.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/decorators/kos-view-model.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASpD;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,kBAAkB;IACjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAOpE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,gBAAgB,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,uBAAuB,CAOzE;AAgMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,wBAAgB,YAAY,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,cAAc,CAgB1E"}

package/core/core/model/kos-service-request-manager.d.ts

@@ -1,102 +0,0 @@
-import { ServiceResponseStore } from './service-response-store';
-import { IKosDataModel } from '../kosModel';
-import { DependencyLifecycle } from '../../types';
-
-/**
- * Manages lifecycle-driven service requests for KOS models
- *
- * The ServiceRequestManager executes @kosServiceRequest decorated methods
- * during the appropriate lifecycle phase (INIT, LOAD, READY, ACTIVATE).
- *
- * @internal
- */
-export declare class ServiceRequestManager {
-    private model;
-    private responseStore;
-    private handlers;
-    constructor(model: IKosDataModel, responseStore: ServiceResponseStore);
-    /**
-     * Discover and organize service request handlers by lifecycle phase
-     */
-    private discoverHandlers;
-    /**
-     * Execute all service requests for a specific lifecycle phase
-     *
-     * @param lifecycle - The lifecycle phase to execute
-     */
-    executeForLifecycle(lifecycle: DependencyLifecycle): Promise<void>;
-    /**
-     * Zone 1: Orchestrates the entire service request flow
-     */
-    private executeHandler;
-    /**
-     * Zone 2: Validates request preconditions
-     */
-    private shouldProcessRequest;
-    /**
-     * Zone 2: Coordinates request preparation, execution, and timing capture
-     */
-    private prepareAndExecuteRequest;
-    /**
-     * Zone 3: Captures request timestamp
-     */
-    private captureRequestTiming;
-    /**
-     * Zone 3: Captures response timestamp
-     */
-    private captureResponseTiming;
-    /**
-     * Zone 2: Coordinates response processing and storage
-     */
-    private processAndStoreResponse;
-    /**
-     * Zone 2: Prepares request parameters by coordinating parameter resolution
-     * @internal
-     */
-    private prepareRequest;
-    /**
-     * Zone 3: Performs the HTTP request
-     * @internal
-     */
-    private performRequest;
-    /**
-     * Zone 2: Processes response by coordinating transformations
-     * @internal
-     */
-    private processResponse;
-    /**
-     * Zone 2: Stores response and invokes handler with cleanup
-     * @internal
-     */
-    private storeAndInvokeHandler;
-    /**
-     * Trigger queue flush for topic handlers waiting on this baseline
-     * @private
-     */
-    private triggerBaselineQueueFlush;
-    /**
-     * Make HTTP request using existing KOS API client
-     */
-    private makeRequest;
-    /**
-     * Zone 2: Applies field mappings to response data by coordinating extraction, transformation, and validation
-     */
-    private applyMappings;
-    /**
-     * Get nested value from object using dot notation
-     */
-    private getNestedValue;
-    /**
-     * Apply transformation to a value
-     */
-    private applyTransform;
-    /**
-     * Handle array iteration and model creation
-     */
-    private handleIteration;
-    /**
-     * Handle errors according to configured strategy
-     */
-    private handleError;
-}
-//# sourceMappingURL=kos-service-request-manager.d.ts.map

package/core/core/model/kos-service-request-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kos-service-request-manager.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/model/kos-service-request-manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAWlD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAqKhE;;;;;;;GAOG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,QAAQ,CAAqD;gBAEzD,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,oBAAoB;IAQrE;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAwBxB;;;;OAIG;IACG,mBAAmB,CAAC,SAAS,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAexE;;OAEG;YACW,cAAc;IAgB5B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAQ5B;;OAEG;YACW,wBAAwB;IAkBtC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;OAEG;YACW,uBAAuB;IAuCrC;;;OAGG;IACH,OAAO,CAAC,cAAc;IAkBtB;;;OAGG;YACW,cAAc;IAoB5B;;;OAGG;YACW,eAAe;IAwB7B;;;OAGG;YACW,qBAAqB;IAiCnC;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAcjC;;OAEG;YACW,WAAW;IA4BzB;;OAEG;IACH,OAAO,CAAC,aAAa;IAoCrB;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,cAAc;IA0BtB;;OAEG;YACW,eAAe;IA4D7B;;OAEG;YACW,WAAW;CAuF1B"}

package/core/core/model/service-response-store.d.ts

@@ -1,164 +0,0 @@
-import { ResponseCacheConfig } from '../../types/service-response-store';
-
-/**
- * ServiceResponseStore manages keyed storage of service responses with flexible retention policies.
- *
- * Responses are stored by `{method}:{path}` key (e.g., 'GET:/api/ingredients')
- * and can be configured with different retention policies to control caching behavior.
- *
- * @example
- * const store = new ServiceResponseStore();
- *
- * // Store with TTL (replaces on each request)
- * store.set('GET:/api/status', statusData, {
- *   retention: ResponseRetention.TTL,
- *   ttl: 5 * 60 * 1000
- * });
- *
- * // Store with TTL extension (keeps existing data, extends TTL)
- * const stored = store.set('GET:/api/expensive', expensiveData, {
- *   retention: ResponseRetention.TTL,
- *   ttl: 5 * 60 * 1000,
- *   extendOnRefresh: true
- * });
- * // stored === false if cache was extended, true if new data stored
- *
- * // Retrieve
- * const status = store.get('GET:/api/status');
- */
-export declare class ServiceResponseStore {
-    private responses;
-    private retentionPolicies;
-    private cleanupTimers;
-    /**
-     * Store a response with retention policy
-     *
-     * @param key - Storage key (typically `{method}:{path}`)
-     * @param response - Response data to cache
-     * @param config - Caching configuration (defaults to SINGLE retention)
-     * @param requestedAt - When the request was sent (for temporal tracking)
-     * @param receivedAt - When the response was received (for temporal tracking)
-     * @returns true if response was stored, false if refresh extended existing TTL
-     */
-    set<T>(key: string, response: T, config?: ResponseCacheConfig, requestedAt?: number, receivedAt?: number): boolean;
-    /**
-     * Get response if not expired
-     *
-     * @param key - Storage key
-     * @returns Response data or undefined if not found/expired
-     */
-    get<T = any>(key: string): T | undefined;
-    /**
-     * Get response by path and method
-     *
-     * @param path - API path
-     * @param method - HTTP method (defaults to 'get')
-     * @returns Response data or undefined if not found/expired
-     */
-    getByPath<T = any>(path: string, method?: string): T | undefined;
-    /**
-     * Check if response exists and is not expired
-     *
-     * @param key - Storage key
-     * @returns true if valid response exists
-     */
-    has(key: string): boolean;
-    /**
-     * Manually delete a response
-     *
-     * @param key - Storage key
-     */
-    delete(key: string): void;
-    /**
-     * Clear all responses for a path (all methods)
-     *
-     * @param path - API path to clear
-     */
-    clearPath(path: string): void;
-    /**
-     * Clear all responses
-     */
-    clear(): void;
-    /**
-     * Get count of cached responses
-     */
-    get size(): number;
-    /**
-     * Check if a response should be cleaned up after handler completes
-     *
-     * @param key - Storage key
-     * @returns true if response has IMMEDIATE retention policy
-     */
-    shouldCleanupAfterHandler(key: string): boolean;
-    /**
-     * Zone 2: Evaluates if TTL should be extended instead of replacing data
-     */
-    private shouldExtendTTL;
-    /**
-     * Extend TTL for existing cached response
-     */
-    private extendExistingTTL;
-    /**
-     * Zone 3: Reset cleanup timer for a cached response
-     */
-    private resetCleanupTimer;
-    /**
-     * Clear cleanup timer if it exists
-     */
-    private clearTimerIfExists;
-    /**
-     * Create cached response object with metadata
-     */
-    private createCachedResponse;
-    /**
-     * Calculate expiration timestamp based on config
-     */
-    private calculateExpiresAt;
-    /**
-     * Store response with retention policy
-     */
-    private storeResponse;
-    /**
-     * Zone 2: Configures retention policy for a stored response
-     */
-    private applyRetentionPolicy;
-    /**
-     * Make storage key from path and method
-     */
-    private makeKey;
-    /**
-     * Extract path from storage key
-     */
-    private extractPath;
-    /**
-     * Extract method from storage key
-     */
-    private extractMethod;
-    /**
-     * Get temporal metadata for a cached response
-     * Used for baseline-delta race condition handling
-     *
-     * @param key - Storage key
-     * @returns Temporal metadata or undefined if not found
-     */
-    getTemporalMetadata(key: string): {
-        requestedAt: number;
-        receivedAt: number;
-    } | undefined;
-    /**
-     * Get temporal metadata by path and method
-     *
-     * @param path - API path
-     * @param method - HTTP method (defaults to 'get')
-     * @returns Temporal metadata or undefined if not found
-     */
-    getTemporalMetadataByPath(path: string, method?: string): {
-        requestedAt: number;
-        receivedAt: number;
-    } | undefined;
-    /**
-     * Cleanup expired responses (called periodically if needed)
-     */
-    cleanup(): void;
-}
-//# sourceMappingURL=service-response-store.d.ts.map

package/core/core/model/service-response-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"service-response-store.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/model/service-response-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,mBAAmB,EAEpB,MAAM,oCAAoC,CAAC;AAmD5C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,iBAAiB,CAA0C;IACnE,OAAO,CAAC,aAAa,CAAqC;IAE1D;;;;;;;;;OASG;IACH,GAAG,CAAC,CAAC,EACH,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,CAAC,EACX,MAAM,GAAE,mBAA6D,EACrE,WAAW,SAAa,EACxB,UAAU,SAAa,GACtB,OAAO;IAiBV;;;;;OAKG;IACH,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAcxC;;;;;;OAMG;IACH,SAAS,CAAC,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,SAAQ,GAAG,CAAC,GAAG,SAAS;IAI/D;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB;;;;OAIG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAWzB;;;;OAIG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQ7B;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;OAKG;IACH,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAK/C;;OAEG;IACH,OAAO,CAAC,eAAe;IAevB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAKzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAkB5B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAM1B;;OAEG;IACH,OAAO,CAAC,aAAa;IAUrB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAiC5B;;OAEG;IACH,OAAO,CAAC,OAAO;IAIf;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB;;OAEG;IACH,OAAO,CAAC,aAAa;IAIrB;;;;;;OAMG;IACH,mBAAmB,CACjB,GAAG,EAAE,MAAM,GACV;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;IAU1D;;;;;;OAMG;IACH,yBAAyB,CACvB,IAAI,EAAE,MAAM,EACZ,MAAM,SAAQ,GACb;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;IAI1D;;OAEG;IACH,OAAO,IAAI,IAAI;CAQhB"}

package/core/types/service-response-store.d.ts

@@ -1,162 +0,0 @@
-/**
- * Response retention policies for ServiceResponseStore
- * Controls how long service responses are cached and when they're cleaned up
- *
- * @kosService core.service-request
- */
-export declare enum ResponseRetention {
-    /**
-     * Clear immediately after handler completes
-     * Use for one-time operations with no caching needs
-     *
-     * Note: Response remains available during handler execution (including async handlers).
-     * Cleanup happens AFTER the handler returns/resolves via ServiceRequestManager.
-     */
-    IMMEDIATE = "immediate",
-    /**
-     * Keep until next response for same path
-     * Default behavior - previous response replaced on new request
-     */
-    SINGLE = "single",
-    /**
-     * Keep for specified duration (ms)
-     * Automatic cleanup after TTL expires
-     */
-    TTL = "ttl",
-    /**
-     * Keep until model is destroyed
-     * Use for data needed throughout model lifetime
-     */
-    PERMANENT = "permanent",
-    /**
-     * Keep until explicitly cleared
-     * Manual cleanup required via clearServiceResponse()
-     */
-    MANUAL = "manual"
-}
-/**
- * Configuration for response caching behavior
- *
- * @kosService core.service-request
- * @kosApiLevel 15
- */
-export interface ResponseCacheConfig {
-    /**
-     * Retention policy determining when response is cleaned up
-     */
-    retention: ResponseRetention;
-    /**
-     * Time-to-live in milliseconds (required for TTL retention)
-     */
-    ttl?: number;
-    /**
-     * For TTL retention: extend TTL instead of replacing data on new request
-     *
-     * When false (default): New request clears old data and stores new data with fresh TTL
-     * When true: If cached data exists and hasn't expired, extend TTL without replacing data
-     *
-     * Use extendOnRefresh=true to avoid re-running expensive operations when cached data is still valid.
-     *
-     * @default false
-     *
-     * @example
-     * // Replace on each request (default)
-     * cache: { retention: ResponseRetention.TTL, ttl: 5 * 60 * 1000 }
-     *
-     * @example
-     * // Extend TTL on refresh - avoid re-fetching if cache valid
-     * cache: { retention: ResponseRetention.TTL, ttl: 5 * 60 * 1000, extendOnRefresh: true }
-     */
-    extendOnRefresh?: boolean;
-    /**
-     * Maximum number of responses to cache per path (future use)
-     */
-    maxSize?: number;
-}
-/**
- * Replay strategy for baseline-delta race condition handling
- * Determines which queued events to replay after baseline loads
- *
- * @kosService core.topic-handler
- */
-export declare enum ReplayStrategy {
-    /**
-     * Replay all queued events
-     * Use for: State machines, audit trails requiring complete event history
-     */
-    ALL = "all",
-    /**
-     * Replay events received at or after baseline request was sent
-     * Use for: High-frequency idempotent updates (quantities, sensor readings, status)
-     */
-    AFTER_REQUEST = "after-request",
-    /**
-     * Replay events received at or after baseline response was received
-     * Use for: Low-frequency config where baseline likely includes recent changes
-     */
-    AFTER_RESPONSE = "after-response",
-    /**
-     * Discard all queued events
-     * Use for: Baseline is always complete source of truth
-     */
-    NONE = "none"
-}
-/**
- * Baseline dependency configuration for topic handlers
- *
- * @kosService core.topic-handler
- * @kosApiLevel 15
- */
-export interface BaselineDependency {
-    /**
-     * API path of the baseline request this handler depends on
-     */
-    path: string;
-    /**
-     * HTTP method of the baseline request
-     * @default 'get'
-     */
-    method?: string;
-    /**
-     * Strategy for replaying queued events after baseline loads
-     * @default ReplayStrategy.AFTER_REQUEST
-     */
-    replayStrategy?: ReplayStrategy;
-}
-/**
- * Cached response with metadata
- */
-export interface CachedResponse<T = unknown> {
-    /**
-     * The response data
-     */
-    data: T;
-    /**
-     * When the response was cached (timestamp)
-     * @deprecated Use requestedAt or receivedAt for temporal comparisons
-     */
-    timestamp: number;
-    /**
-     * When the HTTP request was sent (timestamp)
-     * Used for baseline-delta temporal filtering
-     */
-    requestedAt: number;
-    /**
-     * When the HTTP response was received (timestamp)
-     * Used for baseline-delta temporal filtering
-     */
-    receivedAt: number;
-    /**
-     * The API path this response came from
-     */
-    path: string;
-    /**
-     * The HTTP method used
-     */
-    method: string;
-    /**
-     * When this response expires (for TTL retention)
-     */
-    expiresAt?: number;
-}
-//# sourceMappingURL=service-response-store.d.ts.map

package/core/types/service-response-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"service-response-store.d.ts","sourceRoot":"","sources":["../../../../../../packages/sdk/kos-ui-sdk/src/core/types/service-response-store.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oBAAY,iBAAiB;IAC3B;;;;;;OAMG;IACH,SAAS,cAAc;IAEvB;;;OAGG;IACH,MAAM,WAAW;IAEjB;;;OAGG;IACH,GAAG,QAAQ;IAEX;;;OAGG;IACH,SAAS,cAAc;IAEvB;;;OAGG;IACH,MAAM,WAAW;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,SAAS,EAAE,iBAAiB,CAAC;IAE7B;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;;;;;;;;;;;;;;;;OAiBG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,oBAAY,cAAc;IACxB;;;OAGG;IACH,GAAG,QAAQ;IAEX;;;OAGG;IACH,aAAa,kBAAkB;IAE/B;;;OAGG;IACH,cAAc,mBAAmB;IAEjC;;;OAGG;IACH,IAAI,SAAS;CACd;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO;IACzC;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC;IAER;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/core/util/ancestor-path-visitor.d.ts

@@ -1,60 +0,0 @@
-import { KosModelVisitor } from './kos-model-visitor';
-import { IKosDataModel, IKosModel } from '../core/kosModel';
-
-/**
- * Generic visitor that finds the ancestor path to a target item.
- * Works with any KOS model hierarchy that implements the visitor pattern.
- *
- * Uses depth-first traversal, tracking the path as it goes.
- * When the target is found, the accumulated path IS the ancestor list.
- *
- * Backtracking logic is entirely self-contained - no model changes needed.
- * Works well for Studio's typical model sizes (dozens to ~100 items).
- *
- * @example
- * ```typescript
- * const visitor = new AncestorPathVisitor('target-item-id');
- * visitor.start(rootContainerModel);
- * const ancestors = visitor.getAncestorPath(); // ['root', 'parent', 'grandparent']
- * ```
- *
- * @category Core
- * @kosService core.utils
- * @kosApiLevel 20
- */
-export declare class AncestorPathVisitor extends KosModelVisitor {
-    private targetId;
-    private currentPath;
-    private foundPath;
-    constructor(targetId: string);
-    /**
-     * Override visit() to wrap the entire visit lifecycle with path tracking.
-     *
-     * Flow:
-     * 1. Check cycle detection (skip if already visited)
-     * 2. Push model to path
-     * 3. Call visitModel() to check if this is target
-     * 4. If not target, visit children
-     * 5. Pop from path if target not found in this subtree (backtrack)
-     *
-     * Note: We inline the base class logic rather than calling super.visit()
-     * because we need to control exactly when push/pop happens relative to
-     * the cycle detection and child traversal.
-     */
-    visit(model: IKosModel): void;
-    /**
-     * Called for each model during traversal.
-     * Returns true to stop traversal when target is found.
-     */
-    visitModel<T extends IKosDataModel>(model: T): boolean | void;
-    /**
-     * Get the ancestor path (IDs from root to parent, not including target).
-     * Returns empty array if target not found or target is at root level.
-     */
-    getAncestorPath(): string[];
-    /**
-     * Check if target was found during traversal.
-     */
-    wasFound(): boolean;
-}
-//# sourceMappingURL=ancestor-path-visitor.d.ts.map

package/core/util/ancestor-path-visitor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ancestor-path-visitor.d.ts","sourceRoot":"","sources":["../../../../../../packages/sdk/kos-ui-sdk/src/core/util/ancestor-path-visitor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,mBAAoB,SAAQ,eAAe;IACtD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,SAAS,CAAyB;gBAE9B,QAAQ,EAAE,MAAM;IAK5B;;;;;;;;;;;;;OAaG;IACM,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAgCtC;;;OAGG;IACH,UAAU,CAAC,CAAC,SAAS,aAAa,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,GAAG,IAAI;IAY7D;;;OAGG;IACH,eAAe,IAAI,MAAM,EAAE;IAI3B;;OAEG;IACH,QAAQ,IAAI,OAAO;CAGpB"}