import type { ComponentType } from 'react';
import type { Animated, StyleProp, ViewStyle } from 'react-native';
export declare type ModalfyParams = {
    [key: string]: any;
};
export declare type ModalTransitionValue = Animated.AnimatedInterpolation | string | number | undefined | null;
export declare type ModalTransitionOptions = (animatedValue: Animated.Value) => {
    [key: string]: {
        [key: string]: ModalTransitionValue;
    }[] | ModalTransitionValue;
};
export declare type ModalListener = (eventName: ModalEventName, callback: ModalEventCallback) => ModalEventListener;
export declare type ModalEventListeners = Set<{
    event: string;
    handler: ModalEventCallback;
}>;
export declare type ModalEventName = 'onAnimate' | 'onClose';
export declare type ModalOnAnimateEventCallback = (value?: number) => void;
export declare type ModalOnCloseEventCallback = (closingAction: {
    type: ModalClosingActionName;
    origin: ModalClosingActionOrigin;
}) => void;
export declare type ModalClosingActionName = 'closeModal' | 'closeModals' | 'closeAllModals';
export declare type ModalClosingActionOrigin = 'default' | 'fling' | 'backdrop';
export declare type ModalEventCallback = ModalOnAnimateEventCallback | ModalOnCloseEventCallback;
export declare type ModalEventListener = {
    remove: () => boolean;
};
export declare type ModalEventAction = 'add';
export declare type ModalEventPayload = {
    eventName: ModalEventName;
    handler: ModalEventCallback;
};
export declare type ModalStatePendingClosingAction = {
    modalName?: string;
    action: 'closeModal';
    callback?: () => void;
} | {
    modalName: string;
    action: 'closeModals';
    callback?: () => void;
} | {
    modalName?: never;
    action: 'closeAllModals';
    callback?: () => void;
};
export declare type ModalPendingClosingAction = {
    hash: string;
    currentModalHash?: string;
    modalName?: string;
    action: 'closeModal';
    callback?: () => void;
} | {
    hash: string;
    currentModalHash?: string;
    modalName: string;
    action: 'closeModals';
    callback?: () => void;
} | {
    hash: string;
    modalName?: never;
    currentModalHash?: string;
    action: 'closeAllModals';
    callback?: () => void;
};
export interface ModalStackItem<P extends ModalfyParams> {
    name: Exclude<keyof P, symbol | number>;
    component: ComponentType<any> & {
        modalOptions?: ModalOptions;
    };
    hash: string;
    index: number;
    options?: ModalOptions;
    params?: any;
    callback?: () => void;
}
export interface ModalStack<P extends ModalfyParams> {
    names: Array<Exclude<keyof P, symbol | number>>;
    content: ModalStackItem<P>[];
    defaultOptions: ModalOptions;
    openedItems: Set<ModalStackItem<P>>;
    openedItemsSize: number;
    pendingClosingActions: Set<ModalPendingClosingAction>;
    pendingClosingActionsSize: number;
}
export interface ModalContextProvider<P extends ModalfyParams, M extends Exclude<keyof P, symbol | number> = Exclude<keyof P, symbol | number>> {
    currentModal: M | null;
    closeAllModals: (callback?: () => void) => void;
    closeModal: (stackItem?: M | ModalStackItem<P>, callback?: () => void) => void;
    closeModals: (modalName: M, callback?: () => void) => boolean;
    getParam: <N extends keyof P[M], D extends P[M][N]>(hash: ModalStackItem<P>['hash'], paramName: N, defaultValue?: D) => D extends P[M][N] ? P[M][N] : undefined;
    openModal: <N extends M>(modalName: N, params?: P[N], callback?: () => void) => void;
    stack: ModalStack<P>;
}
export declare type ModalInternalState<P> = {
    currentModal: ModalContextProvider<P>['currentModal'] | string | null;
    stack: ModalContextProvider<P>['stack'];
};
export interface ModalStateSubscriber<P> {
    state: ModalInternalState<P>;
    equalityFn: ModalStateEqualityChecker<P>;
    error: boolean;
    stateListener: ModalStateListener<P>;
    unsubscribe: () => boolean;
}
export interface ModalStateSubscription<P> {
    unsubscribe: ModalStateSubscriber<P>['unsubscribe'];
}
export declare type ModalStateListener<P> = (state: ModalInternalState<P> | null, error?: Error) => void;
export declare type ModalStateEqualityChecker<P> = (currentState: ModalInternalState<P>, newState: ModalInternalState<P>) => boolean;
export declare type ModalState<P> = Omit<ModalContextProvider<P>, 'currentModal' | 'stack' | 'openModal'> & {
    openModal: <M extends Exclude<keyof P, symbol | number>, N extends M>(args: {
        modalName: N;
        params?: P[N];
        isCalledOutsideOfContext?: boolean;
        callback?: () => void;
    }) => void;
    handleBackPress: () => boolean;
    init: <T>(updater: (currentState: ModalInternalState<T>) => ModalInternalState<T>) => ModalInternalState<T>;
    getState: <T>() => ModalInternalState<T>;
    setState: <T>(updater: (currentState: ModalInternalState<T>) => ModalInternalState<T>) => ModalInternalState<T>;
    subscribe: <T>(listener: ModalStateListener<T>, equalityFn?: ModalStateEqualityChecker<T>) => ModalStateSubscription<T>;
    queueClosingAction: (action: ModalStatePendingClosingAction) => ModalPendingClosingAction | null;
    removeClosingAction: (action: ModalPendingClosingAction) => boolean;
};
export interface SharedProps<P extends ModalfyParams> extends ModalContextProvider<P> {
    clearListeners: (hash: string) => void;
    eventListeners: ModalEventListeners;
    registerListener: (hash: ModalStackItem<P>['hash'], eventName: ModalEventName, handler: ModalEventCallback) => ModalEventListener;
    removeClosingAction: ModalState<P>['removeClosingAction'];
    rootStyle?: StyleProp<ViewStyle>;
}
export declare type UsableModalProp<P extends ModalfyParams> = Pick<ModalContextProvider<P>, 'closeAllModals' | 'closeModals' | 'currentModal' | 'openModal'> & {
    closeModal: (modalName?: Exclude<keyof P, symbol | number>, callback?: () => void) => void;
};
export interface UsableModalComponentProp<P extends ModalfyParams, M extends keyof P> extends Omit<ModalContextProvider<P>, 'closeModal' | 'stack' | 'getParam'> {
    addListener: ModalListener;
    closeModal: (modalName?: M, callback?: () => void) => void;
    getParam: <N extends keyof P[M], D extends P[M][N]>(paramName: N, defaultValue?: D) => D extends P[M][N] ? P[M][N] : undefined;
    removeAllListeners: () => void;
    params?: P[M];
}
/**
 * Interface of the modal stack configuration.
 * These settings will let Modalfy know what modals you will be rendering and how.
 *
 * @see https://colorfy-software.gitbook.io/react-native-modalfy/guides/typing#config-and-options
 */
