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

package/core/core/decorators/kos-future-aware.d.ts

@@ -1,162 +0,0 @@
-import { FutureAwareContainer, IFutureModel } from '../../../models/models/future/future-types';
-
-/**
- * @kosService core.future-aware
- * @kosApiLevel 13
- */
-export interface KosFutureAwareOptions {
-    /** Setup mode: 'full' includes all UI properties, 'minimal' only futureHandler. Default: 'full' */
-    mode?: "full" | "minimal";
-    /** Custom futureHandler property name. Default: 'futureHandler' */
-    handlerProperty?: string;
-}
-/**
- * Interface for models using @kosFutureAware in minimal mode.
- * Use TypeScript interface merging to add the futureHandler property to your model class.
- *
- * @example
- * Add ESLint disable comment at top of file, then:
- * ```typescript
- * interface BackgroundServiceModelImpl extends KosFutureAwareMinimal {}
- *
- * kosFutureAware({ mode: 'minimal' })
- * class BackgroundServiceModelImpl implements IKosDataModel {
- *   // futureHandler is now available via interface merging
- * }
- * ```
- *
- * @kosService core.future-aware
- * @kosApiLevel 13
- */
-export interface KosFutureAwareMinimal<T extends object = Record<string, unknown>> {
-    /**
-     * Core future management container that handles Future lifecycle operations.
-     * Provides methods to add, remove, and query Future instances.
-     * Automatically injected by @kosFutureAware decorator.
-     */
-    futureHandler: FutureAwareContainer<T>;
-}
-/**
- * Interface for models using @kosFutureAware in full mode (default).
- * Use TypeScript interface merging to add all Future Container properties to your model class.
- *
- * @example
- * Add ESLint disable comment at top of file, then:
- * ```typescript
- * interface CopyLogsModelImpl extends KosFutureAwareFull<CopyProgress> {}
- *
- * kosFutureAware() // defaults to full mode
- * class CopyLogsModelImpl implements IKosDataModel {
- *   // All Future Container properties are now available automatically
- *
- *   onFutureUpdate?(future: IFutureModel<CopyProgress>): void {
- *     // Access typed clientData
- *   }
- * }
- * ```
- *
- * @kosService core.future-aware
- * @kosApiLevel 13
- */
-export interface KosFutureAwareFull<T extends object = Record<string, unknown>> extends KosFutureAwareMinimal<T> {
-    /**
-     * Current active Future model instance containing operation details.
-     * Undefined when no operation is active. Automatically updated when
-     * operations start, progress, complete, or fail.
-     */
-    future?: IFutureModel<T>;
-    /**
-     * Current operation progress as a percentage (0-100).
-     * Returns 0 when no Future is active. Updates automatically as the
-     * Future operation progresses via WebSocket events.
-     */
-    progress: number;
-    /**
-     * Current operation status string representation.
-     * Common values: "IDLE", "IN_PROGRESS", "SUCCESS", "ERROR", "CANCELLED".
-     * Returns "IDLE" when no Future is active.
-     */
-    status: string;
-    /**
-     * Whether an operation is currently actively executing.
-     * True when Future exists and has not reached an end state.
-     * False when no Future exists or operation has completed/failed/cancelled.
-     */
-    isRunning: boolean;
-    /**
-     * Whether the current or most recent operation was cancelled.
-     * Remains true after cancellation for status tracking until a new
-     * operation starts. False if operation completed normally or failed.
-     */
-    isCancelled: boolean;
-    /**
-     * Cancels the currently running Future operation.
-     * Sends cancellation request to the backend service managing the Future.
-     * No-op if no Future is currently active.
-     * @returns Promise that resolves when cancellation is acknowledged
-     * @throws Error if cancellation request fails
-     */
-    cancelFuture(): Promise<void>;
-}
-/**
- * Class decorator that automatically adds Future Container capabilities to a KOS model.
- *
- * This decorator eliminates the need for manual Future Container setup by:
- * - Adding a futureHandler property for managing Future operations
- * - Adding reactive getters for future, progress, status, isRunning, isCancelled (in full mode)
- * - Adding cancelFuture method for canceling operations (in full mode)
- *
- * **Important**: Use TypeScript interface merging to get proper type information:
- *
- * ```typescript
- * // Add ESLint disable comment at top of file, then:
- * interface MyModelImpl extends KosFutureAwareFull<MyDataType> {}
- *
- * kosFutureAware()
- * class MyModelImpl implements IKosDataModel {
- *   // All Future properties are now available with full type safety
- * }
- * ```
- *
- * Note: This decorator supports single Future operations. For models that need to manage
- * multiple concurrent Futures, use @kosMultiFutureAware (coming soon).
- *
- * @param options Configuration options for the decorator
- * @returns A class decorator
- *
- * @example
- * ```typescript
- * // Full mode example
- * interface DeviceOperationsModelImpl extends KosFutureAwareFull<OperationData> {}
- *
- * kosFutureAware()
- * class DeviceOperationsModelImpl implements IKosDataModel {
- *   onFutureUpdate?(future: IFutureModel<OperationData>): void {
- *     // Handle Future updates
- *   }
- *
- *   kosFuture()
- *   async performOperation(): Promise<OperationData> {
- *     return { result: "done" };
- *   }
- * }
- *
- * // Minimal mode example
- * interface BackgroundServiceModelImpl extends KosFutureAwareMinimal {}
- *
- * kosFutureAware({ mode: 'minimal' })
- * class BackgroundServiceModelImpl implements IKosDataModel {
- *   kosFuture()
- *   async backgroundTask() {
- *     return "done";
- *   }
- * }
- * ```
- *
- * @category KOS Model Decorator
- * @since 2.0.0
- * @kosService core.future-aware
- * @kosApiLevel 13
- */
-export declare function kosFutureAware(options?: KosFutureAwareOptions): ClassDecorator;
-//# sourceMappingURL=kos-future-aware.d.ts.map

