import { SelectProps, AvatarProps, ThemeConfig, ConfigProviderProps, TabsProps, TableColumnProps, UploadFile, UploadProps, ModalProps, FormProps, FormItemProps, Typography } from 'antd';
import * as React$1 from 'react';
import React__default, { ReactNode, CSSProperties, PropsWithChildren, SVGProps, ComponentProps } from 'react';
import { BootstrapProps as BootstrapProps$1, GetFormPropsType, Owner, Account, User } from '@ucheeddev/refine-core';
import { Dayjs } from 'dayjs';
import { AntdIconProps } from '@ant-design/icons/lib/components/AntdIcon';
import * as antd_style from 'antd-style';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as _refinedev_core from '@refinedev/core';
import { ITreeMenu, BaseRecord, UseFormProps, BaseKey, CrudFilters } from '@refinedev/core';
import * as _refinedev_antd from '@refinedev/antd';
import { RefineLayoutThemedTitleProps, ShowButtonProps } from '@refinedev/antd';
import { SizeType } from 'antd/es/config-provider/SizeContext';
import { CustomIconComponentProps } from '@ant-design/icons/lib/components/Icon';
import { UploadProps as UploadProps$1 } from 'antd/es/upload';
import { PhoneNumber } from 'antd-phone-input';

type AccountDropdownProps = {
    width?: number;
};
declare const AccountDropdown: React.FC<SelectProps & AccountDropdownProps>;

type AvatarGroupProps = {
    avatars: {
        name?: string;
        src?: string;
    }[];
    size?: AvatarProps["size"];
    maxCount?: number;
    containerStyle?: React.CSSProperties;
    avatarStyle?: AvatarProps["style"];
    gap?: string;
    overlap?: boolean;
};

declare const AvatarGroup: React.FC<AvatarGroupProps>;

type BackButtonProps = {
    onClick: () => void;
    label?: string;
};

declare const BackButton: React.FC<BackButtonProps>;

type BootstrapProps = Omit<BootstrapProps$1, 'Loading' | 'Error'> & {
    theme?: ThemeConfig;
    forceLightTheme?: boolean;
    configProviderProps?: ConfigProviderProps;
};

declare const Bootstrap: React__default.FC<BootstrapProps>;

type CircleIconButtonActionProps = {
    icon: React.ReactNode;
    label: string;
    onClick?: () => void;
};

declare const CircleIconButtonAction: React.FC<CircleIconButtonActionProps>;

declare const CurrentUser: React.FC<{
    beforeLogout?: ReactNode;
}>;

type CurrentUserProps = {};

interface CustomAvatarProps extends AvatarProps {
    name?: string;
    style?: CSSProperties;
}

declare const CustomAvatar: React__default.NamedExoticComponent<CustomAvatarProps>;

type CustomDatePickerProps = {
    value: string | undefined | Dayjs;
    showTime?: boolean;
    showNow?: boolean;
    needConfirm?: boolean;
    allowClear?: boolean;
    format?: string;
    style?: React.CSSProperties;
    onOk?: ((date: Dayjs) => void) | undefined;
    onChange?: ((date: Dayjs, dateString?: string | string[]) => void) | undefined;
};

declare const CustomDatePicker: React.FC<CustomDatePickerProps>;

type CustomTabsProps = {
    items: TabsProps['items'];
    defaultActiveKey?: string;
    onChange?: (key: string) => void;
    style?: React.CSSProperties;
};

declare const CustomTabs: React.FC<CustomTabsProps>;

type CustomTimePickerProps = {
    value: string | undefined;
    needConfirm?: boolean;
    allowClear?: boolean;
    format?: string;
    style?: React.CSSProperties;
    onOk?: ((date: Dayjs) => void) | undefined;
    onChange?: ((date: Dayjs, dateString: string | string[]) => void) | undefined;
};

declare const CustomTimePicker: React.FC<CustomTimePickerProps>;

