import React$1, { ComponentType } from 'react';
import { BProgressOptions, SpinnerPosition } from '@bprogress/core';
export { BProgressOptions, SpinnerPosition } from '@bprogress/core';

/**
 * @param start Start the progress bar
 * @param done Stop the progress bar
 * @param inc Increase the progress Bar
 * @param dec Decrease the progress bar
 * @param set Set the progress bar to a specific value
 * @param pause Pause the progress bar
 * @param resume Resume the progress bar
 * @param setOptions Set the BProgress options
 * @param getOptions Get the BProgress options
 */
interface ProgressContextValue {
    start: (startPosition?: number, delay?: number, autoStopDisabled?: boolean) => void;
    stop: (stopDelay?: number, forcedStopDelay?: number) => void;
    inc: (amount?: number) => void;
    dec: (amount?: number) => void;
    set: (n: number) => void;
    pause: () => void;
    resume: () => void;
    setOptions: (options: Partial<BProgressOptions> | ((prevOptions: BProgressOptions) => Partial<BProgressOptions>)) => void;
    getOptions: () => BProgressOptions;
    isAutoStopDisabled: React.RefObject<boolean>;
    disableAutoStop: () => void;
    enableAutoStop: () => void;
    shallowRouting: boolean;
    disableSameURL: boolean;
    startPosition: number;
    delay: number;
    stopDelay: number;
}
/**
 * @param as Custom component - @default div
 * @param children Children - @default undefined
 * @param className Custom class - @default undefined
 * @param classSelector Custom class selector - @default undefined
 */
type ProgressComponentProps<T extends React.ElementType = 'div'> = {
    as?: T;
    children?: React.ReactNode;
    classSelector?: string;
} & React.ComponentPropsWithoutRef<T>;
/**
 * @param children Children - @default undefined
 * @param color Color of the progress bar. @default #0A2FFF
 * @param height Height of the progress bar. @default 2px
 * @param options BProgress options. @default undefined
 * @param spinnerPosition Position of the spinner. @default top-right
 * @param style Custom css - @default undefined
 * @param disableStyle Disable default css - @default false
 * @param nonce Custom nonce for Content-Security-Policy directives - @default undefined
 * @param shallowRouting If the progress bar is not displayed when you use shallow routing - @default false
 * @param startPosition The position of the progress bar at the start of the page load - @default 0
 * @param delay When the page loads faster than the progress bar, it does not display - @default 0
 * @param stopDelay Delay to stop the progress bar - @default 0
 */
interface ProgressProviderProps {
    children?: React.ReactNode;
    color?: string;
    height?: string;
    options?: Partial<BProgressOptions>;
    spinnerPosition?: SpinnerPosition;
    style?: string;
    disableStyle?: boolean;
    nonce?: string;
    shallowRouting?: boolean;
    disableSameURL?: boolean;
    startPosition?: number;
    delay?: number;
    stopDelay?: number;
}
/**
 * @param shallowRouting If the progress bar is not displayed when you use shallow routing - @default false
 * @param startPosition The position of the progress bar at the start of the page load - @default 0
 * @param delay When the page loads faster than the progress bar, it does not display - @default 0
 * @param stopDelay Delay to stop the progress bar - @default 0
 * @param shouldCompareComplexProps If you want to compare props in the React.memo return - @default false
 * @param disableSameURL Disable triggering progress bar on the same URL - @default true
 */
interface RouterProgressProps {
    shallowRouting?: boolean;
    disableSameURL?: boolean;
    startPosition?: number;
    delay?: number;
    stopDelay?: number;
    memo?: boolean;
    shouldCompareComplexProps?: boolean;
}
/**
 * @param targetPreprocessor If you want to process the target URL - @default undefined
 * @param disableAnchorClick Disable triggering progress bar on anchor clicks - @default false
 * @param startOnLoad Start the progress bar on page load - @default false
 */
interface AnchorProgressProps extends RouterProgressProps {
    targetPreprocessor?: (url: URL) => URL;
    disableAnchorClick?: boolean;
    startOnLoad?: boolean;
}
interface RouterProgressProviderProps extends RouterProgressProps, ProgressProviderProps {
}
interface AnchorProgressProviderProps extends AnchorProgressProps, ProgressProviderProps {
}
/**
 * @params forcedStopDelay - Delay to stop the progress bar that does not take the timer into account
 */
type UseAnchorProgressOptions = Omit<AnchorProgressProps, 'memo' | 'shouldCompareComplexProps'> & {
    forcedStopDelay?: number;
};

declare const useProgress: () => ProgressContextValue;
declare const ProgressProvider: ({ children, color, height, options, spinnerPosition, style, disableStyle, nonce, shallowRouting, disableSameURL, startPosition, delay, stopDelay, }: ProgressProviderProps) => React$1.JSX.Element;