package/core/core/decorators/kos-future-aware.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kos-future-aware.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/decorators/kos-future-aware.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,YAAY,EACb,MAAM,4CAA4C,CAAC;AAGpD;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,mGAAmG;IACnG,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,mEAAmE;IACnE,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,qBAAqB,CACpC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAE1C;;;;OAIG;IACH,aAAa,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAC5E,SAAQ,qBAAqB,CAAC,CAAC,CAAC;IAChC;;;;OAIG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IAEzB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;;OAIG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;;;;OAMG;IACH,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,wBAAgB,cAAc,CAC5B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,cAAc,CAchB"}

package/core/core/decorators/kos-logger-aware.d.ts

@@ -1,105 +0,0 @@
-import { KosContextLogger } from '../kosModel';
-
-/**
- * @kosService core.logger-aware
- * @kosApiLevel 13
- */
-export interface KosLoggerAwareOptions {
-    /** Logger property name. Default: 'logger' */
-    loggerProperty?: string;
-    /** Logger context/group name. If not provided, uses model type */
-    loggerContext?: string;
-}
-/**
- * Interface for models using @kosLoggerAware decorator.
- * Use TypeScript interface merging to add the logger property to your model class.
- *
- * @example
- * ```typescript
- * interface MyModelImpl extends KosLoggerAware {}
- *
- * @kosModel("my-model")
- * @kosLoggerAware()
- * export class MyModelImpl implements IKosDataModel {
- *   id: string;
- *
- *   constructor(modelId: string, options: any, context: KosCreationContext) {
- *     this.id = modelId;
- *     // No logger setup needed - automatically injected!
- *   }
- *
- *   async performOperation() {
- *     this.logger.info("Starting operation"); // Direct access to logger
- *   }
- * }
- * ```
- *
- * @kosService core.logger-aware
- * @kosApiLevel 13
- */
-export interface KosLoggerAware {
-    /**
-     * KOS context logger for this model instance.
-     * Automatically injected by the @kosLoggerAware decorator.
-     * Shared across all instances of the same model type for optimal performance.
-     * Provides structured logging with debug(), info(), warn(), and error() methods.
-     * Logger context is automatically set to the model type name unless overridden.
-     */
-    logger: KosContextLogger;
-}
-/**
- * Class decorator that automatically injects a shared logger into a KOS model.
- *
- * This decorator eliminates the need for manual logger setup in constructors by:
- * - Creating a single shared logger per model type (not per instance)
- * - Using the KosLoggerFactory for consistent logger creation
- * - Following KOS naming conventions for logger context
- * - Providing optimal performance through logger reuse
- *
- * **Performance Note**: Creates one logger per model type, shared across all instances
- * of that type. This is much more efficient than per-instance logger creation.
- *
- * **Important**: Use TypeScript interface merging to get proper type information:
- *
- * ```typescript
- * interface MyModelImpl extends KosLoggerAware {}
- *
- * @kosModel("my-model")
- * @kosLoggerAware()
- * export class MyModelImpl implements IKosDataModel {
- *   // logger property is now available with full type safety
- *   async doSomething() {
- *     this.logger.debug("Doing something...");
- *   }
- * }
- * ```
- *
- * @param options Configuration options for the logger injection
- * @returns A class decorator
- *
- * @example
- * ```typescript
- * // Basic usage with default logger property
- * @kosLoggerAware()
- * class MyModel { }
- *
- * // Custom logger property name
- * @kosLoggerAware({ loggerProperty: 'log' })
- * class MyModel {
- *   // this.log is available instead of this.logger
- * }
- *
- * // Custom logger context for specialized logging
- * @kosLoggerAware({ loggerContext: 'analytics' })
- * class AnalyticsModel {
- *   // Logger uses "analytics" context instead of model type
- * }
- * ```
- *
- * @category KOS Model Decorator
- * @since 2.1.0
- * @kosService core.logger-aware
- * @kosApiLevel 13
- */
-export declare function kosLoggerAware(options?: KosLoggerAwareOptions): ClassDecorator;
-//# sourceMappingURL=kos-logger-aware.d.ts.map

