import { Context } from 'react';
import { Dispatch } from 'react';
import { MutableRefObject } from 'react';
import { Pxth } from 'pxth';
import { default as React_2 } from 'react';
import { SetStateAction } from 'react';

export declare const areProxyMapsEqual: (map1: ProxyMapSource<unknown>, map2: ProxyMapSource<unknown>) => boolean;

/** Object, in which "stocked" calls observers */
declare type BatchUpdate<T> = {
    /** which paths should be updated */
    paths: Pxth<unknown>[];
    /** path, which triggered subtree update */
    origin: Pxth<unknown>;
    /** all values, which should be sent to observers */
    values: T;
};
export { BatchUpdate }
export { BatchUpdate as BatchUpdate_alias_1 }
export { BatchUpdate as BatchUpdate_alias_2 }

export declare const createProxyMap: <T>(mapSource: ProxyMapSource<T>) => PxthMap<any>;

export declare const getInnerPaths: <V>(path: Pxth<V>, proxyMap: PxthMap<Pxth<unknown>>) => [key: any, value: any][];

export declare const hashPxth: <V>(pxth: Pxth<V>) => string;

export declare const hasMappedParentPaths: <V>(path: Pxth<V>, proxyMap: PxthMap<Pxth<unknown>>) => boolean;

/**
 * Helper function. Calls `standardCallback` if `proxy` is undefined, or if `path` isn't inner path of `proxy.path` variable.
 * Otherwise, calls `proxiedCallback`.
 * Passes args into function.
 */
declare const intercept: <T extends (...args: any[]) => any>(proxy: StockProxy<unknown> | undefined, path: Pxth<unknown>, standardCallback: T, proxiedCallback: T, args: Parameters<T>) => ReturnType<T>;
export { intercept }
export { intercept as intercept_alias_1 }

/**
 * Simple example of StockProxy.
 * Proxies values by map. Map is built by this method:
 * {
 *      a: {
 *          b: {
 *              c: "<path to real value, in stock>"
 *          },
 *      }
 * }
 */
declare class MappingProxy<T> extends StockProxy<T> {
    private readonly proxyMap;
    constructor(mapSource: ProxyMapSource<T>, path: Pxth<T>);
    setValue: <V>(path: Pxth<V>, value: SetStateAction<V>, defaultSetValue: <U>(path: Pxth<U>, value: SetStateAction<U>) => void, defaultGetValue: <U>(path: Pxth<U>) => U) => void;
    watch: <V>(path: Pxth<V>, observer: Observer<V>, defaultWatch: <U>(path: Pxth<U>, observer: Observer<U>) => () => void) => () => void;
    watchEffect: <V>(path: Pxth<V>, observer: Observer<V>, defaultWatchEffect: <U>(path: Pxth<U>, observer: Observer<U>) => () => void) => () => void;
    getValue: <V>(path: Pxth<V>, defaultGetValue: <U>(path: Pxth<U>) => U) => V;
    private mapValue;
    getProxiedPath: <V>(path: Pxth<V>) => Pxth<V>;
    getNormalPath: <V>(path: Pxth<V>) => Pxth<V>;
}
export { MappingProxy }
export { MappingProxy as MappingProxy_alias_1 }
export { MappingProxy as MappingProxy_alias_2 }

declare type ObjectMappingType<T> = {
    [P in keyof T]: ProxyMapSource<T[P]>;
};

declare type Observer<V> = (message: V) => void;
export { Observer }
export { Observer as Observer_alias_1 }
export { Observer as Observer_alias_2 }

declare class ObserverArray<V> {
    private readonly observers;
    private counter;
    /**
     * Calls all observers in the array.
     * @param message - message, which would be sent to all observers
     */
    call(message: V): void;
    /**
     * Registers new observer and returns key, which will be used for removing observer.
     * @param observer - registers new observer
     */
    add(observer: Observer<V>): ObserverKey;
    /**
     * Removes observer from array. Throws an error, if observer with that key not exists.
     * @param key - key to observer
     */
    remove(key: ObserverKey): void;
    /**
     * Does array include at least one observer or not.
     */
    isEmpty: () => boolean;
}
export { ObserverArray }
export { ObserverArray as ObserverArray_alias_1 }

declare type ObserverKey = number;
export { ObserverKey }
export { ObserverKey as ObserverKey_alias_1 }

declare type ObserversControl<T> = {
    /**
     * Watch stock value. Returns cleanup function.
     * @deprecated - use watchEffect instead
     */
    watch: <V>(path: Pxth<V>, observer: Observer<V>) => () => void;
    /**
     * Watch all stock values. Returns cleanup function.
     * @deprecated - use watchEffect instead
     */
    watchAll: (observer: Observer<T>) => () => void;
    /** Watch stock value. Returns cleanup function. Calls observer instantly. */
    watchEffect: <V>(path: Pxth<V>, observer: Observer<V>) => () => void;
    /** Check if value is observed or not. */
    isObserved: <V>(path: Pxth<V>) => boolean;
    /** Notify all observers, which are children of specified path */
    notifySubTree: <V>(path: Pxth<V>, values: T) => void;
    /** Notify all observers */
    notifyAll: (values: T) => void;
    /** "stocked" updates values in batches, so you can subscribe to batch updates. Returns cleanup. */
    watchBatchUpdates: (observer: Observer<BatchUpdate<T>>) => () => void;
};
export { ObserversControl }
export { ObserversControl as ObserversControl_alias_1 }
export { ObserversControl as ObserversControl_alias_2 }