export interface ModalStackConfig {
    [key: string]: ComponentType<any> | ModalOptions;
}
/**
 * Interface of the modal configuration options.
 * These settings will let Modalfy how to render and animate a modal.
 *
 * @see https://colorfy-software.gitbook.io/react-native-modalfy/guides/typing#config-and-options
 */
export interface ModalOptions {
    /**
     * Animation configuration used to animate a modal in, at the top of the stack.
     * It uses Animated.timing() by default, if you want to use another animation type, see `animationIn`.
     *
     * Note: only `easing` and `duration` are needed.
     *
     * @default { easing: Easing.inOut(Easing.exp), duration: 450 }
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#animateinconfig
     */
    animateInConfig?: Pick<Animated.TimingAnimationConfig, 'duration' | 'easing'>;
    /**
     * Animation function that receives the `animatedValue` used by the library to animate the modal opening,
     * and a `toValue` argument representing the modal position in the stack.
     *
     * Since Modalfy v3, the function receives a `callback` argument, which _can_ be called when the animation is finished,
     * depending on whether or not you'll have a callback in a `openModal()`.
     *
     * Note: If you just want to use Animated.timing(), check `animateInConfig`.
     *
     * @default -
     * @example
     * animationIn: (modalAnimatedValue, modalToValue, callback) => {
     *   Animated.parallel([
     *     Animated.timing(modalAnimatedValue, {
     *       toValue: modalToValue,
     *       duration: 300,
     *       easing: Easing.inOut(Easing.exp),
     *       useNativeDriver: true,
     *     }),
     *     Animated.timing(myOtherAnimatedValue, {
     *       toValue: 1,
     *       duration: 300,
     *       easing: Easing.inOut(Easing.exp),
     *       useNativeDriver: true,
     *     }),
     *   ]).start(({ finished }) => {
     *     if (finished) callback?.()
     *   })
     * }
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#animationin
     */
    animationIn?: (animatedValue: Animated.Value, toValue: number, callback?: () => void) => Animated.CompositeAnimation | void;
    /**
     * Animation configuration used to animate a modal out (underneath other modals or when closing the last one).
     * Uses Animated.timing(), if you want to use another animation type, use `animationOut`.
     *
     * Note: only `easing` and `duration` are needed.
     *
     * @default { easing: Easing.inOut(Easing.exp), duration: 450 }
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#animationout
     */
    animateOutConfig?: Pick<Animated.TimingAnimationConfig, 'duration' | 'easing'>;
    /**
     * Animation function that receives the `animatedValue` used by the library to animate the modal closing,
     * and a `toValue` argument representing the modal position in the stack.
     *
     * Since Modalfy v3, the function receives a `callback` argument, which **_must_** be called when the animation is finished.
     *
     * Note: If you just want to use Animated.timing(), check `animateOutConfig`.
     *
     * @default -
     * @example
     * animationOut: (modalAnimatedValue, modalToValue, callback) => {
     *   Animated.parallel([
     *     Animated.timing(modalAnimatedValue, {
     *       toValue: modalToValue,
     *       duration: 300,
     *       easing: Easing.inOut(Easing.exp),
     *       useNativeDriver: true,
     *     }),
     *     Animated.timing(myOtherAnimatedValue, {
     *       toValue: 1,
     *       duration: 300,
     *       easing: Easing.inOut(Easing.exp),
     *       useNativeDriver: true,
     *     }),
     *   ]).start(({ finished }) => {
     *     if (finished) callback()
     *   })
     * }
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#animationout
     */
    animationOut?: (animatedValue: Animated.Value, toValue: number, callback?: () => void) => Animated.CompositeAnimation | void;
    /**
     * How you want the modal stack to behave when users press the backdrop, but also when the physical back button is pressed on Android.
     *
     * @default 'pop'
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#backbehavior
     */
    backBehavior?: 'clear' | 'pop' | 'none';
    /**
     * Color of the modal stack backdrop.
     *
     * @default 'black'
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#backdropcolor
     */
    backdropColor?: ViewStyle['backgroundColor'];
    /**
     * Number between `0` and `1` that defines the backdrop opacity.
     *
     * @default 0.6
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#backdropopacity
     */
    backdropOpacity?: number;
    /**
     * Number that defines how long the backdrop should take to animate in and out.
     *
     * @default 300
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#backdropanimationduration
     */
    backdropAnimationDuration?: number;
    /**
     * Styles applied to the `<View>` directly wrapping your modal component.
     *
     * @default '{}'
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#containerstyle
     */
    containerStyle?: ViewStyle;
    /**
     * Disable fling gesture detection to close the modal.
     *
     * Note: the fling gesture handler is not enabled when `position` is `center`.
     *
     * @default false
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#disableflinggesture
     */
    disableFlingGesture?: boolean;
    /**
     * React component that will be rendered when you'll open the modal.
     *
     * Note: only needed when you're using this inside createModalStack() 1st argument.
     *
     * @default -
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#modal
     */
    modal?: ComponentType<any>;
    /**
     * Vertical positioning of the modal.
     *
     * @default 'center'
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#position
     */
    position?: 'center' | 'top' | 'bottom';
    /**
     * `transitionOptions(animatedValue)` returns a React Native style object containing values that can use the provided `animatedValue` to run animation interpolations on a modal.
     *
     * Note: the object returned by `transitionOptions()` must contain keys that work with `useNativeDriver: true`.
     *
     * @default -
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/api/types/modaloptions#transitionoptions
     */
    transitionOptions?: ModalTransitionOptions;
}
/**
 * Interface of the `modal` prop exposed by the library to regular components.
 *
 * @argument { unknown } ModalStackParamsList? - Interface of the whole modal stack params.
 * @argument { unknown } Props? - Component's props interface.
 *
 * Note: Modal components used in `createModalStack()`'s config should employ `ModalComponentProp` instead.
 *
 * @see https://colorfy-software.gitbook.io/react-native-modalfy/guides/typing#modalprop
 */
