import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React from 'react';
import React__default, { ElementType, ReactNode, SyntheticEvent, RefAttributes, ReactElement, PropsWithChildren, ChangeEvent } from 'react';
import { Theme, SxProps } from '@mui/material/styles';
import { ContainerProps } from '@mui/material/Container';
import { SxProps as SxProps$1, SnackbarProps, PaletteMode, ChipTypeMap, TextFieldProps, AutocompleteProps, AutocompleteValue, AutocompleteChangeReason, AutocompleteChangeDetails, TextField } from '@mui/material';
import { FieldValues, FieldPath, Control, UseControllerProps, FieldError, PathValue, UseControllerReturn, UseFormProps, DefaultValues, UseFormReturn } from 'react-hook-form';
import { DateValidationError, DatePickerProps, DatePickerSlotProps, PickerChangeHandlerContext } from '@mui/x-date-pickers';
import { PickerValidDate } from '@mui/x-date-pickers/models';
import dayjs from 'dayjs';
import { ZodType, z } from 'zod';
import { GridPaginationModel } from '@mui/x-data-grid';

/**
 * @ignore - internal component.
 */
interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
    history?: 'auto' | 'push' | 'replace';
    href: string;
}
declare const DefaultLink: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;

interface LocaleText {
    accountSignInLabel: string;
    accountSignOutLabel: string;
    accountPreviewIconButtonLabel: string;
    accountPreviewTitle: string;
    signInTitle: string | ((brandingTitle?: string) => string);
    signInSubtitle: string;
    providerSignInTitle: (provider: string) => string;
    signInRememberMe: string;
    email: string;
    passkey: string;
    username: string;
    password: string;
    or: string;
    to: string;
    with: string;
    save: string;
    cancel: string;
    ok: string;
    close: string;
    delete: string;
    alert: string;
    confirm: string;
    loading: string;
    createNewButtonLabel: string;
    reloadButtonLabel: string;
    createLabel: string;
    createSuccessMessage: string;
    createErrorMessage: string;
    editLabel: string;
    editSuccessMessage: string;
    editErrorMessage: string;
    deleteLabel: string;
    deleteConfirmTitle: string;
    deleteConfirmMessage: string;
    deleteConfirmLabel: string;
    deleteCancelLabel: string;
    deleteSuccessMessage: string;
    deleteErrorMessage: string;
    deletedItemMessage: string;
}
interface LocalizationProviderProps {
    children?: React.ReactNode;
    /**
     * Locale for components texts
     */
    localeText?: Partial<LocaleText>;
}
declare const LocalizationContext: React.Context<Partial<LocaleText>>;
declare const LocalizationProvider: {
    (props: LocalizationProviderProps): react_jsx_runtime.JSX.Element;
    propTypes: any;
};

/**
 *
 * Demos:
 *
 * - [Sign-in Page](https://mui.com/toolpad/core/react-sign-in-page/)
 *
 * API:
 *
 * - [LocalizationProvider API](https://mui.com/toolpad/core/api/localization-provider)
 */
declare function useLocaleText(): Partial<LocaleText>;

interface NavigateOptions {
    history?: 'auto' | 'push' | 'replace';
}
interface Navigate {
    (url: string | URL, options?: NavigateOptions): void;
}
/**
 * Abstract router used by Toolpad components.
 */
interface Router {
    pathname: string;
    searchParams: URLSearchParams;
    navigate: Navigate;
    Link?: React.ComponentType<LinkProps>;
}
interface Branding {
    title?: string;
    logo?: React.ReactNode;
    homeUrl?: string;
}
interface NavigationPageItem {
    kind?: 'page';
    segment?: string;
    title?: string;
    icon?: React.ReactNode;
    pattern?: string;
    action?: React.ReactNode;
    children?: Navigation;
}
interface NavigationSubheaderItem {
    kind: 'header';
    title: string;
}
interface NavigationDividerItem {
    kind: 'divider';
}
type NavigationItem = NavigationPageItem | NavigationSubheaderItem | NavigationDividerItem;
type Navigation = NavigationItem[];
interface Session {
    user?: {
        id?: string | null;
        name?: string | null;
        image?: string | null;
        email?: string | null;
    };
}
interface Authentication {
    signIn: () => void;
    signOut: () => void;
}
declare const AuthenticationContext: React.Context<Authentication | null>;
declare const SessionContext: React.Context<Session | null>;
type AppTheme = Theme | {
    light: Theme;
    dark: Theme;
};
interface AppProviderProps {
    /**
     * The content of the app provider.
     */
    children: React.ReactNode;
    /**
     * [Theme or themes](https://mui.com/toolpad/core/react-app-provider/#theming) to be used by the app in light/dark mode. A [CSS variables theme](https://mui.com/material-ui/customization/css-theme-variables/overview/) is recommended.
     * @default createDefaultTheme()
     */
    theme?: AppTheme;
    /**
     * Branding options for the app.
     * @default null
     */
    branding?: Branding | null;
    /**
     * Navigation definition for the app. [Find out more](https://mui.com/toolpad/core/react-app-provider/#navigation).
     * @default []
     */
    navigation?: Navigation;
    /**
     * Router implementation used inside Toolpad components.
     * @default null
     */
    router?: Router;
    /**
     * Locale text for components
     */
    localeText?: Partial<LocaleText>;
    /**
     * Session info about the current user.
     * @default null
     */
    session?: Session | null;
    /**
     * Authentication methods.
     * @default null
     */
    authentication?: Authentication | null;
    /**
     * The window where the application is rendered.
     * This is needed when rendering the app inside an iframe, for example.
     * @default window
     */
    window?: Window;
    /**
     * The nonce to be used for inline scripts.
     */
    nonce?: string;
}
/**
 *
 * Demos:
 *
 * - [App Provider](https://mui.com/toolpad/core/react-app-provider/)
 * - [Dashboard Layout](https://mui.com/toolpad/core/react-dashboard-layout/)
 *
 * API:
 *
 * - [AppProvider API](https://mui.com/toolpad/core/api/app-provider)
 */