declare type Primitive = string | number | boolean | bigint | symbol | null | undefined;

declare const ProxyContext: Context<StockProxy<unknown> | undefined>;
export { ProxyContext }
export { ProxyContext as ProxyContext_alias_1 }
export { ProxyContext as ProxyContext_alias_2 }

declare type ProxyMapSource<T> = T extends Primitive ? Pxth<T> : ObjectMappingType<T> | Pxth<T>;
export { ProxyMapSource }
export { ProxyMapSource as ProxyMapSource_alias_1 }
export { ProxyMapSource as ProxyMapSource_alias_2 }

declare const ProxyProvider: <V>({ proxy, children }: ProxyProviderProps<V>) => React_2.JSX.Element;
export { ProxyProvider }
export { ProxyProvider as ProxyProvider_alias_1 }
export { ProxyProvider as ProxyProvider_alias_2 }

declare type ProxyProviderProps<V> = {
    proxy: StockProxy<V>;
    children: React_2.ReactNode | ((path: Pxth<V>) => React_2.ReactNode);
};
export { ProxyProviderProps }
export { ProxyProviderProps as ProxyProviderProps_alias_1 }
export { ProxyProviderProps as ProxyProviderProps_alias_2 }

declare class PxthMap<Value> {
    private _values;
    private _keys;
    get: <V>(key: Pxth<V>) => Value | undefined;
    set: <V>(key: Pxth<V>, value: Value) => void;
    remove: <V>(key: Pxth<V>) => void;
    has: <V>(key: Pxth<V>) => boolean;
    keys: () => Pxth<unknown>[];
    entries: () => Array<[key: Pxth<unknown>, value: Value]>;
}
export { PxthMap }
export { PxthMap as PxthMap_alias_1 }
export { PxthMap as PxthMap_alias_2 }

declare type Stock<T extends object> = {
    /** Function for setting value. Deeply sets value, using path to variable. @see https://lodash.com/docs/4.17.15#set */
    setValue: <V>(path: Pxth<V>, value: SetStateAction<V>) => void;
    /** Function for setting all values. */
    setValues: (values: T) => void;
    /** Get actual value from stock. */
    getValue: <V>(path: Pxth<V>) => V;
    /** Get all values from stock */
    getValues: () => T;
    /** Function for resetting values to initial state */
    resetValues: () => void;
    /** Paths to all variables */
    paths: Pxth<T>;
    /** Name, which appears in stocked devtools */
    debugName?: string;
} & Omit<ObserversControl<T>, 'notifyAll' | 'notifySubTree'>;
export { Stock }
export { Stock as Stock_alias_1 }
export { Stock as Stock_alias_2 }

declare type StockConfig<T extends object> = {
    initialValues: T;
    debugName?: string;
};
export { StockConfig }
export { StockConfig as StockConfig_alias_1 }
export { StockConfig as StockConfig_alias_2 }

declare const StockContext: Context<Stock<object> | undefined>;
export { StockContext }
export { StockContext as StockContext_alias_1 }
export { StockContext as StockContext_alias_2 }

/**
 * Abstract class of "stocked" proxy
 * By inheriting this class, you can provide custom logic for proxing (casting) values.
 */
declare abstract class StockProxy<T> {
    /** Path to variable, where proxy is attached. */
    readonly path: Pxth<T>;
    constructor(path: Pxth<T>);
    /** Function, which sets proxied value. It will be callen only if proxied value is changing. */
    abstract setValue: <V>(path: Pxth<V>, value: SetStateAction<V>, defaultSetValue: <U>(path: Pxth<U>, value: SetStateAction<U>) => void, defaultGetValue: <U>(path: Pxth<U>) => U) => void;
    /**
     * Function for watching proxied value. Should return cleanup.
     * @deprecated
     */
    abstract watch: <V>(path: Pxth<V>, observer: Observer<V>, defaultWatch: <U>(path: Pxth<U>, observer: Observer<U>) => () => void) => () => void;
    /** Function for watching proxied value. Should return cleanup. Calls observer instantly. */
    abstract watchEffect: <V>(path: Pxth<V>, observer: Observer<V>, defaultWatchEffect: <U>(path: Pxth<U>, observer: Observer<U>) => () => void) => () => void;
    /** Function to access proxied value. */
    abstract getValue: <V>(path: Pxth<V>, defaultGetValue: <U>(path: Pxth<U>) => U) => V;
    /** Function for getting proxied path from normal path. */
    abstract getProxiedPath: <V>(path: Pxth<V>) => Pxth<V>;
    /** Function for getting normal path from proxied path */
    abstract getNormalPath: <V>(path: Pxth<V>) => Pxth<V>;
    /** Activate proxy. After activation, you cannot modify proxy. */
    activate: () => Readonly<this>;
    /** Returns boolean, is proxy active and ready for use or not. */
    isActive: () => boolean;
}
export { StockProxy }
export { StockProxy as StockProxy_alias_1 }
export { StockProxy as StockProxy_alias_2 }

