import { PublicModelInterface } from '../../core/types';
import { IKosDataModel } from '../../core/core/kosModel';

/**
 * External interface for companion decorators
 * This is what gets added to the public model type, similar to ExternalFutureInterface
 */
export interface ExternalCompanionInterface<TParent extends IKosDataModel> {
    /**
     * Get the parent model instance
     */
    getParent(): TParent;
}
/**
 * Mixin class that provides companion decorator functionality
 * This can be composed into any companion model without inheritance issues
 */
export declare class CompanionDecoratorMixin<TParent extends IKosDataModel> {
    private parent;
    private companion;
    constructor(companion: IKosDataModel, parent: TParent);
    /**
     * Get the parent model instance
     */
    getParent(): TParent;
    /**
     * Setup proxy properties for parent's public interface
     * This is called after the companion's constructor to avoid MobX issues
     */
    setupProxy(options?: {
        excludeProperties?: string[];
        includeLifecycle?: boolean;
    }): void;
    private getAllParentProperties;
    private createProxyProperty;
}
/**
 * Setup function for drop-in replacement companions
 *
 * ⚠️  Use this ONLY when you need seamless parent model replacement.
 * ✅  For most cases, prefer simple composition: `public readonly parent: ParentModel`
 *
 * This creates transparent proxies to all parent properties/methods.
 */
export declare function setupCompanionDecoratorMixin<TParent extends IKosDataModel>(companion: IKosDataModel, parent: TParent, options?: {
    excludeProperties?: string[];
    includeLifecycle?: boolean;
}): CompanionDecoratorMixin<TParent>;
/**
 * Type utility for companions using the interface mixin approach
 * This provides proper typing for the resulting companion
 */
export type CompanionWithMixin<TParent extends IKosDataModel, TExtensions = Record<string, never>> = TExtensions & ExternalCompanionInterface<TParent> & IKosDataModel & Omit<PublicModelInterface<TParent>, keyof IKosDataModel>;
/**
 * Type helper for adding companion support to models
 * This adds the parent's interface and companion functionality to your model
 */
export type WithCompanionSupport<TModel extends IKosDataModel, TParent extends IKosDataModel, TExtensions = Record<string, never>> = TModel & CompanionWithMixin<TParent, TExtensions>;
/**
 * Helper function to check if a model has companion mixin support
 */
export declare function hasCompanionMixin(model: any): boolean;
/**
 * Get the companion mixin instance from a model
 */
export declare function getCompanionMixin<TParent extends IKosDataModel>(companion: any): CompanionDecoratorMixin<TParent> | null;
/**
 * Development utility to inspect companion mixin setup (optional debugging tool)
 */
export declare function inspectCompanionMixin(companion: any): {
    error: string;
    parentType?: undefined;
    companionType?: undefined;
    proxiedProps?: undefined;
    proxiedCount?: undefined;
} | {
    parentType: string;
    companionType: any;
    proxiedProps: string[];
    proxiedCount: number;
    error?: undefined;
};
//# sourceMappingURL=kosmodel-interface-companion-mixin.d.ts.map