declare function AppProvider(props: AppProviderProps): react_jsx_runtime.JSX.Element;
declare namespace AppProvider {
    var propTypes: any;
}

interface AppTitleProps {
    branding?: Branding;
}

interface DashboardHeaderSlotProps {
    appTitle?: AppTitleProps;
    toolbarActions?: {};
}
interface DashboardHeaderSlots {
    /**
     * The component used for the app title section.
     * @default Link
     * @see [DashboardLayout#slots](https://mui.com/toolpad/core/react-dashboard-layout/#slots)
     */
    appTitle?: React.ElementType;
    /**
     * The toolbar actions component to be used.
     * @default ToolbarActions
     * @see [DashboardLayout#slots](https://mui.com/toolpad/core/react-dashboard-layout/#slots)
     */
    toolbarActions?: React.JSXElementConstructor<{}>;
}
interface DashboardHeaderProps {
    /**
     * Branding options for the header.
     * @default null
     */
    branding?: Branding | null;
    /**
     * If `true`, show menu button as if menu is expanded, otherwise show it as if menu is collapsed.
     */
    menuOpen: boolean;
    /**
     * Callback fired when the menu button is clicked.
     */
    onToggleMenu: (open: boolean) => void;
    /**
     * Whether the menu icon should always be hidden.
     * @default false
     */
    hideMenuButton?: boolean;
    /**
     * The components used for each slot inside.
     * @default {}
     */
    slots?: DashboardHeaderSlots;
    /**
     * The props used for each slot inside.
     * @default {}
     */
    slotProps?: DashboardHeaderSlotProps;
}
/**
 *
 * Demos:
 *
 * - [Dashboard Layout](https://mui.com/toolpad/core/react-dashboard-layout/)
 *
 * API:
 *
 * - [DashboardHeader API](https://mui.com/toolpad/core/api/dashboard-header)
 */
declare function DashboardHeader(props: DashboardHeaderProps): react_jsx_runtime.JSX.Element;
declare namespace DashboardHeader {
    var propTypes: any;
}

interface SidebarFooterProps {
    mini: boolean;
}
interface DashboardLayoutSlotProps {
    appTitle?: DashboardHeaderSlotProps['appTitle'];
    toolbarActions?: DashboardHeaderSlotProps['toolbarActions'];
    sidebarFooter?: SidebarFooterProps;
    header?: DashboardHeaderProps;
}
interface DashboardLayoutSlots {
    /**
     * The component used for the app title section in the layout header.
     * @default Link
     * @see [DashboardLayout#slots](https://mui.com/toolpad/core/react-dashboard-layout/#slots)
     */
    appTitle?: React.ElementType;
    /**
     * The toolbar actions component used in the layout header.
     * @default ToolbarActions
     * @see [DashboardLayout#slots](https://mui.com/toolpad/core/react-dashboard-layout/#slots)
     */
    toolbarActions?: React.JSXElementConstructor<{}>;
    /**
     * The component used for the layout header.
     * @default DashboardHeader
     */
    header?: React.JSXElementConstructor<DashboardHeaderProps>;
    /**
     * Optional footer component used in the layout sidebar.
     * @default null
     */
    sidebarFooter?: React.JSXElementConstructor<SidebarFooterProps>;
}
interface DashboardLayoutProps {
    /**
     * The content of the dashboard.
     */
    children: React.ReactNode;
    /**
     * Branding options for the dashboard.
     * @default null
     */
    branding?: Branding | null;
    /**
     * Navigation definition for the dashboard. [Find out more](https://mui.com/toolpad/core/react-dashboard-layout/#navigation).
     * @default []
     * @deprecated Set the navigation in the [AppProvider](https://mui.com/toolpad/core/react-app-provider/#navigation) instead.
     */
    navigation?: Navigation;
    /**
     * Whether the sidebar should start collapsed in desktop size screens.
     * @default false
     */
    defaultSidebarCollapsed?: boolean;
    /**
     * Whether the sidebar should not be collapsible to a mini variant in desktop and tablet viewports.
     * @default false
     */
    disableCollapsibleSidebar?: boolean;
    /**
     * Whether the navigation bar and menu icon should be hidden.
     * @default false
     */
    hideNavigation?: boolean;
    /**
     * Width of the sidebar when expanded.
     * @default 320
     */
    sidebarExpandedWidth?: number | string;
    /**
     * Render each page item.
     *
     * @param {NavigationPageItem} item
     * @param {{ mini: boolean }} params
     * @returns {ReactNode}
     */
    renderPageItem?: (item: NavigationPageItem, params: {
        mini: boolean;
    }) => React.ReactNode;
    /**
     * The components used for each slot inside.
     * @default {}
     */
    slots?: DashboardLayoutSlots;
    /**
     * The props used for each slot inside.
     * @default {}
     */
    slotProps?: DashboardLayoutSlotProps;
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx?: SxProps;
}
/**
 *
 * Demos:
 *
 * - [Dashboard Layout](https://mui.com/toolpad/core/react-dashboard-layout/)
 *
 * API:
 *
 * - [DashboardLayout API](https://mui.com/toolpad/core/api/dashboard-layout)
 */