interface EmailLinkProps {
    email: string;
    style?: React__default.CSSProperties;
}

declare const EmailLink: React__default.FC<EmailLinkProps>;

type FieldFormTitleProps = {
    title: string;
    Icon?: React__default.FC<AntdIconProps>;
    iconProps?: AntdIconProps;
    titleStyle?: CSSProperties;
} & React__default.HTMLAttributes<HTMLDivElement>;

declare const FieldFormTitle: React__default.FC<FieldFormTitleProps>;

type AntdFilterDropdownProps = React.ComponentProps<Exclude<TableColumnProps<any>['filterDropdown'], ReactNode>>;
type MapValueEvent = 'onChange' | 'value';
type FilterDropdownProps = AntdFilterDropdownProps & {
    mapValue?: (selectedKeys: React.Key[], event: MapValueEvent) => any;
    children: JSX.Element;
};

declare const FilterDropdown: React__default.FC<FilterDropdownProps>;

declare const FormLoadingSkeleton: React__default.FC;

type FormattedNumberFieldProps = {
    value: number;
    currency?: string;
};

declare const FormattedNumberField: React.FC<FormattedNumberFieldProps>;

declare const FullScreenLoading: React__default.FC;

type SearchProps$1 = {};
type HeaderWithMenu = {
    Search?: React.FC<SearchProps$1>;
    logo?: string;
    logoWidth?: number;
    logoHeight?: number;
    hideThemeButton?: boolean;
    beforeLogout?: ReactNode;
    overflowedIndicator?: React.ReactNode | null;
    disabledOverflow?: boolean;
    style?: CSSProperties;
    className?: string;
};

type FullWidthLayoutProps = PropsWithChildren & {
    headerProps?: HeaderWithMenu;
    overflowedIndicator?: React.ReactNode | null;
    disabledOverflow?: boolean;
    style?: CSSProperties;
    contentStyle?: CSSProperties;
    className?: string;
    contentClassName?: string;
};

declare const FullWidthLayout: React__default.FC<FullWidthLayoutProps>;

type SearchProps = {};
type HeaderWithSearchProps = {
    Search?: React__default.FC<SearchProps>;
    beforeLogout?: ReactNode;
    beforeCurrentUser?: ReactNode;
};

declare const HeaderWithSearch: React__default.FC<HeaderWithSearchProps>;

declare const useStyles: (props?: unknown) => antd_style.ReturnStyles<{
    headerContainer: {
        backgroundColor: string;
        padding: string;
        minHeight: string;
        height: string;
    };
    flexContainer: {
        width: string;
        maxWidth: string;
        margin: string;
        height: string;
    };
    headerTitleRefine: {
        fontFamily: "Bricolage Grotesque, sans-serif";
        color: string;
    };
    headerTitleInvoicer: {
        fontFamily: "Bricolage Grotesque, sans-serif";
        color: string;
        fontWeight: number;
    };
    tabs: antd_style.SerializedStyles;
    inputSuffix: {
        width: string;
        height: string;
        display: "flex";
        alignItems: "center";
        justifyContent: "center";
        backgroundColor: string;
        color: string;
        borderRadius: string;
        fontSize: string;
    };
    inputPrefix: {
        color: string;
        marginRight: string;
    };
    languageSwitchText: {
        color: string;
    };
    languageSwitchIcon: {
        color: string;
        width: string;
    };
    themeSwitch: {
        display: "flex";
        alignItems: "center";
        justifyContent: "center";
        height: string;
        width: string;
        borderRadius: string;
        cursor: "pointer";
        flexShrink: number;
        backgroundColor: string;
    };
    rightSlot: {
        marginLeft: string;
        '@media (max-width: 1000px)': {
            padding: string;
        };
    };
}>;