declare function useAnchorProgress({ shallowRouting, disableSameURL, startPosition, delay, stopDelay, targetPreprocessor, disableAnchorClick, startOnLoad, forcedStopDelay, }: UseAnchorProgressOptions, deps?: unknown[]): void;

type ProgressProps<T extends React$1.ElementType = 'div'> = Omit<ProgressComponentProps<T>, 'classSelector'>;
declare function ProgressInner<T extends React$1.ElementType = 'div'>({ as, children, className, style, ...rest }: ProgressProps<T>, ref: React$1.ForwardedRef<React$1.ComponentRef<T>>): React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
declare const Progress: <T extends React$1.ElementType = "div">(props: ProgressProps<T> & {
    ref?: React$1.ForwardedRef<React$1.ComponentRef<T>>;
}) => ReturnType<typeof ProgressInner>;

type BarProps<T extends React$1.ElementType = 'div'> = ProgressComponentProps<T>;
declare function BarInner<T extends React$1.ElementType = 'div'>({ as, children, className, classSelector, ...rest }: BarProps<T>, ref: React$1.ForwardedRef<React$1.ComponentRef<T>>): React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
declare const Bar: <T extends React$1.ElementType = "div">(props: BarProps<T> & {
    ref?: React$1.ForwardedRef<React$1.ComponentRef<T>>;
}) => ReturnType<typeof BarInner>;

type PegProps<T extends React$1.ElementType = 'div'> = Omit<ProgressComponentProps<T>, 'classSelector'> & {
    classSelector?: string;
};
declare function PegInner<T extends React$1.ElementType = 'div'>({ as, children, className, classSelector, ...rest }: PegProps<T>, ref: React$1.ForwardedRef<React$1.ComponentRef<T>>): React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
declare const Peg: <T extends React$1.ElementType = "div">(props: PegProps<T> & {
    ref?: React$1.ForwardedRef<React$1.ComponentRef<T>>;
}) => ReturnType<typeof PegInner>;

type SpinnerProps<T extends React$1.ElementType = 'div'> = ProgressComponentProps<T>;
declare function SpinnerInner<T extends React$1.ElementType = 'div'>({ as, children, className, classSelector, ...rest }: SpinnerProps<T>, ref: React$1.ForwardedRef<React$1.ComponentRef<T>>): React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
declare const Spinner: <T extends React$1.ElementType = "div">(props: SpinnerProps<T> & {
    ref?: React$1.ForwardedRef<React$1.ComponentRef<T>>;
}) => ReturnType<typeof SpinnerInner>;

type SpinnerIconProps<T extends React$1.ElementType = 'div'> = Omit<ProgressComponentProps<T>, 'classSelector'> & {
    classSelector?: string;
};
declare function SpinnerIconInner<T extends React$1.ElementType = 'div'>({ as, children, className, classSelector, ...rest }: SpinnerIconProps<T>, ref: React$1.ForwardedRef<React$1.ComponentRef<T>>): React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
declare const SpinnerIcon: <T extends React$1.ElementType = "div">(props: SpinnerIconProps<T> & {
    ref?: React$1.ForwardedRef<React$1.ComponentRef<T>>;
}) => ReturnType<typeof SpinnerIconInner>;

type IndeterminateProps<T extends React$1.ElementType = 'div'> = ProgressComponentProps<T> & {
    children?: never;
};
declare function IndeterminateInner<T extends React$1.ElementType = 'div'>({ as, className, classSelector, ...rest }: IndeterminateProps<T>, ref: React$1.ForwardedRef<React$1.ComponentRef<T>>): React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
declare const Indeterminate: <T extends React$1.ElementType = "div">(props: IndeterminateProps<T> & {
    ref?: React$1.ForwardedRef<React$1.ComponentRef<T>>;
}) => ReturnType<typeof IndeterminateInner>;

declare function withSuspense<P extends object>(Component: ComponentType<P>): (props: P) => React$1.JSX.Element;

declare function withMemo<P extends {
    memo?: boolean;
    shouldCompareComplexProps?: boolean;
}>(Component: React$1.ComponentType<P>, ignoreKeys?: string[]): React$1.MemoExoticComponent<React$1.ComponentType<P>>;

export { type AnchorProgressProps, type AnchorProgressProviderProps, Bar, type BarProps, Indeterminate, type IndeterminateProps, Peg, type PegProps, Progress, type ProgressComponentProps, type ProgressContextValue, type ProgressProps, ProgressProvider, type ProgressProviderProps, type RouterProgressProps, type RouterProgressProviderProps, Spinner, SpinnerIcon, type SpinnerIconProps, type SpinnerProps, type UseAnchorProgressOptions, useAnchorProgress, useProgress, withMemo, withSuspense };