declare function DashboardLayout(props: DashboardLayoutProps): react_jsx_runtime.JSX.Element;
declare namespace DashboardLayout {
    var propTypes: any;
}

interface DashboardSidebarPageItemProps {
    /**
     * Navigation page item definition.
     */
    item: NavigationPageItem;
    /**
     * Link `href` for when the item is rendered as a link.
     * @default getItemPath(navigationContext, item)
     */
    href?: string;
    /**
     * The component used to render the item as a link.
     * @default Link
     */
    LinkComponent?: React.ElementType;
    /**
     * If `true`, expands any nested navigation in the item, otherwise collapse it.
     * @default false
     */
    expanded?: boolean;
    /**
     * Use to apply selected styling.
     * @default false
     */
    selected?: boolean;
    /**
     * If `true`, the item is disabled.
     * @default false
     */
    disabled?: boolean;
}
interface DashboardSidebarPageItemContextProps extends Partial<DashboardSidebarPageItemProps> {
    id: string;
    onClick: (itemId: string, item: NavigationPageItem) => void;
    isMini?: boolean;
    isSidebarFullyExpanded?: boolean;
    isSidebarFullyCollapsed?: boolean;
    renderNestedNavigation: (subNavigation: Navigation) => React.ReactNode;
}
/**
 *
 * Demos:
 *
 * - [Dashboard Layout](https://mui.com/toolpad/core/react-dashboard-layout/)
 *
 * API:
 *
 * - [DashboardSidebarPageItem API](https://mui.com/toolpad/core/api/dashboard-sidebar-page-item)
 */
declare function DashboardSidebarPageItem(props: DashboardSidebarPageItemProps): react_jsx_runtime.JSX.Element;
declare namespace DashboardSidebarPageItem {
    var propTypes: any;
}

/**
 *
 * Demos:
 *
 * - [Dashboard Layout](https://mui.com/toolpad/core/react-dashboard-layout/)
 *
 * API:
 *
 * - [ThemeSwitcher API](https://mui.com/toolpad/core/api/theme-switcher)
 */
declare function ThemeSwitcher(): react_jsx_runtime.JSX.Element | null;

/**
 *
 * Demos:
 *
 * - [Dashboard Layout](https://mui.com/toolpad/core/react-dashboard-layout/)
 *
 * API:
 *
 * - [ToolbarActions API](https://mui.com/toolpad/core/api/toolbar-actions)
 */
declare function ToolbarActions(): react_jsx_runtime.JSX.Element;

declare const _default$3: {
    components: {
        MuiLocalizationProvider: {
            defaultProps: {
                localeText: {
                    accountSignInLabel?: string | undefined;
                    accountSignOutLabel?: string | undefined;
                    accountPreviewIconButtonLabel?: string | undefined;
                    accountPreviewTitle?: string | undefined;
                    signInTitle?: string | ((brandingTitle?: string) => string) | undefined;
                    signInSubtitle?: string | undefined;
                    providerSignInTitle?: ((provider: string) => string) | undefined;
                    signInRememberMe?: string | undefined;
                    email?: string | undefined;
                    passkey?: string | undefined;
                    username?: string | undefined;
                    password?: string | undefined;
                    or?: string | undefined;
                    to?: string | undefined;
                    with?: string | undefined;
                    save?: string | undefined;
                    cancel?: string | undefined;
                    ok?: string | undefined;
                    close?: string | undefined;
                    delete?: string | undefined;
                    alert?: string | undefined;
                    confirm?: string | undefined;
                    loading?: string | undefined;
                    createNewButtonLabel?: string | undefined;
                    reloadButtonLabel?: string | undefined;
                    createLabel?: string | undefined;
                    createSuccessMessage?: string | undefined;
                    createErrorMessage?: string | undefined;
                    editLabel?: string | undefined;
                    editSuccessMessage?: string | undefined;
                    editErrorMessage?: string | undefined;
                    deleteLabel?: string | undefined;
                    deleteConfirmTitle?: string | undefined;
                    deleteConfirmMessage?: string | undefined;
                    deleteConfirmLabel?: string | undefined;
                    deleteCancelLabel?: string | undefined;
                    deleteSuccessMessage?: string | undefined;
                    deleteErrorMessage?: string | undefined;
                    deletedItemMessage?: string | undefined;
                };
            };
        };
    };
};

interface PageHeaderToolbarProps {
    children?: React.ReactNode;
}
/**
 *
 * Demos:
 *
 * - [Page Container](https://mui.com/toolpad/core/react-page-container/)
 *
 * API:
 *
 * - [PageHeaderToolbar API](https://mui.com/toolpad/core/api/page-header-toolbar)
 */
declare function PageHeaderToolbar(props: PageHeaderToolbarProps): react_jsx_runtime.JSX.Element;
declare namespace PageHeaderToolbar {
    var propTypes: any;
}