declare const IconInvoicerLogo: (props: SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;

declare const IconMoon: () => react_jsx_runtime.JSX.Element;

declare const IconSun: () => react_jsx_runtime.JSX.Element;

type ImageUploadProps = {
    fileList?: UploadFile[];
    listType?: UploadProps['listType'];
    onPreview?: (file: UploadFile) => void;
    onChange?: UploadProps['onChange'];
    previewImage?: string;
    previewImageOpen?: boolean;
    onVisibleChange?: (visible: boolean) => void;
    afterOpenChange?: (visible: boolean) => void;
    onRemove?: (file: UploadFile<any>) => void;
    multiple?: boolean;
    disabled?: boolean;
};

declare const ImageUpload: React.FC<ImageUploadProps>;

type ImportButtonProps = {
    canAccess: boolean;
    openModal: () => void;
    title: string;
};

declare const ImportButton: React.FC<ImportButtonProps>;

type ImportModalProps = {
    modalProps: ModalProps;
    formProps: FormProps;
    onFinish: (values: unknown) => void;
    onCancel: () => void;
    isOpen: boolean;
    isLoading: boolean;
    title?: string;
    width?: number;
    extra?: ReactNode;
};

declare const ImportModal: React.FC<ImportModalProps>;

type TitleProps = RefineLayoutThemedTitleProps & {
    name: string;
    logo: string;
    logoWidth?: number;
    logoHeight?: number;
    gap?: string;
    flexRow?: boolean;
};

declare const Title: React__default.FC<TitleProps>;

type TitlePropsWithoutCollapse = Omit<TitleProps, 'collapsed'>;
interface SiderProps {
    titleProps: TitlePropsWithoutCollapse;
}
interface DrawerSiderProps {
    titleProps: TitlePropsWithoutCollapse;
}
interface ICollapseSider {
    titleProps: TitlePropsWithoutCollapse;
}
type SiderMenuProps = {
    selectedKey: string;
    defaultOpenKeys: Array<string>;
    setMobileSiderOpen: (open: boolean) => void;
    menuItems: ITreeMenu[];
    Link: React.FC<PropsWithChildren & {
        to: string;
        style?: CSSProperties;
    }>;
    siderCollapsed: boolean;
};
type RenderSiderMenu = (props: SiderMenuProps) => ReactNode;
interface MenuItemsProps {
    tree: ITreeMenu[];
    selectedKey?: string;
    Link: React.FC<PropsWithChildren & {
        to: string;
        style?: CSSProperties;
    }>;
    siderCollapsed: boolean;
}
type RenderMenuItems = (props: MenuItemsProps) => ReactNode;

declare const Sider: React__default.FC<SiderProps>;

type LayoutProps = PropsWithChildren & {
    siderProps: SiderProps;
    headerProps?: HeaderWithSearchProps;
    children: ReactNode;
};

declare const Layout: React__default.FC<LayoutProps>;

type LayoutContextProviderType = React.FC<PropsWithChildren>;

declare const LayoutContextProvider: LayoutContextProviderType;

type LeftHeaderProps = {
    onBackClick: () => void;
    backButtonLabel?: string;
};
type ProfileMetaCommonProps = {
    onTitleChange: ([titleOne, titleTwo]: [string, string]) => void;
    editTitleOne?: string;
    editTitleTwo?: string;
    titleLabelTwo?: string;
    titleLabelOne?: string;
    subtitleLabel?: string;
    hideTitleTwo?: boolean;
    hideSubtitle?: boolean;
    subtitle?: string;
    onSubtitleChange?: (subtitle: string) => void;
};
type ProfileMetaProps = ProfileMetaCommonProps & {
    image?: string;
    onImageChange: (photo: Blob) => void;
    onImageDelete: () => void;
    title: string;
    description?: string;
    isLoading?: boolean;
};
type ProfileMetaEditProps = ProfileMetaCommonProps & {
    onCancel?: () => void;
};
type RecordQuickActionsProps = {
    items: Array<{
        icon: React.ReactNode;
        label: string;
        onClick: () => void;
    }>;
    style?: CSSProperties;
};

declare const LeftHeader: React.FC<LeftHeaderProps>;

declare const ProfileMeta: React.FC<ProfileMetaProps>;

declare const ProfileMetaEdit: React.FC<ProfileMetaEditProps>;

declare const RecordQuickActions: React.FC<RecordQuickActionsProps>;

type ListPageProps = {
    resource: string;
    titleText?: string;
    isFetching?: boolean;
    searchFormProps?: any;
    children?: ReactNode;
    extra?: ReactNode;
    headerButtonsBefore?: ReactNode;
    headerButtonsAfter?: ReactNode;
    titleStyle?: React.CSSProperties;
    hideListTitleButton?: boolean;
    hideSearch?: boolean;
    titleExtra?: ReactNode;
    listTitleButtonComponent?: ReactNode;
    buttonText?: string;
};

declare const ListPage: React.FC<ListPageProps>;

interface ListTitleButtonProps {
    resource: string;
    buttonText?: string;
    textStyle?: CSSProperties;
    accessControl?: {
        enabled?: boolean;
        hideIfUnauthorized?: boolean;
    };
    meta?: Record<string, unknown>;
    size?: SizeType;
    marginTop?: string | number;
}

declare const ListTitleButton: React__default.FC<ListTitleButtonProps>;

type LogoProps = {
    src: string;
    height?: number;
    width?: number;
    alt?: string;
};

declare const Logo: React.FC<LogoProps>;

interface PaginationTotalProps {
    total: number;
    entityName: string;
}

declare const PaginationTotal: React__default.FC<PaginationTotalProps>;

interface PhoneNumberLinkProps {
    phone: string;
    style?: React.CSSProperties;
}

declare const PhoneNumberLink: React__default.FC<PhoneNumberLinkProps>;

interface SelectOptionWithAvatarProps {
    name: string;
    avatarUrl?: string;
    shape?: "circle" | "square";
}

declare const SelectOptionWithAvatar: React__default.FC<SelectOptionWithAvatarProps>;

type ShowLinkButtonProps = Omit<Omit<ShowButtonProps, 'icon'>, 'style'>;

declare const ShowLinkButton: React__default.FC<ShowLinkButtonProps>;

type SingleElementFormProps<T extends BaseRecord = BaseRecord> = {
    children?: React.ReactNode;
    icon?: React.ReactNode;
    itemProps?: FormItemProps;
    extra?: React.ReactNode;
    view?: React.ReactNode;
    state?: 'empty' | 'form' | 'view';
    onUpdate?: (values: BaseRecord) => void;
    onCancel?: () => void;
    onClick?: () => void;
    loading?: boolean;
    style?: React.CSSProperties;
    useFormProps?: UseFormProps<T>;
    formProps?: FormProps<T>;
    isDisabled?: boolean;
    resource?: string;
    id?: BaseKey;
    minimal?: boolean;
    disableEditIcon?: boolean;
    parseValues?: (values: BaseRecord) => BaseRecord;
    formItemStyle?: React.CSSProperties;
    wrapContent?: boolean;
    tooltip?: ReactNode;
};
type FallbackProps = {
    view?: ReactNode;
    onClick?: () => void;
    isDisabled?: boolean;
    disableEditIcon?: boolean;
};
type Fallback$1 = React.FC<FallbackProps>;
type SingleElementForm$1<T extends BaseRecord = BaseRecord> = React.FC<SingleElementFormProps<T>>;

declare const Fallback: Fallback$1;

declare const SingleElementForm: SingleElementForm$1;

type SpreadThreeColumnsProps = {
    leftColumnHeader?: ReactNode;
    leftColumnContentExtra?: ReactNode;
    leftColumnContent: ReactNode;
    mainColumnContent: ReactNode;
    rightColumnContent?: ReactNode;
};

declare const SpreadThreeColumns: React.FC<SpreadThreeColumnsProps>;

type SpreadsTwoColProps = {
    leftColumnHeader?: ReactNode;
    leftColumnContent: ReactNode;
    rightColumnContent: ReactNode;
};

declare const SpreadsTwoColumn: React.FC<SpreadsTwoColProps>;

type TextProps = {
    size?: "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl" | "huge" | "xhuge" | "xxhuge";
} & ComponentProps<typeof Typography.Text>;

declare const Text: React__default.FC<TextProps>;

declare const TextIcon: (props: Partial<CustomIconComponentProps>) => react_jsx_runtime.JSX.Element;

declare const Unauthorized: () => react_jsx_runtime.JSX.Element;

type UploadButtonProps = {
    icon?: ReactNode;
    label?: string;
};

declare const UploadButton: React.FC<UploadButtonProps>;

type OwnerDropdownProps = {
    placeholder?: string | ReactNode | null;
    width?: number;
    filters?: CrudFilters;
};
declare const OwnerDropdown: React.FC<SelectProps & OwnerDropdownProps>;

type UserPhotoUploadProps<T = Blob> = {
    photo?: string;
    name?: string;
    onChange: UploadProps$1<T>['onChange'];
    onRemove?: UploadProps$1<T>['onRemove'];
    readOnly?: boolean;
    size?: number;
};

declare const UserPhotoUpload: <T extends object>({ photo, size, name, onChange, readOnly, onRemove, }: UserPhotoUploadProps<T>) => react_jsx_runtime.JSX.Element;

declare const DEFAULT_THEME_CONFIG: ThemeConfig;

type LayoutContextValue = {
    noPadding: boolean;
    disableLayoutPadding: () => void;
    enableLayoutPadding: () => void;
};

declare const LayoutContext: React$1.Context<LayoutContextValue>;
declare const useLayoutContext: () => LayoutContextValue;

type ImportArgs = {
    parseArgs?: (record: unknown) => unknown;
};
type UseImportModalReturnType = {
    modalProps: ModalProps;
    isLoading: boolean;
    formProps: FormProps;
    onCancel: () => void;
    isOpen: boolean;
    onFinish: (values: unknown) => unknown;
    openModal: () => void;
    canAccess: boolean;
};
type UseImportModalProps = {
    resource: string;
    args?: ImportArgs;
};
type UseImportModalType = (props: UseImportModalProps) => UseImportModalReturnType;

declare const useImportModal: UseImportModalType;

type UseIsUrlButtonReturnValue = {
    isUrl: boolean;
    onClick: () => void;
};
type UseIsUrlButton = (props: {
    url: string | undefined;
}) => UseIsUrlButtonReturnValue;

declare const useIsUrlButton: UseIsUrlButton;

declare const useOwnership: (resource: string) => {
    canViewOthers: boolean;
    canEditOthers: boolean;
    canEditOwnership: boolean;
    canDeleteOthers: boolean;
    canListUsers: boolean;
    appendOwnerTableColumns: (columns: Array<unknown>, args?: {
        title?: string;
        viewType?: "selectOptionWithAvatar" | "text";
        role?: string;
        hideFilter?: boolean;
    }) => void;
    renderOwnerEditField: ({ getFormProps, owner, hideIcon, selectProps, label, viewType, role, }: {
        getFormProps: GetFormPropsType;
        owner: Owner | undefined;
        hideIcon?: boolean;
        selectProps?: SelectProps;
        label?: string;
        viewType?: "selectOptionWithAvatar" | "text";
        role?: string;
    }) => react_jsx_runtime.JSX.Element;
};

type ColorMode = 'dark' | 'light';

type UseThemeConfigProps = {
    mode: ColorMode;
    overrides?: ThemeConfig;
};
type UseThemeConfigResult = ThemeConfig;

declare const useThemeConfig: (props: UseThemeConfigProps) => UseThemeConfigResult;

type UseAccountSelectParams = {
    filters?: CrudFilters;
};

declare const useAccountSelect: (params?: UseAccountSelectParams) => _refinedev_antd.UseSelectReturnType<Account, _refinedev_core.BaseOption>;

declare const usePhoneinput: () => {
    fieldProps: {
        rules: {
            validator: (_: unknown, value: {
                valid: (strict?: boolean) => boolean;
            }) => Promise<void>;
        }[];
        enableSearch: boolean;
        enableArrow: boolean;
    };
    parsePhoneNumber: (value: PhoneNumber) => string;
};

type ParsePhoneNumberProps = {
    countryCode: number;
    areaCode: string;
    phoneNumber: string;
    isoCode: string;
    valid: (strict?: boolean) => boolean;
};

type UseUserSelectParams = {
    filters?: CrudFilters;
};

declare const useUserSelect: (params?: UseUserSelectParams) => _refinedev_antd.UseSelectReturnType<User, _refinedev_core.BaseOption>;

declare const isUrl: (url: string | undefined) => boolean;

declare const lightenHexColor: (color?: string, amount?: number) => string;

export { AccountDropdown, AvatarGroup, type AvatarGroupProps, BackButton, type BackButtonProps, Bootstrap, type BootstrapProps, CircleIconButtonAction, type CircleIconButtonActionProps, CurrentUser, type CurrentUserProps, CustomAvatar, type CustomAvatarProps, CustomDatePicker, type CustomDatePickerProps, CustomTabs, type CustomTabsProps, CustomTimePicker, type CustomTimePickerProps, DEFAULT_THEME_CONFIG, type DrawerSiderProps, EmailLink, type EmailLinkProps, Fallback, FieldFormTitle, type FieldFormTitleProps, FilterDropdown, type FilterDropdownProps, FormLoadingSkeleton, FormattedNumberField, type FormattedNumberFieldProps, FullScreenLoading, FullWidthLayout, type FullWidthLayoutProps, type HeaderWithMenu, HeaderWithSearch, type HeaderWithSearchProps, type ICollapseSider, IconInvoicerLogo, IconMoon, IconSun, ImageUpload, type ImageUploadProps, type ImportArgs, ImportButton, type ImportButtonProps, ImportModal, type ImportModalProps, Layout, LayoutContext, LayoutContextProvider, type LayoutContextProviderType, type LayoutContextValue, type LayoutProps, LeftHeader, type LeftHeaderProps, ListPage, type ListPageProps, ListTitleButton, type ListTitleButtonProps, Logo, type LogoProps, type MapValueEvent, type MenuItemsProps, OwnerDropdown, PaginationTotal, type PaginationTotalProps, type ParsePhoneNumberProps, PhoneNumberLink, type PhoneNumberLinkProps, ProfileMeta, ProfileMetaEdit, type ProfileMetaEditProps, type ProfileMetaProps, RecordQuickActions, type RecordQuickActionsProps, type RenderMenuItems, type RenderSiderMenu, SelectOptionWithAvatar, type SelectOptionWithAvatarProps, ShowLinkButton, type ShowLinkButtonProps, Sider, type SiderMenuProps, type SiderProps, SingleElementForm, SpreadThreeColumns, type SpreadThreeColumnsProps, type SpreadsTwoColProps, SpreadsTwoColumn, Text, TextIcon, type TextProps, Title, type TitleProps, Unauthorized, UploadButton, type UploadButtonProps, type UseAccountSelectParams, type UseImportModalProps, type UseImportModalReturnType, type UseImportModalType, type UseIsUrlButton, type UseIsUrlButtonReturnValue, type UseThemeConfigProps, type UseThemeConfigResult, type UseUserSelectParams, UserPhotoUpload, type UserPhotoUploadProps, isUrl, lightenHexColor, useAccountSelect, useImportModal, useIsUrlButton, useLayoutContext, useOwnership, usePhoneinput, useStyles, useThemeConfig, useUserSelect };