import { FutureAwareContainer, FutureContainer } from '../models/future/future-types';
import { IKosDataModel } from '../../core/core/kosModel';

/**
 * KosModel-compatible mixin that provides all the FutureContainer boilerplate
 * This version is designed to work with @kosModel's automatic makeAutoObservable() call
 */
export declare class KosModelFutureContainerMixin<T extends object = Record<string, unknown>> implements FutureContainer<T> {
    futureHandler: FutureAwareContainer<T>;
    constructor(model: IKosDataModel);
    get future(): import('../models/future/future-types').IFutureModel<T> | undefined;
    get progress(): number;
    get status(): string;
    get isRunning(): boolean;
    get isCancelled(): boolean;
    cancelFuture(): Promise<void>;
}
/**
 * Setup minimal Future support - only adds futureHandler for @kosFuture methods
 * Use this when you only need Future methods to work internally but don't expose the interface
 *
 * Perfect for the nozzle-model pattern where:
 * - The impl class only declares futureHandler
 * - The external type adds ExternalFutureInterface via intersection
 * - No need for declare statements for progress/status/etc in the impl
 */
export declare function setupMinimalFutureSupport<T extends IKosDataModel>(model: T): void;
/**
 * Setup complete Future support with all getters and methods
 * Use this when you need full Future capabilities both internally and externally
 *
 * This means:
 * - When the Future's progress/status changes, UI components will reactively update
 * - The getters track the observable properties in the underlying FutureModel
 * - This is exactly what you want for reactive UI updates!
 *
 * @example
 * // @kosModel("my-model")
 * // export class MyModelImpl implements IKosDataModel, CompleteFutureContainer {
 * //   id: string;
 * //
 * //   // These will be set by setupCompleteFutureSupport()
 * //   declare futureHandler: FutureAwareContainer<Record<string, unknown>>;
 * //   declare future: any;
 * //   declare progress: number;
 * //   declare status: string;
 * //   declare isRunning: boolean;
 * //   declare isCancelled: boolean;
 * //   declare cancelFuture: () => Promise<void>;
 * //
 * //   constructor(modelId: string, options: any, context: KosCreationContext) {
 * //     this.id = modelId;
 * //     setupCompleteFutureSupport(this);
 * //   }
 * //
 * //   @kosFuture()
 * //   async performOperation() { return "done"; }
 * // }
 * //
 * // export type MyModel = PublicModelInterface<MyModelImpl>;
 */
export declare function setupCompleteFutureSupport<T extends IKosDataModel>(model: T): void;
/**
 * Alternative decorator approach that works with @kosModel
 * This decorator must be applied AFTER @kosModel
 *
 * @example
 * // @kosModel("my-model")
 * // @withKosModelFutures()  // AFTER @kosModel
 * // export class MyModel implements IKosDataModel {
 * //   id: string;
 * //
 * //   constructor(modelId: string, options: any, context: KosCreationContext) {
 * //     this.id = modelId;
 * //     // No need to call setup function with decorator approach
 * //   }
 * //
 * //   @kosFuture()
 * //   async performOperation() { return "done"; }
 * //
 * //   unload() {}
 * // }
 */
export declare function withKosModelFutures(): (constructor: any) => any;
/**
 * Composition helper that works with @kosModel
 * Use this if you prefer composition over setup function
 *
 * @example
 * Example usage:
 *
 * @kosModel("my-model")
 * export class MyModel implements IKosDataModel, FutureContainer {
 *   id: string;
 *   private futures = createKosModelFutureManager(this);
 *
 *   // Delegate FutureContainer interface
 *   get futureHandler() { return this.futures.futureHandler; }
 *   get future() { return this.futures.future; }
 *   get progress() { return this.futures.progress; }
 *   get status() { return this.futures.status; }
 *   get isRunning() { return this.futures.isRunning; }
 *   get isCancelled() { return this.futures.isCancelled; }
 *   async cancelFuture() { return this.futures.cancelFuture(); }
 *
 *   constructor(modelId: string, options: any, context: KosCreationContext) {
 *     this.id = modelId;
 *   }
 *
 *   async performOperation() { return "done"; }
 *   unload() {}
 * }
 */
export declare function createKosModelFutureManager<T extends IKosDataModel>(model: T): KosModelFutureContainerMixin<Record<string, unknown>>;
/**
 * Enhanced composition helper with lazy initialization
 * This version delays future manager creation until first access
 * Useful if the manager needs to be created after the model is fully constructed
 */
export declare function createLazyKosModelFutureManager<T extends IKosDataModel>(getModel: () => T): {
    readonly futureHandler: FutureAwareContainer<Record<string, unknown>>;
    readonly future: import('../models/future/future-types').IFutureModel<Record<string, unknown>> | undefined;
    readonly progress: number;
    readonly status: string;
    readonly isRunning: boolean;
    readonly isCancelled: boolean;
    cancelFuture(): Promise<void>;
};
/**
 * Type helper for models that use KosModel future support
 */
export type KosModelWithFutures<T> = T & FutureContainer;
/**
 * Utility to check if a model has been set up with KosModel future support
 */
export declare function hasKosModelFutureSupport(model: any): model is FutureContainer;
/**
 * Development utility to inspect the observable state of Future properties
 * Useful for debugging MobX integration issues
 */
export declare function inspectFutureObservability(model: any): Record<string, any>;
//# sourceMappingURL=kosmodel-compatible-future-mixin.d.ts.map