interface PageHeaderSlotProps {
    toolbar: PageHeaderToolbarProps;
}
interface PageHeaderSlots {
    /**
     * The component that renders the actions toolbar.
     * @default PageHeaderToolbar
     */
    toolbar: React.ElementType;
}
interface PageHeaderProps {
    /**
     * The title of the page. Leave blank to use the active page title.
     */
    title?: string;
    /**
     * The breadcrumbs of the page. Leave blank to use the active page breadcrumbs.
     */
    breadcrumbs?: Breadcrumb[];
    /**
     * The components used for each slot inside.
     */
    slots?: PageHeaderSlots;
    /**
     * The props used for each slot inside.
     */
    slotProps?: PageHeaderSlotProps;
}
/**
 * A header component to provide a title and breadcrumbs for your pages.
 *
 * Demos:
 *
 * - [Page Container](https://mui.com/toolpad/core/react-page-container/)
 *
 * API:
 *
 * - [PageHeader API](https://mui.com/toolpad/core/api/page-header)
 */
declare function PageHeader(props: PageHeaderProps): react_jsx_runtime.JSX.Element;
declare namespace PageHeader {
    var propTypes: any;
}

interface Breadcrumb {
    /**
     * The title of the breadcrumb segment.
     */
    title: string;
    /**
     * The path the breadcrumb links to.
     */
    path?: string;
}
interface PageContainerSlotProps {
    header: PageHeaderProps;
}
interface PageContainerSlots {
    /**
     * The component that renders the page header.
     * @default PageHeader
     */
    header: React.ElementType;
}
interface PageContainerProps extends ContainerProps {
    children?: React.ReactNode;
    /**
     * The title of the page. Leave blank to use the active page title.
     */
    title?: string;
    /**
     * The breadcrumbs of the page. Leave blank to use the active page breadcrumbs.
     */
    breadcrumbs?: Breadcrumb[];
    /**
     * The components used for each slot inside.
     */
    slots?: PageContainerSlots;
    /**
     * The props used for each slot inside.
     */
    slotProps?: PageContainerSlotProps;
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx?: SxProps$1;
}
/**
 * A container component to provide a title and breadcrumbs for your pages.
 *
 * Demos:
 *
 * - [Page Container](https://mui.com/toolpad/core/react-page-container/)
 *
 * API:
 *
 * - [PageContainer API](https://mui.com/toolpad/core/api/page-container)
 */
declare function PageContainer(props: PageContainerProps): react_jsx_runtime.JSX.Element;
declare namespace PageContainer {
    var propTypes: any;
}

/**
 * A codec that can encode and decode values of type V to and from strings.
 * @typeParam V The type of values that can be encoded and decoded.
 */
interface Codec<V> {
    /**
     * Decodes a string value into a value of type V.
     * @param value The value to decode.
     * @returns The decoded value.
     */
    parse: (value: string) => V;
    /**
     * Encodes a value of type V into a string.
     * @param value The value to encode.
     * @returns The encoded value.
     */
    stringify: (value: V) => string;
}

type StorageStateInitializer<T> = () => T | null;
type UseStorageStateHookResult<T> = [
    T | null,
    React.Dispatch<React.SetStateAction<T | null>>
];
declare function useStorageStateServer<T = string>(): UseStorageStateHookResult<T>;
interface DefaultStorageStateoptions<T = string> {
    codec?: Codec<T>;
}
interface StorageStateOptions<T> extends DefaultStorageStateoptions<T> {
    codec: Codec<T>;
}
/**
 * Sync state to local storage so that it persists through a page refresh. Usage is
 * similar to useState except we pass in a storage key so that we can default
 * to that value on page load instead of the specified initial value.
 *
 * Since the storage API isn't available in server-rendering environments, we
 * return null during SSR and hydration.
 */
declare function useStorageState(area: Storage, key: string | null, initializer?: string | null | StorageStateInitializer<string>, options?: DefaultStorageStateoptions): UseStorageStateHookResult<string>;
declare function useStorageState<T>(area: Storage, key: string | null, initializer: T | null | StorageStateInitializer<T>, options: StorageStateOptions<T>): UseStorageStateHookResult<T>;
interface UseStorageState {
    /**
     * Sync state to local or session storage so that it persists through a page refresh. Usage is
     * similar to useState except we pass in a storage key that uniquely identifies the value.
     * @param key The key to use for storing the value in local or session storage.
     * @param initializer The initial value to use if the key is not present in storage.
     * @param options Additional options for the storage state.
     */
    (key: string | null, initializer?: string | null | StorageStateInitializer<string>, options?: DefaultStorageStateoptions): UseStorageStateHookResult<string>;
    /**
     * Sync state to local or session storage so that it persists through a page refresh. Usage is
     * similar to useState except we pass in a storage key that uniquely identifies the value.
     * @param key The key to use for storing the value in local or session storage.
     * @param initializer The initial value to use if the key is not present in storage.
     * @param options Additional options for the storage state.
     */
    <T>(key: string | null, initializer: T | null | StorageStateInitializer<T>, options: StorageStateOptions<T>): UseStorageStateHookResult<T>;
    /**
     * Sync state to local or session storage so that it persists through a page refresh. Usage is
     * similar to useState except we pass in a storage key that uniquely identifies the value.
     * @param key The key to use for storing the value in local or session storage.
     * @param initializer The initial value to use if the key is not present in storage.
     * @param options Additional options for the storage state.
     */
    <T>(key: string | null, initializer?: T | null | StorageStateInitializer<T>, options?: StorageStateOptions<T>): UseStorageStateHookResult<T>;
}

interface ActivePage {
    title: string;
    path: string;
    breadcrumbs: Breadcrumb[];
}
declare function useActivePage(): ActivePage | null;