package/core/core/decorators/kos-logger-aware.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kos-logger-aware.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/decorators/kos-logger-aware.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIpD;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,8CAA8C;IAC9C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kEAAkE;IAClE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;OAMG;IACH,MAAM,EAAE,gBAAgB,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,cAAc,CAC5B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,cAAc,CAoChB"}

package/core/core/decorators/kos-multiple-future-aware.d.ts

@@ -1,217 +0,0 @@
-import { IFutureModel } from '../../../models/models/future/future-types';
-import { MultipleFutureHandler } from '../../../models/models/future/future-aware';
-
-/**
- * @kosService core.future-aware
- * @kosApiLevel 14
- */
-export interface KosMultipleFutureAwareOptions {
-    /** Setup mode: 'full' includes all UI properties, 'minimal' only futureHandler. Default: 'full' */
-    mode?: "full" | "minimal";
-    /** Custom futureHandler property name. Default: 'futureHandler' */
-    handlerProperty?: string;
-}
-/**
- * Interface for models using @kosMultipleFutureAware in minimal mode.
- * Use TypeScript interface merging to add the futureHandler property and named futures to your model class.
- *
- * @example
- * Add ESLint disable comment at top of file, then:
- * ```typescript
- * interface MaintenanceModelImpl extends KosMultipleFutureAwareMinimal {
- *   // Add your specific named futures manually for strong typing:
- *   calibrationFuture?: IFutureModel;
- *   cleaningFuture?: IFutureModel;
- * }
- *
- * @kosMultipleFutureAware({ mode: 'minimal' })
- * class MaintenanceModelImpl implements IKosDataModel {
- *   // futureHandler and named futures are now available via interface merging
- * }
- * ```
- *
- * @kosService core.future-aware
- * @kosApiLevel 14
- */
-export interface KosMultipleFutureAwareMinimal {
-    /**
-     * Core multiple future management container that handles concurrent Future lifecycle operations.
-     * Provides methods to add, remove, and query multiple Future instances.
-     * Automatically injected by @kosMultipleFutureAware decorator.
-     */
-    futureHandler: MultipleFutureHandler;
-    /**
-     * Default future from the handler.
-     * Returns the most recently added future or undefined if no futures are active.
-     */
-    future?: IFutureModel;
-}
-/**
- * Utility types to generate future property names for multiple futures (for internal use)
- */
-type FutureGetters<T extends string> = {
-    readonly [K in T as `${K}Future`]?: IFutureModel;
-};
-type ProgressGetters<T extends string> = {
-    readonly [K in T as `${K}Progress`]: number;
-};
-type StatusGetters<T extends string> = {
-    readonly [K in T as `${K}Status`]: string;
-};
-type IsRunningGetters<T extends string> = {
-    readonly [K in T as `${K}IsRunning`]: boolean;
-};
-type IsCancelledGetters<T extends string> = {
-    readonly [K in T as `${K}IsCancelled`]: boolean;
-};
-type CancelMethods<T extends string> = {
-    readonly [K in T as `cancel${Capitalize<K>}`]: () => Promise<void>;
-};
-/**
- * @kosService core.future-aware
- */
-export type MultipleFutureProperties<T extends string> = FutureGetters<T> & ProgressGetters<T> & StatusGetters<T> & IsRunningGetters<T> & IsCancelledGetters<T> & CancelMethods<T>;
-/**
- * Interface for models using @kosMultipleFutureAware in full mode (default).
- * Use TypeScript interface merging to add all Future Container properties and named futures to your model class.
- *
- * @example
- * Add ESLint disable comment at top of file, then:
- * ```typescript
- * interface IceAgitatorModelImpl extends KosMultipleFutureAwareFull<"pour" | "agitate" | "gate"> {}
- *
- * @kosMultipleFutureAware() // defaults to full mode
- * class IceAgitatorModelImpl implements IKosDataModel {
- *   // All Future Container properties and named futures are now available automatically
- *   // Access: this.pourFuture, this.agitateFuture, this.gateFuture
- *
- *   onFutureUpdate?(future: IFutureModel, alias?: string): void {
- *     // Handle updates from any managed Future
- *     // Use alias to identify which future triggered the update
- *     if (alias === 'pour') {
- *       console.log(`Pour operation: ${future.progress}%`);
- *     }
- *   }
- * }
- * ```
- *
- * @kosService core.future-aware
- */
-export type KosMultipleFutureAwareFull<T extends string = string> = KosMultipleFutureAwareMinimal & MultipleFutureProperties<T> & {
-    /**
-     * Current operation progress as a percentage (0-100) for the default future.
-     * Returns 0 when no default Future is active. Updates automatically as the
-     * Future operation progresses via WebSocket events.
-     */
-    progress: number;
-    /**
-     * Current operation status string representation for the default future.
-     * Common values: "IDLE", "IN_PROGRESS", "SUCCESS", "ERROR", "CANCELLED".
-     * Returns "IDLE" when no default Future is active.
-     */
-    status: string;
-    /**
-     * Whether the default operation is currently actively executing.
-     * True when default Future exists and has not reached an end state.
-     * False when no Future exists or operation has completed/failed/cancelled.
-     */
-    isRunning: boolean;
-    /**
-     * Whether the current or most recent default operation was cancelled.
-     * Remains true after cancellation for status tracking until a new
-     * operation starts. False if operation completed normally or failed.
-     */
-    isCancelled: boolean;
-    /**
-     * Cancels the currently running default Future operation.
-     * Sends cancellation request to the backend service managing the Future.
-     * No-op if no default Future is currently active.
-     * @returns Promise that resolves when cancellation is acknowledged
-     * @throws Error if cancellation request fails
-     */
-    cancelFuture(): Promise<void>;
-};
-/**
- * Class decorator that automatically adds Multiple Future Container capabilities to a KOS model.
- *
- * This decorator eliminates the need for manual MultipleFutureHandler setup by:
- * - Adding a futureHandler property for managing multiple concurrent Future operations
- * - Adding reactive getters for default future, progress, status, isRunning, isCancelled (in full mode)
- * - Adding dynamic named future getters based on @kosFuture aliases
- * - Adding cancelFuture method for canceling the default operation (in full mode)
- *
- * **Important**: Use TypeScript interface merging to get proper type information:
- *
- * ```typescript
- * // Add ESLint disable comment at top of file, then:
- * interface MyModelImpl extends KosMultipleFutureAwareFull<"operation1" | "operation2"> {}
- *
- * @kosMultipleFutureAware()
- * class MyModelImpl implements IKosDataModel {
- *   // All Future properties and named futures are now available with full type safety
- * }
- * ```
- *
- * Note: This decorator supports multiple concurrent Future operations. For models that only need
- * single Future support, use @kosFutureAware instead.
- *
- * @param options Configuration options for the decorator
- * @returns A class decorator
- *
- * @example
- * ```typescript
- * // Full mode example with multiple futures
- * interface IceAgitatorModelImpl extends KosMultipleFutureAwareFull<"pour" | "agitate" | "gate"> {}
- *
- * @kosMultipleFutureAware()
- * class IceAgitatorModelImpl implements IKosDataModel {
- *   get isPouring() {
- *     return !!(this.pourFuture && !this.pourFuture?.endState);
- *   }
- *
- *   onFutureUpdate?(future: IFutureModel, alias?: string): void {
- *     // Handle Future updates from any operation
- *     // Use alias to discriminate between different future types
- *     if (alias === 'pour') {
- *       console.log(`Pouring ice: ${future.progress}%`);
- *     } else if (alias === 'agitate') {
- *       console.log(`Agitating: ${future.progress}%`);
- *     }
- *   }
- *
- *   @kosFuture({ alias: "pour" })
- *   async pourIce(): Promise<void> {
- *     // Pour operation
- *   }
- *
- *   @kosFuture({ alias: "agitate" })
- *   async testAgitate(): Promise<void> {
- *     // Agitation operation
- *   }
- * }
- *
- * // Minimal mode example
- * interface BackgroundServiceModelImpl extends KosMultipleFutureAwareMinimal<"task1" | "task2"> {}
- *
- * @kosMultipleFutureAware({ mode: 'minimal' })
- * class BackgroundServiceModelImpl implements IKosDataModel {
- *   @kosFuture({ alias: "task1" })
- *   async backgroundTask1() {
- *     return "done";
- *   }
- *
- *   @kosFuture({ alias: "task2" })
- *   async backgroundTask2() {
- *     return "done";
- *   }
- * }
- * ```
- *
- * @category KOS Model Decorator
- * @since 2.0.0
- * @kosService core.future-aware
- * @kosApiLevel 14
- */
-export declare function kosMultipleFutureAware(options?: KosMultipleFutureAwareOptions): ClassDecorator;
-export {};
-//# sourceMappingURL=kos-multiple-future-aware.d.ts.map

