import { Ref, WatchOptions, WritableComputedRef } from '@mpxjs/core';
import { Fn, MaybeComputedRef } from '@mpxjs/mpxuse-shared';
export * from '@mpxjs/mpxuse-shared';

declare function useCached<T>(refValue: Ref<T>, comparator?: (a: T, b: T) => boolean, watchOptions?: WatchOptions): Ref<T>;

declare type EventBusListener<T = unknown, P = any> = (event: T, payload?: P) => void;
declare type EventBusEvents<T, P = any> = EventBusListener<T, P>[];
declare type EventBusKey<T> = symbol;
declare type EventBusIdentifier<T = unknown> = EventBusKey<T> | string | number;
interface UseEventBusReturn<T, P> {
    /**
     * Subscribe to an event. When calling emit, the listeners will execute.
     * @param listener watch listener.
     * @returns a stop function to remove the current callback.
     */
    on: (listener: EventBusListener<T, P>) => Fn;
    /**
     * Similar to `on`, but only fires once
     * @param listener watch listener.
     * @returns a stop function to remove the current callback.
     */
    once: (listener: EventBusListener<T, P>) => Fn;
    /**
     * Emit an event, the corresponding event listeners will execute.
     * @param event data sent.
     */
    emit: (event?: T, payload?: P) => void;
    /**
     * Remove the corresponding listener.
     * @param listener watch listener.
     */
    off: (listener: EventBusListener<T>) => void;
    /**
     * Clear all events
     */
    reset: () => void;
}
declare function useEventBus<T = unknown, P = any>(key: EventBusIdentifier<T>): UseEventBusReturn<T, P>;

interface Serializer<T> {
    read(raw: string): T;
    write(value: T): string;
}
declare const StorageSerializers: Record<'boolean' | 'object' | 'number' | 'any' | 'string' | 'map' | 'set' | 'date', Serializer<any>>;
interface OptionsKeys<T> extends Object {
    sync?: boolean;
    encrypt?: boolean;
    serializer?: Serializer<T>;
    shallow?: boolean;
    onError?: (error: unknown) => void;
}
declare function useStorage<T extends (string | number | boolean | object | null)>(key: string, value?: MaybeComputedRef<T>, options?: OptionsKeys<T>): Ref<T>;

/**
 * Reactive document title.
 *
 * @see https://mpxuse.cn/useTitle
 * @param newTitle
 * @param options
 */
declare function useTitle(newTitle?: MaybeComputedRef<string | null | undefined>): WritableComputedRef<string | null | undefined>;
declare type UseTitleReturn = ReturnType<typeof useTitle>;

export { EventBusEvents, EventBusIdentifier, EventBusKey, EventBusListener, OptionsKeys, Serializer, StorageSerializers, UseEventBusReturn, UseTitleReturn, useCached, useEventBus, useStorage, useTitle };