interface OpenDialogOptions<R> {
    /**
     * A function that is called before closing the dialog closes. The dialog
     * stays open as long as the returned promise is not resolved. Use this if
     * you want to perform an async action on close and show a loading state.
     *
     * @param result The result that the dialog will return after closing.
     * @returns A promise that resolves when the dialog can be closed.
     */
    onClose?: (result: R) => Promise<void>;
}
interface AlertOptions extends OpenDialogOptions<void> {
    /**
     * A title for the dialog. Defaults to `'Alert'`.
     */
    title?: React.ReactNode;
    /**
     * The text to show in the "Ok" button. Defaults to `'Ok'`.
     */
    okText?: React.ReactNode;
}
interface ConfirmOptions extends OpenDialogOptions<boolean> {
    /**
     * A title for the dialog. Defaults to `'Confirm'`.
     */
    title?: React.ReactNode;
    /**
     * The text to show in the "Ok" button. Defaults to `'Ok'`.
     */
    okText?: React.ReactNode;
    /**
     * Denotes the purpose of the dialog. This will affect the color of the
     * "Ok" button. Defaults to `undefined`.
     */
    severity?: 'error' | 'info' | 'success' | 'warning';
    /**
     * The text to show in the "Cancel" button. Defaults to `'Cancel'`.
     */
    cancelText?: React.ReactNode;
}
interface PromptOptions extends OpenDialogOptions<string | null> {
    /**
     * A title for the dialog. Defaults to `'Prompt'`.
     */
    title?: React.ReactNode;
    /**
     * The text to show in the "Ok" button. Defaults to `'Ok'`.
     */
    okText?: React.ReactNode;
    /**
     * The text to show in the "Cancel" button. Defaults to `'Cancel'`.
     */
    cancelText?: React.ReactNode;
}
/**
 * The props that are passed to a dialog component.
 */
interface DialogProps<P = undefined, R = void> {
    /**
     * The payload that was passed when the dialog was opened.
     */
    payload: P;
    /**
     * Whether the dialog is open.
     */
    open: boolean;
    /**
     * A function to call when the dialog should be closed. If the dialog has a return
     * value, it should be passed as an argument to this function. You should use the promise
     * that is returned to show a loading state while the dialog is performing async actions
     * on close.
     * @param result The result to return from the dialog.
     * @returns A promise that resolves when the dialog can be fully closed.
     */
    onClose: (result: R) => Promise<void>;
}
interface OpenAlertDialog {
    /**
     * Open an alert dialog. Returns a promise that resolves when the user
     * closes the dialog.
     *
     * @param msg The message to show in the dialog.
     * @param options Additional options for the dialog.
     * @returns A promise that resolves when the dialog is closed.
     */
    (msg: React.ReactNode, options?: AlertOptions): Promise<void>;
}
interface OpenConfirmDialog {
    /**
     * Open a confirmation dialog. Returns a promise that resolves to true if
     * the user confirms, false if the user cancels.
     *
     * @param msg The message to show in the dialog.
     * @param options Additional options for the dialog.
     * @returns A promise that resolves to true if the user confirms, false if the user cancels.
     */
    (msg: React.ReactNode, options?: ConfirmOptions): Promise<boolean>;
}
interface OpenPromptDialog {
    /**
     * Open a prompt dialog to request user input. Returns a promise that resolves to the input
     * if the user confirms, null if the user cancels.
     *
     * @param msg The message to show in the dialog.
     * @param options Additional options for the dialog.
     * @returns A promise that resolves to the user input if the user confirms, null if the user cancels.
     */
    (msg: React.ReactNode, options?: PromptOptions): Promise<string | null>;
}
type DialogComponent<P, R> = React.ComponentType<DialogProps<P, R>>;
interface OpenDialog {
    /**
     * Open a dialog without payload.
     * @param Component The dialog component to open.
     * @param options Additional options for the dialog.
     */
    <P extends undefined, R>(Component: DialogComponent<P, R>, payload?: P, options?: OpenDialogOptions<R>): Promise<R>;
    /**
     * Open a dialog and pass a payload.
     * @param Component The dialog component to open.
     * @param payload The payload to pass to the dialog.
     * @param options Additional options for the dialog.
     */
    <P, R>(Component: DialogComponent<P, R>, payload: P, options?: OpenDialogOptions<R>): Promise<R>;
}
interface CloseDialog {
    /**
     * Close a dialog and return a result.
     * @param dialog The dialog to close. The promise returned by `open`.
     * @param result The result to return from the dialog.
     * @returns A promise that resolves when the dialog is fully closed.
     */
    <R>(dialog: Promise<R>, result: R): Promise<R>;
}
interface DialogHook {
    alert: OpenAlertDialog;
    confirm: OpenConfirmDialog;
    prompt: OpenPromptDialog;
    open: OpenDialog;
    close: CloseDialog;
}
interface AlertDialogPayload extends AlertOptions {
    msg: React.ReactNode;
}
interface AlertDialogProps extends DialogProps<AlertDialogPayload, void> {
}
declare function AlertDialog({ open, payload, onClose }: AlertDialogProps): react_jsx_runtime.JSX.Element;
interface ConfirmDialogPayload extends ConfirmOptions {
    msg: React.ReactNode;
}
interface ConfirmDialogProps extends DialogProps<ConfirmDialogPayload, boolean> {
}
declare function ConfirmDialog({ open, payload, onClose }: ConfirmDialogProps): react_jsx_runtime.JSX.Element;
interface PromptDialogPayload extends PromptOptions {
    msg: React.ReactNode;
}
interface PromptDialogProps extends DialogProps<PromptDialogPayload, string | null> {
}
declare function PromptDialog({ open, payload, onClose }: PromptDialogProps): react_jsx_runtime.JSX.Element;
declare function useDialogs(): DialogHook;

