import { AnnotationMapEntry, IAtom, IEqualsComparer } from 'mobx';
import { AnyObject, Maybe } from 'yummies/types';

type ObservableAnnotationsArray<T extends AnyObject = AnyObject> = [
    AnnotationMapEntry,
    ...(keyof T | (string & {}))[]
][];
declare const applyObservable: <T extends AnyObject>(context: T, annotationsArray: ObservableAnnotationsArray<T>, useDecorators?: boolean) => void;

interface IEnhancedAtom<TMeta extends AnyObject = AnyObject> extends IAtom {
    meta: TMeta;
}
/**
 * Creates an enhanced atom with meta data
 * And bind `reportChanged` and `reportObserved` method to the atom
 */
declare const createEnhancedAtom: <TMeta extends AnyObject>(name: string, onBecomeObservedHandler?: (atom: IEnhancedAtom<TMeta>) => void, onBecomeUnobservedHandler?: (atom: IEnhancedAtom<TMeta>) => void, meta?: TMeta) => IEnhancedAtom<TMeta>;

/**
 * You can return `false` if you don't want to change the value in this ref
 */
type RefChangeListener<T> = (value: T | null, prevValue: T | undefined) => void | false;
/**
 * Alternative to React.createRef but works in MobX world.
 * Typically it the should be the same React.LegacyRef (fn style)
 */
interface Ref<T = any, TMeta = AnyObject> {
    /**
     * Setter function
     */
    (value: Maybe<T>): void;
    set(value: Maybe<T>): void;
    listeners: Set<RefChangeListener<NoInfer<T>>>;
    current: NoInfer<T> | null;
    meta: TMeta;
}
interface CreateRefConfig<T = any, TMeta = AnyObject> {
    onSet?: (node: T, prevValue: T | undefined) => void;
    onUnset?: (lastValue: T | undefined) => void;
    onChange?: RefChangeListener<T>;
    meta?: TMeta;
    initial?: Maybe<T>;
    comparer?: IEqualsComparer<T | null>;
}
/**
 * Creates ref thing to attach HTMLElements in React and all other
 */
declare const createRef: <T = any, TMeta = AnyObject>(cfg?: CreateRefConfig<T, TMeta>) => Ref<T, TMeta>;
declare const isRef: <T, TMeta = any>(value: T | Ref<T, TMeta>) => value is Ref<T, TMeta>;
declare const toRef: <T, TMeta = any>(value: T | Ref<T, TMeta>, cfg?: Omit<CreateRefConfig<T, TMeta>, "initial">) => Ref<T, TMeta>;

declare class DeepObservableStruct<TData extends AnyObject> {
    data: TData;
    constructor(data: TData);
    set(newData: Partial<TData>): void;
}

type ObservableObjectAdministration = Parameters<Exclude<AnnotationMapEntry, boolean>['make_']>[0];
declare const getMobxAdministration: (context: AnyObject) => ObservableObjectAdministration;

/**
 * When ONE OF the properties is becomes observed then `onStart` function is called.
 * WHen ALL properties are unobserved then `onEnd` function is called with the `metaData` that was returned by `onStart`.
 *
 * It uses `onBecomeObserved` and `onBecomeUnobserved` mobx hooks to perform lazy observation.
 */
declare const lazyObserve: <TMetaData = void>({ context, property, onStart, onEnd, endDelay, }: {
    context?: any;
    property: any | any[];
    onStart?: () => TMetaData;
    onEnd?: (metaData: TMetaData, cleanupFn: VoidFunction) => void;
    endDelay?: number | false;
}) => () => void;

export { DeepObservableStruct, applyObservable, createEnhancedAtom, createRef, getMobxAdministration, isRef, lazyObserve, toRef };
export type { CreateRefConfig, IEnhancedAtom, ObservableAnnotationsArray, Ref, RefChangeListener };