import { Func, Primitive } from './types';
import { IEvent, TEventTarget } from './events';
import { ICreateObsDispAPIParams, TGetObserversMap } from './api';
import { TObserverByIdMap } from './obsMap';
export declare const ON_CREATE_OBS_FIELD = "obs";
export declare const __removeAllObservers: (API: ICreateObsDispAPIParams, getObserversMap: TGetObserversMap) => () => void;
export interface IObserverTreeNode extends IObserverOptions {
    children: IObserverTreeNode[];
}
export interface IObserverOptions {
    /** Optional id (must be unique); if not passed, it is autogenerated */
    id?: string;
    /**
     * Optional name; it's an arbitrary key, not used by the library internally; can be
     * useful for debugging / display purposes or when dispatching events (target filter);
     * does not need to be unique
     * */
    name?: string;
    /**
     * Arbitrary meta data for the given observer; can be
     * useful for debugging / display purposes or when dispatching events (target filter);
     * does not need to be unique */
    meta?: Record<string, Primitive>;
}
export interface IObserver {
    handleEvent: (event: IEvent) => void;
    options?: IObserverOptions;
    parentId?: string;
    forChildren: (mapper: (obs: IObserver, childrenMap: TObserverByIdMap) => void) => void;
    /** Adds a child observer */
    addOD: (obs: IObserver) => IObserver;
    dispatchEvent: <T extends IEvent>(...args: Parameters<TDispatchEventType<T>>) => ReturnType<TDispatchEventType<T>>;
    /**
     * Removes the child observer that is passed
     * @param obs
     * @param skipChildren If passed as `true`, this will not automatically remove child observers
     */
    removeOD: (obs: IObserver, skipChildren: boolean) => void;
}
export type TEventDispatchOptions<T extends IEvent> = {
    payload?: T extends IEvent ? T['payload'] : {};
    target?: TEventTarget | TEventTarget[];
};
/**
 * Dispatches an obs-disp event.
 * Note: do not use self-referencing objects (expect exceptions) for payload
 * */
export declare const __dispatchEvent: (API: ICreateObsDispAPIParams, getObserversMap: TGetObserversMap) => <T extends IEvent>(event: string | Partial<T>, options?: TEventDispatchOptions<T>) => void;
export type TDispatchEventType<T extends IEvent> = (event: Partial<T> | IEvent['name'], options?: TEventDispatchOptions<T>) => void;
/**
 * Same as dispatchEvent but can be throttled via throttleMs
 * @param ev The default event (can be overriden when calling the function)
 * @param throttleMs default 200
 * @returns A throttled function that dispatches an event, e.g. as a generic func `dispatchThrottledEv = createThrottledDispatch(undefined, 200)`
 * ... later in the code ... `dispatchThrottledEv({ name: 'SOME_EVENT', payload: {}})`
 *
 * Or as a more specific throttled event func:
 * `dispatchSomeThrottledEv = createThrottledDispatch({ name: 'SOME_EVENT', 200)`
 * ... later in the code ... or overriding the payload if needed
 * `dispatchSomeThrottledEv({ payload: { somePayloadProp: 1 }})`
 */
export declare const __createThrottledDispatch: (API: ICreateObsDispAPIParams, getObserversMap: TGetObserversMap) => (ev: IEvent, opts?: {
    throttleMs?: number;
    debugLog?: string;
}) => () => any;
export interface IObserverEventHandlers extends Record<IEvent['name'], Func<IEvent, void>> {
}
/**
 * Adds (creates) a new global Observer (Observable Dispatcher or obs-disp)
 * which starts tracking events.
 *
 * Will generate a unique ID or use the provided ID (only one OD can exists with the same id)
 *
 * When an observer with the same id already exists (and replaceExisting is not passed or is `false`)
 * then a warning is thrown (can be handled via the `onWarn` handler on the API) and the existing observer is returned
 * @param eventHandlersOrFunc Either a map of event-name-to-handler or a function that returns such () => ({ ... })
 * @param options Common options available to each observer (like `id`)
 * @param props Initial properties which would be passed (convenient when not using this directly but
 * when using obsDispCreator<Props>((props: Props) => {...}))
 * @returns
 */
export declare const __addObsDisp: (API: ICreateObsDispAPIParams, getObserversMap: TGetObserversMap) => <T extends TObsCreateParams>(eventHandlersOrFunc: IObserverEventHandlers | Func<T, IObserverEventHandlers>, options?: IObserver['options'], props?: T) => IObserver;
declare const __getSampleAddObsDispFn: <T extends TObsCreateParams>() => (eventHandlersOrFunc: IObserverEventHandlers | Func<T, IObserverEventHandlers>, options?: IObserver['options'], props?: T) => IObserver;
export interface IAddObsDispType<T extends TObsCreateParams> extends ReturnType<typeof __getSampleAddObsDispFn<T>> {
}
export interface IAddObsDispParameters<T extends TObsCreateParams> extends Parameters<IAddObsDispType<T>> {
}
export interface IAddObsDispReturnType<T extends TObsCreateParams> extends ReturnType<IAddObsDispType<T>> {
}
/**
 * The initial parameters (props) when creating an obs-disp - a plain object or nothing (void)
 * */
export type TObsCreateParams = Record<string, unknown> | void;
export declare const __obsDispCreator: (API: ICreateObsDispAPIParams, getObserversMap: TGetObserversMap) => <T extends TObsCreateParams>(...args: [IAddObsDispParameters<T>[0], IAddObsDispParameters<T>[1]?, IAddObsDispParameters<T>[2]?]) => (props: T) => IObserver;
/**
 * Removes the observer (along with all of its children).
 * You can disable child removal by passing skipChildren as false
 * @param obs
 * @param skipChildren If passed as `true`, this will not automatically remove child observers
 */
export declare const __removeObs: (API: ICreateObsDispAPIParams, getObserversMap: TGetObserversMap) => (observer: IObserver, skipChildren?: boolean) => void;
export declare const __removeObsById: (API: ICreateObsDispAPIParams, getObserversMap: TGetObserversMap) => (id: string) => void;
export declare const __checkObsExists: (getObserversMap: TGetObserversMap) => (obs: IObserver) => boolean;
export declare const __checkObsExistsById: (getObserversMap: TGetObserversMap) => (id: string) => boolean;
export declare const addMultipleObs: (getObserversMap: TGetObserversMap) => (evHandlersOrFuncs: (Func<never, IObserverEventHandlers> | IObserverEventHandlers)[]) => IObserver[];
export {};