interface DialogProviderProps {
    children?: React.ReactNode;
    unmountAfter?: number;
}
/**
 * Provider for Dialog stacks. The subtree of this component can use the `useDialogs` hook to
 * access the dialogs API. The dialogs are rendered in the order they are requested.
 *
 * Demos:
 *
 * - [useDialogs](https://mui.com/toolpad/core/react-use-dialogs/)
 *
 * API:
 *
 * - [DialogsProvider API](https://mui.com/toolpad/core/api/dialogs-provider)
 */
declare function DialogsProvider(props: DialogProviderProps): react_jsx_runtime.JSX.Element;

declare const useLocalStorageState: UseStorageState;

interface ShowNotificationOptions {
    /**
     * The key to use for deduping notifications. If not provided, a unique key will be generated.
     */
    key?: string;
    /**
     * The severity of the notification. When provided, the snackbar will show an alert with the
     * specified severity.
     */
    severity?: 'info' | 'warning' | 'error' | 'success';
    /**
     * The duration in milliseconds after which the notification will automatically close.
     */
    autoHideDuration?: number;
    /**
     * The text to display on the action button.
     */
    actionText?: React.ReactNode;
    /**
     * The callback to call when the action button is clicked.
     */
    onAction?: () => void;
}
interface ShowNotification {
    /**
     * Show a snackbar in the application.
     *
     * @param message The message to display in the snackbar.
     * @param options Options for the snackbar.
     * @returns The key that represents the notification. Useful for programmatically
     * closing it.
     */
    (message: React.ReactNode, options?: ShowNotificationOptions): string;
}
interface CloseNotification {
    /**
     * Close a snackbar in the application.
     *
     * @param key The key of the notification to close.
     */
    (key: string): void;
}
interface UseNotifications {
    show: ShowNotification;
    close: CloseNotification;
}
declare function useNotifications(): UseNotifications;

interface NotificationsProviderSlotProps {
    snackbar: SnackbarProps;
}
interface NotificationsProviderSlots {
    /**
     * The component that renders the snackbar.
     * @default Snackbar
     */
    snackbar: React.ElementType;
}
interface NotificationsProviderProps {
    children?: React.ReactNode;
    slots?: Partial<NotificationsProviderSlots>;
    slotProps?: Partial<NotificationsProviderSlotProps>;
}
/**
 * Provider for Notifications. The subtree of this component can use the `useNotifications` hook to
 * access the notifications API. The notifications are shown in the same order they are requested.
 *
 * Demos:
 *
 * - [Sign-in Page](https://mui.com/toolpad/core/react-sign-in-page/)
 * - [useNotifications](https://mui.com/toolpad/core/react-use-notifications/)
 *
 * API:
 *
 * - [NotificationsProvider API](https://mui.com/toolpad/core/api/notifications-provider)
 */
declare function NotificationsProvider(props: NotificationsProviderProps): react_jsx_runtime.JSX.Element;

declare function NextAppProvider(props: AppProviderProps): react_jsx_runtime.JSX.Element;

declare function useApplicationTitle(): string;

interface ErrorOverlayProps {
    error?: unknown;
}
declare function ErrorOverlay({ error }: ErrorOverlayProps): react_jsx_runtime.JSX.Element;
declare function LoadingOverlay(): react_jsx_runtime.JSX.Element;

declare const BrandingContext: React.Context<Branding | null>;
declare const NavigationContext: React.Context<Navigation>;
declare const PaletteModeContext: React.Context<{
    paletteMode: PaletteMode;
    setPaletteMode: (mode: PaletteMode) => void;
    isDualTheme: boolean;
}>;
declare const RouterContext: React.Context<Router | null>;
declare const DashboardSidebarPageItemContext: React.Context<DashboardSidebarPageItemContextProps | null>;
declare const WindowContext: React.Context<Window | undefined>;

declare const getItemKind: (item: NavigationItem) => "header" | "page" | "divider";
declare const isPageItem: (item: NavigationItem) => item is NavigationPageItem;
declare const getItemTitle: (item: NavigationPageItem | NavigationSubheaderItem) => string;
/**
 * Matches a path against the navigation to find the active page. i.e. the page that should be
 * marked as selected in the navigation.
 */
declare function matchPath(navigation: Navigation, path: string): NavigationPageItem | null;
/**
 * Gets the path for a specific navigation page item.
 */
declare function getItemPath(navigation: Navigation, item: NavigationPageItem): string;
/**
 * Checks if a specific navigation page item has the active page as a child item.
 */
declare function hasSelectedNavigationChildren(navigation: Navigation, item: NavigationPageItem, activePagePath: string): boolean;