package/core/core/decorators/kos-multiple-future-aware.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kos-multiple-future-aware.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/decorators/kos-multiple-future-aware.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AACxF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAG/E;;;GAGG;AACH,MAAM,WAAW,6BAA6B;IAC5C,mGAAmG;IACnG,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,mEAAmE;IACnE,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;;OAIG;IACH,aAAa,EAAE,qBAAqB,CAAC;IAErC;;;OAGG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED;;GAEG;AACH,KAAK,aAAa,CAAC,CAAC,SAAS,MAAM,IAAI;IACrC,QAAQ,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,YAAY;CACjD,CAAC;AAEF,KAAK,eAAe,CAAC,CAAC,SAAS,MAAM,IAAI;IACvC,QAAQ,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,UAAU,GAAG,MAAM;CAC5C,CAAC;AAEF,KAAK,aAAa,CAAC,CAAC,SAAS,MAAM,IAAI;IACrC,QAAQ,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,QAAQ,GAAG,MAAM;CAC1C,CAAC;AAEF,KAAK,gBAAgB,CAAC,CAAC,SAAS,MAAM,IAAI;IACxC,QAAQ,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,WAAW,GAAG,OAAO;CAC9C,CAAC;AAEF,KAAK,kBAAkB,CAAC,CAAC,SAAS,MAAM,IAAI;IAC1C,QAAQ,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,aAAa,GAAG,OAAO;CAChD,CAAC;AAEF,KAAK,aAAa,CAAC,CAAC,SAAS,MAAM,IAAI;IACrC,QAAQ,EAAE,CAAC,IAAI,CAAC,IAAI,SAAS,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC;CACnE,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,wBAAwB,CAAC,CAAC,SAAS,MAAM,IAAI,aAAa,CAAC,CAAC,CAAC,GACvE,eAAe,CAAC,CAAC,CAAC,GAClB,aAAa,CAAC,CAAC,CAAC,GAChB,gBAAgB,CAAC,CAAC,CAAC,GACnB,kBAAkB,CAAC,CAAC,CAAC,GACrB,aAAa,CAAC,CAAC,CAAC,CAAC;AAEnB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAC9D,6BAA6B,GAC3B,wBAAwB,CAAC,CAAC,CAAC,GAAG;IAC5B;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;;OAIG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;;;;OAMG;IACH,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B,CAAC;AAEN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,CAAC,EAAE,6BAA6B,GACtC,cAAc,CAchB"}