export declare type ModalProp<P extends ModalfyParams, Props = unknown> = Props & {
    /**
     * Interface of the `modal` prop exposed by the library to regular components.
     *
     * Note: Modal components used in `createModalStack()`'s config should employ `ModalComponentProp` instead.
     *
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/guides/typing#modalprop
     */
    modal: UsableModalProp<P>;
};
/**
 * Interface of the `modal` prop exposed by the library specifically to modal components.
 *
 * @argument { unknown } ModalStackParamsList? - Interface of the whole modal stack params.
 * @argument { unknown } Props? - Component's props interface.
 * @argument { string } ModalName? - Name of the current modal
 *
 * Note: Components that are not used from `createModalStack()`'s config should employ `ModalProp` instead.
 *
 * @see https://colorfy-software.gitbook.io/react-native-modalfy/guides/typing#modalcomponentprop
 */
export declare type ModalComponentProp<P extends ModalfyParams, Props = unknown, M extends keyof P = keyof P> = Props & {
    /**
     * Interface of the `modal` prop exposed by the library specifically to modal components.
     *
     * Note: Components that are not used from `createModalStack()`'s config should employ `ModalProp` instead.
     *
     * @see https://colorfy-software.gitbook.io/react-native-modalfy/guides/typing#modalcomponentprop
     */
    modal: UsableModalComponentProp<P, M>;
};
/**
 * Interface for a React component containing its props and the `modalOptions` static property.
 *
 * Note: Only use with Hooks modal components (those present in your `createModalStack()`'s config).
 * If you're working with a Class modal component, you can directly use `static modalOptions: ModalOptions`.
 *
 * @argument { unknown } Props? - Component's props interface.
 *
 * @see https://colorfy-software.gitbook.io/react-native-modalfy/guides/typing#modalcomponentwithoptions
 */
export declare type ModalComponentWithOptions<P = unknown> = ComponentType<P> & {
    modalOptions?: ModalOptions;
};