type AutocompleteElementProps<TValue, Multiple extends boolean | undefined, DisableClearable extends boolean | undefined, FreeSolo extends boolean | undefined, ChipComponent extends ElementType = ChipTypeMap['defaultComponent'], TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = {
    name: TName;
    control?: Control<TFieldValues>;
    options: TValue[];
    loading?: boolean;
    multiple?: Multiple;
    loadingIndicator?: ReactNode;
    rules?: UseControllerProps<TFieldValues, TName>['rules'];
    parseError?: (error: FieldError) => ReactNode;
    required?: boolean;
    label?: TextFieldProps['label'];
    showCheckbox?: boolean;
    matchId?: boolean;
    autocompleteProps?: Omit<AutocompleteProps<TValue, Multiple, DisableClearable, FreeSolo, ChipComponent>, 'name' | 'options' | 'loading' | 'renderInput'>;
    textFieldProps?: Omit<TextFieldProps, 'name' | 'required' | 'label'>;
    transform?: {
        input?: (value: PathValue<TFieldValues, TName>) => AutocompleteValue<TValue, Multiple, DisableClearable, FreeSolo>;
        output?: (event: SyntheticEvent, value: AutocompleteValue<TValue, Multiple, DisableClearable, FreeSolo>, reason: AutocompleteChangeReason, details?: AutocompleteChangeDetails<TValue>) => PathValue<TFieldValues, TName>;
    };
};
type AutocompleteElementComponent = <TValue, Multiple extends boolean | undefined = false, DisableClearable extends boolean | undefined = false, FreeSolo extends boolean | undefined = false, ChipComponent extends ElementType = ChipTypeMap['defaultComponent'], TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: AutocompleteElementProps<TValue, Multiple, DisableClearable, FreeSolo, ChipComponent, TFieldValues, TName> & RefAttributes<HTMLDivElement>) => ReactElement;
declare const _default$2: AutocompleteElementComponent;

declare const defaultErrorMessages: {
    [v in NonNullable<DateValidationError>]: string;
};

type DatePickerElementProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TValue extends PickerValidDate = PickerValidDate> = Omit<DatePickerProps, 'value' | 'slotProps'> & {
    name: TName;
    required?: boolean;
    isDate?: boolean;
    parseError?: (error: FieldError | DateValidationError) => ReactNode;
    rules?: UseControllerProps<TFieldValues, TName>['rules'];
    control?: Control<TFieldValues>;
    inputProps?: TextFieldProps;
    helperText?: TextFieldProps['helperText'];
    textReadOnly?: boolean;
    slotProps?: Omit<DatePickerSlotProps, 'textField'>;
    overwriteErrorMessages?: typeof defaultErrorMessages;
    transform?: {
        input?: (value: PathValue<TFieldValues, TName>) => TValue | null;
        output?: (value: TValue | null, context: PickerChangeHandlerContext<DateValidationError>) => PathValue<TFieldValues, TName>;
    };
};
type DatePickerElementComponent = <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TValue extends PickerValidDate = PickerValidDate>(props: DatePickerElementProps<TFieldValues, TName, TValue> & RefAttributes<HTMLDivElement>) => ReactElement;
declare const _default$1: DatePickerElementComponent;

type FormErrorProviderProps = {
    onError: (error: FieldError) => ReactNode;
};
declare function FormErrorProvider({ onError, children, }: PropsWithChildren<FormErrorProviderProps>): react_jsx_runtime.JSX.Element;
declare const useFormError: () => (error: FieldError) => ReactNode;

type TextFieldElementProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TValue = unknown> = Omit<TextFieldProps, 'name'> & {
    rules?: UseControllerProps<TFieldValues, TName>['rules'];
    name: TName;
    parseError?: (error: FieldError) => ReactNode;
    control?: Control<TFieldValues>;
    /**
     * You override the MUI's TextField component by passing a reference of the component you want to use.
     *
     * This is especially useful when you want to use a customized version of TextField.
     */
    component?: typeof TextField;
    transform?: {
        input?: (value: PathValue<TFieldValues, TName>) => TValue;
        output?: (event: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => PathValue<TFieldValues, TName>;
    };
};
type TextFieldElementComponent = <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TValue = unknown>(props: TextFieldElementProps<TFieldValues, TName, TValue> & RefAttributes<HTMLDivElement>) => ReactElement;
declare const _default: TextFieldElementComponent;

type UseTransformOptions<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TValue = unknown> = {
    value: UseControllerReturn<TFieldValues, TName>['field']['value'];
    onChange: UseControllerReturn<TFieldValues, TName>['field']['onChange'];
    transform?: {
        input?: (value: PathValue<TFieldValues, TName>) => TValue;
        output?: (...event: any[]) => PathValue<TFieldValues, TName>;
    };
};
type UseTransformReturn<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TValue = unknown> = {
    value: TValue;
    onChange: UseControllerReturn<TFieldValues, TName>['field']['onChange'];
};
declare function useTransform<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TValue = unknown>(options: UseTransformOptions<TFieldValues, TName, TValue>): UseTransformReturn<TFieldValues, TName, TValue>;

interface UseFormSearchParamsOptions<TFieldValues extends FieldValues> extends UseFormProps<TFieldValues> {
    resetValues: DefaultValues<TFieldValues>;
    onPush: (values: TFieldValues) => Record<string, unknown>;
    isLoading: boolean;
}
interface UseFormSearchParamsReturn<TFieldValues extends FieldValues> {
    form: UseFormReturn<TFieldValues>;
    onSubmit: (e?: React__default.BaseSyntheticEvent) => Promise<void>;
    push: (values: TFieldValues) => void;
    reset: () => void;
    FormSearchActions: React__default.ReactNode;
}
declare function useFormQueryString<TFieldValues extends FieldValues>(options: UseFormSearchParamsOptions<TFieldValues>): UseFormSearchParamsReturn<TFieldValues>;

declare function useQueryString<T extends Record<string, any>>(): {
    getParam: <K extends keyof T>(name: K, defaultValue?: T[K] | string) => T[K] | string;
    getParams: <K extends keyof T>(name: K, defaultValue?: string[]) => string[];
    getParamsParsed: <K extends keyof T, S extends ZodType>(name: K, schema: S, defaultValue?: z.infer<S>[]) => z.infer<S>[];
    getDateDayjs: <K extends keyof T>(name: K) => dayjs.Dayjs | null;
};

declare function FormSearchActions({ reset, isLoading }: {
    reset: () => void;
    isLoading: boolean;
}): react_jsx_runtime.JSX.Element;

declare function useDataGrid(): {
    paginationModel: GridPaginationModel;
    onPaginationModelChange: (model: GridPaginationModel) => void;
};

/**
 * Hook that memoizes the given dependency array and checks the consecutive calls with deep equality and returns the same value as the first call if dependencies are not changed.
 * @internal
 */
declare const useDeepMemo: <T>(fn: () => T, dependencies: React__default.DependencyList) => T;

/**
 * Hook that memoizes the given value with deep equality.
 * @internal
 */
declare const useMemoized: <T = unknown>(value: T) => T;

declare function QueryClientProviderWrapper({ children }: {
    children: React__default.ReactNode;
}): react_jsx_runtime.JSX.Element;

declare class Notify {
    private readonly show;
    constructor(show: ShowNotification);
    static createSuccessMsg(resource: string, id?: string): string;
    static createErrorMsg(resource: string): string;
    static deleteSuccessMsg(resource: string, id?: string): string;
    static deleteErrorMsg(resource: string, id?: string): string;
    static editSuccessMsg(resource: string, id?: string): string;
    static editErrorMsg(resource: string, id?: string): string;
    success(msg: string, options?: ShowNotificationOptions): void;
    error(msg: string, options?: ShowNotificationOptions): void;
    createSuccess(msg: {
        resource: string;
        id?: string;
    }, options?: ShowNotificationOptions): void;
    createError(msg: {
        resource: string;
        id?: string;
    }, options?: ShowNotificationOptions): void;
    deleteSuccess(msg: {
        resource: string;
        id?: string;
    }, options?: ShowNotificationOptions): void;
    deleteError(msg: {
        resource: string;
        id?: string;
    }, options?: ShowNotificationOptions): void;
    editSuccess(msg: {
        resource: string;
        id?: string;
    }, options?: ShowNotificationOptions): void;
    editError(msg: {
        resource: string;
        id?: string;
    }, options?: ShowNotificationOptions): void;
}

declare class QueryStrings {
    static parse(values?: Record<string, unknown> | null): string;
    static appendSingle(params: URLSearchParams, key: string, value: unknown): void;
    private static isInvalidInput;
    private static isSkippableTopLevelValue;
    private static isSkippableSingleValue;
}

export { type ActivePage, AlertDialog, type AlertDialogPayload, type AlertDialogProps, type AlertOptions, AppProvider, type AppProviderProps, type AppTheme, type Authentication, AuthenticationContext, _default$2 as AutocompleteElement, type AutocompleteElementProps, type Branding, BrandingContext, type Breadcrumb, type CloseDialog, type CloseNotification, ConfirmDialog, type ConfirmDialogPayload, type ConfirmDialogProps, type ConfirmOptions, DashboardHeader, type DashboardHeaderProps, type DashboardHeaderSlotProps, type DashboardHeaderSlots, DashboardLayout, type DashboardLayoutProps, type DashboardLayoutSlotProps, type DashboardLayoutSlots, DashboardSidebarPageItem, DashboardSidebarPageItemContext, type DashboardSidebarPageItemContextProps, type DashboardSidebarPageItemProps, _default$1 as DatePickerElement, type DatePickerElementProps, DefaultLink, type DefaultStorageStateoptions, type DialogComponent, type DialogHook, type DialogProps, type DialogProviderProps, DialogsProvider, ErrorOverlay, type ErrorOverlayProps, FormErrorProvider, type FormErrorProviderProps, FormSearchActions, Link, type LinkProps, LoadingOverlay, type LocaleText, LocalizationContext, LocalizationProvider, type LocalizationProviderProps, type Navigate, type NavigateOptions, type Navigation, NavigationContext, type NavigationDividerItem, type NavigationItem, type NavigationPageItem, type NavigationSubheaderItem, NextAppProvider, NotificationsProvider, type NotificationsProviderProps, type NotificationsProviderSlotProps, type NotificationsProviderSlots, Notify, type OpenAlertDialog, type OpenConfirmDialog, type OpenDialog, type OpenDialogOptions, type OpenPromptDialog, PageContainer, type PageContainerProps, type PageContainerSlotProps, type PageContainerSlots, PageHeader, type PageHeaderProps, type PageHeaderSlotProps, type PageHeaderSlots, PageHeaderToolbar, type PageHeaderToolbarProps, PaletteModeContext, PromptDialog, type PromptDialogPayload, type PromptDialogProps, type PromptOptions, QueryClientProviderWrapper, QueryStrings, type Router, RouterContext, type Session, SessionContext, type ShowNotification, type ShowNotificationOptions, type SidebarFooterProps, type StorageStateInitializer, type StorageStateOptions, _default as TextFieldElement, ThemeSwitcher, ToolbarActions, type UseFormSearchParamsOptions, type UseFormSearchParamsReturn, type UseStorageState, type UseStorageStateHookResult, type UseTransformOptions, type UseTransformReturn, WindowContext, _default$3 as en, getItemKind, getItemPath, getItemTitle, hasSelectedNavigationChildren, isPageItem, matchPath, useActivePage, useApplicationTitle, useDataGrid, useDeepMemo, useDialogs, useFormError, useFormQueryString, useLocalStorageState, useLocaleText, useMemoized, useNotifications, useQueryString, useStorageState, useStorageStateServer, useTransform };