package/core/core/decorators/kos-service-request-helpers.d.ts

@@ -1,60 +0,0 @@
-import { ErrorResponseContext } from '../../util/service-request-error';
-
-/**
- * Helper functions for kosServiceRequest decorator.
- *
- * These functions are extracted to reduce complexity and improve maintainability
- * of the service request decorator implementation.
- */
-/**
- * Resolves all parameters for a service request.
- *
- * This helper function handles the complex parameter resolution logic including:
- * - Resolving PropKeys in path
- * - Merging decorator-defined params with runtime params
- * - Building the final API params object
- *
- * @param metadata - Service request metadata
- * @param modelInstance - The model instance (this context)
- * @param args - Original method arguments
- * @param runtimeOptions - Runtime execution options
- * @returns Resolved parameters for the API request
- */
-export declare function resolveServiceRequestParameters(metadata: any, modelInstance: any, args: any[], runtimeOptions: any): {
-    resolvedPath: string;
-    apiParams: any;
-    finalBody: any;
-    finalRequestOptions: any;
-};
-/**
- * Executes an API method with the appropriate HTTP verb.
- *
- * This helper function handles the complexity of method selection and execution,
- * supporting GET, POST, PUT, and DELETE operations with proper parameter passing.
- *
- * @param API - The API client instance
- * @param method - HTTP method (get, post, put, delete)
- * @param path - Resolved API path
- * @param params - API parameters (path, query)
- * @param body - Request body (for POST, PUT, DELETE)
- * @param requestOptions - Additional request options
- * @returns Error-first tuple with response
- */
-export declare function executeApiMethod(API: any, method: string | undefined, path: string, params: any, body: any, requestOptions: any): Promise<[string | null, any, ErrorResponseContext?]>;
-/**
- * Handles service request errors according to the configured error handling strategy.
- *
- * This helper function implements the error handling strategies defined in metadata:
- * - "throw": Return error tuple for caller to handle
- * - "log": Log error and return default value
- * - "ignore": Silently return default value
- * - "default": Return default value
- *
- * @param error - Error message from API call
- * @param response - API response (may contain status code)
- * @param errorHandler - Error handler configuration from metadata
- * @param modelInstance - The model instance (this context)
- * @returns Error-first tuple with default value or error
- */
-export declare function handleServiceRequestError(error: string, response: any, errorHandler: any, modelInstance: any, errorContext?: ErrorResponseContext): [string | null, any];
-//# sourceMappingURL=kos-service-request-helpers.d.ts.map

package/core/core/decorators/kos-service-request-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kos-service-request-helpers.d.ts","sourceRoot":"","sources":["../../../../../../../packages/sdk/kos-ui-sdk/src/core/core/decorators/kos-service-request-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAM7E;;;;;GAKG;AAEH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,GAAG,EACb,aAAa,EAAE,GAAG,EAClB,IAAI,EAAE,GAAG,EAAE,EACX,cAAc,EAAE,GAAG;;;;;EAgEpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,GAAG,EACX,IAAI,EAAE,GAAG,EACT,cAAc,EAAE,GAAG,GAClB,OAAO,CAAC,CAAC,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAgBtD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,GAAG,EACb,YAAY,EAAE,GAAG,EACjB,aAAa,EAAE,GAAG,EAClB,YAAY,CAAC,EAAE,oBAAoB,GAClC,CAAC,MAAM,GAAG,IAAI,EAAE,GAAG,CAAC,CAqCtB"}