/**
 * The main component, which should wrap all code, which uses stock values.
 * Creates stock and puts it in `StockContext`.
 */
declare const StockRoot: <Values extends object>({ children, ...stockConfig }: StockRootProps<Values>) => React_2.JSX.Element;
export { StockRoot }
export { StockRoot as StockRoot_alias_1 }
export { StockRoot as StockRoot_alias_2 }

declare type StockRootProps<Values extends object> = StockConfig<Values> & {
    children: React_2.ReactNode;
};
export { StockRootProps }
export { StockRootProps as StockRootProps_alias_1 }
export { StockRootProps as StockRootProps_alias_2 }

declare const useAllStockValues: <T extends object = object>(customStock?: Stock<T>, proxy?: StockProxy<unknown>) => T;
export { useAllStockValues }
export { useAllStockValues as useAllStockValues_alias_1 }
export { useAllStockValues as useAllStockValues_alias_2 }

export declare const useDebugStock: <T extends object>(stock: Stock<T>) => void;

/** Intercepts stock's `observe`, `stopObserving` and `setValue` functions, if proxy is provided. */
export declare const useInterceptors: <T extends object>(stock: Stock<T>, proxy?: StockProxy<unknown>) => Stock<T>;

/**
 * Same as `React.useRef` but with lazy initialization.
 * @param initializer - function, which initializes value. Called once.
 */
export declare const useLazyRef: <T>(initializer: () => T) => MutableRefObject<T>;

declare const useMappingProxy: <V>(mapSource: ProxyMapSource<V>, path: Pxth<V>) => MappingProxy<V>;
export { useMappingProxy }
export { useMappingProxy as useMappingProxy_alias_1 }
export { useMappingProxy as useMappingProxy_alias_2 }

/** Hook, wraps functionality of observers storage (add, remove, notify tree of observers, etc.) */
declare const useObservers: <T>(values: MutableRefObject<T>) => ObserversControl<T>;
export { useObservers }
export { useObservers as useObservers_alias_1 }
export { useObservers as useObservers_alias_2 }

/**
 * Creates stock.
 *
 * Use it only if you want to use several Stock's at the same time.
 *
 * Instead, use `<StockRoot>` component
 *
 * @param config - configuration of Stock.
 */
declare const useStock: <T extends object>({ initialValues, debugName }: StockConfig<T>) => Stock<T>;
export { useStock }
export { useStock as useStock_alias_1 }
export { useStock as useStock_alias_2 }

/**
 * Function to access stock, with automatically applying proxy. By default, will pick stock and proxy from context.
 * @param stock - optional argument. Pass it if you don't want to use stock from context.
 * @param proxy - optional argument. Pass it if you don't want to use proxy from context.
 */
declare const useStockContext: <T extends object>(stock?: Stock<T>, proxy?: StockProxy<unknown>) => Stock<T>;
export { useStockContext }
export { useStockContext as useStockContext_alias_1 }
export { useStockContext as useStockContext_alias_2 }

/**
 * Hook, returns tuple of value and value set action.
 * Returns *actual* value.
 * This means, this hook fires re-render each time value in stock was changed.
 * Similar to standard React's `useState` hook.
 * @param path  - path to variable in stock, deeply gets value. @see https://lodash.com/docs/4.17.15#get
 * @param customStock - optional parameter, if you want to work with custom stock, not received from context. @see useStockContext
 * @param proxy       - optional parameter, if you want to pass custom proxy, not receive it from context. @see useStockContext
 */
declare const useStockState: <V, T extends object = object>(path: Pxth<V>, customStock?: Stock<T>, proxy?: StockProxy<unknown>) => [V, Dispatch<SetStateAction<V>>];
export { useStockState }
export { useStockState as useStockState_alias_1 }
export { useStockState as useStockState_alias_2 }

/**
 * Hook, which returns *actual* stock value.
 * This means, it will update component each time when value in stock changes.
 * @param path        - path to variable in stock, deeply gets value. @see https://lodash.com/docs/4.17.15#get
 * @param customStock - optional parameter, if you want to work with custom stock, not received from context. @see useStockContext
 * @param proxy       - optional parameter, if you want to pass custom proxy, not receive it from context. @see useStockContext
 */
declare const useStockValue: <V, T extends object = object>(path: Pxth<V>, customStock?: Stock<T>, proxy?: StockProxy<unknown>) => V;
export { useStockValue }
export { useStockValue as useStockValue_alias_1 }
export { useStockValue as useStockValue_alias_2 }

export { }