zaions-react-ui-kit/dist/index.d.ts

Zaions React ui Kit, this is react projects tool kit created by Zaions Dev Team (https://zaions.com). We hope you will love this and all other packages we have developed for you, please do react out if you face any issue in packages we deliver. Once again

import { PermissionEnum, RoleEnum, FormFieldsEnum } from 'zaions-tool-kit';
export { configureZTK } from 'zaions-tool-kit';
import React$1, { CSSProperties, ReactNode } from 'react';
import { Responsive } from '@radix-ui/themes/props';
import { CountdownTimeDelta } from 'react-countdown';
import { DropEvent, FileRejection, FileError } from 'react-dropzone';
import { ZDropzoneAccept } from 'zaions-react-tool-kit';
import { SelectComponents } from 'node_modules/react-select/dist/declarations/src/components';
import { PropsValue, OptionsOrGroups, GroupBase, StylesConfig, SingleValue, ActionMeta, MultiValue } from 'react-select';
import * as Accordion from '@radix-ui/react-accordion';
import { FormikHelpers } from 'formik';
import { RecoilState } from 'recoil';
import dayjs from 'dayjs';
import { ToastContent, ToastOptions } from 'react-toastify';
import { z } from 'zod';

declare enum RegisterFormFieldsEnum {
    name = "name",
    email = "email",
    password = "password",
    passwordConfirmation = "passwordConfirmation"
}
declare enum LoginFormFieldsEnum {
    email = "email",
    password = "password"
}
declare enum UserAccountDataFormFieldsEnum {
    name = "name"
}
declare enum ZFormModeE {
    edit = "edit",
    add = "add"
}

declare enum ZPermissionCheckModeEnum {
    every = "every",
    any = "any"
}
declare enum ZSideE {
    start = "start",
    end = "end"
}

declare enum ZRUSideE {
    left = "left",
    right = "right"
}
declare enum ZRUCommonVariantE {
    classic = "classic",
    surface = "surface"
}
declare enum ZRUTableVariantE {
    ghost = "ghost",
    surface = "surface"
}
declare enum ZRUTableLayoutE {
    auto = "auto",
    fixed = "fixed"
}
declare enum ZRUCalloutVariantE {
    surface = "surface",
    soft = "soft",
    outline = "outline"
}
declare enum ZRUBasicVariantE {
    classic = "classic",
    surface = "surface",
    ghost = "ghost"
}
declare enum ZRUAvatarVariantE {
    soft = "soft",
    solid = "solid"
}
declare enum ZRUTriggerVariantE {
    classic = "classic",
    surface = "surface",
    soft = "soft"
}
declare enum ZRUBadgeVariantE {
    solid = "solid",
    soft = "soft",
    surface = "surface",
    outline = "outline"
}
declare enum ZRUVariantE {
    classic = "classic",
    solid = "solid",
    soft = "soft",
    surface = "surface",
    outline = "outline",
    ghost = "ghost"
}
declare enum ZRUColorE {
    gray = "gray",
    gold = "gold",
    bronze = "bronze",
    brown = "brown",
    yellow = "yellow",
    amber = "amber",
    orange = "orange",
    tomato = "tomato",
    red = "red",
    ruby = "ruby",
    crimson = "crimson",
    pink = "pink",
    plum = "plum",
    purple = "purple",
    violet = "violet",
    iris = "iris",
    indigo = "indigo",
    blue = "blue",
    cyan = "cyan",
    teal = "teal",
    jade = "jade",
    green = "green",
    grass = "grass",
    lime = "lime",
    mint = "mint",
    sky = "sky"
}
declare enum ZRURadiusE {
    none = "none",
    small = "small",
    medium = "medium",
    large = "large",
    full = "full"
}
declare enum ZRUInputTypeE {
    number = "number",
    search = "search",
    time = "time",
    text = "text",
    hidden = "hidden",
    date = "date",
    datetimeLocal = "datetime-local",
    email = "email",
    month = "month",
    password = "password",
    tel = "tel",
    url = "url",
    week = "week"
}
declare enum ZRUScrollbarsE {
    vertical = "vertical",
    horizontal = "horizontal",
    both = "both"
}
declare enum ZRUOrientationE {
    vertical = "vertical",
    horizontal = "horizontal"
}
declare enum ZRUScrollbarTypeE {
    auto = "auto",
    always = "always",
    scroll = "scroll",
    hover = "hover"
}
declare enum ZRUAsE {
    div = "div",
    span = "span"
}
declare enum ZRUTextAsE {
    div = "div",
    span = "span",
    label = "label",
    p = "p"
}
declare enum ZRUHeadingAsE {
    h1 = "h1",
    h2 = "h2",
    h3 = "h3",
    h4 = "h4",
    h5 = "h5",
    h6 = "h6"
}
declare enum ZRUDirectionE {
    row = "row",
    column = "column",
    rowRevers = "row-reverse",
    columnRevers = "column-reverse"
}
declare enum ZRUPositionE {
    static = "static",
    relative = "relative",
    absolute = "absolute",
    fixed = "fixed",
    sticky = "sticky"
}
declare enum ZRUDisplayE {
    none = "none",
    inlineFlex = "inline-flex",
    flex = "flex"
}
declare enum ZRUContainerDisplayE {
    none = "none",
    initial = "initial"
}
declare enum ZRUBoxDisplayE {
    none = "none",
    inline = "inline",
    inlineBlock = "inline-block",
    block = "block"
}
declare enum ZRUTableRowAlignE {
    start = "start",
    center = "center",
    end = "end",
    baseline = "baseline"
}
declare enum ZRUAlignE {
    start = "start",
    center = "center",
    end = "end",
    baseline = "baseline",
    stretch = "stretch"
}
declare enum ZRUGeneralAlignE {
    left = "left",
    center = "center",
    right = "right"
}
declare enum ZRUTrimE {
    normal = "normal",
    start = "start",
    end = "end",
    both = "both"
}
declare enum ZRUJustifyE {
    start = "start",
    center = "center",
    end = "end",
    between = "between"
}
declare enum ZRUCellJustifyE {
    start = "start",
    center = "center",
    end = "end"
}
declare enum ZRUWrapFlexE {
    nowrap = "nowrap",
    wrap = "wrap",
    wrapReverse = "wrap-reverse"
}
declare enum ZRUWrapE {
    nowrap = "nowrap",
    wrap = "wrap",
    pretty = "pretty",
    balance = "balance"
}
declare enum ZRUOverflowE {
    visible = "visible",
    hidden = "hidden",
    clip = "clip",
    scroll = "scroll",
    auto = "auto"
}
declare enum ZRUWeightE {
    light = "light",
    regular = "regular",
    medium = "medium",
    bold = "bold"
}
declare enum ZRUSelectContentPositionE {
    itemAligned = "item-aligned",
    popper = "popper"
}
declare enum ZRUAccordingTypeE {
    single = "single",
    multiple = "multiple"
}
declare enum ZRUUnderlineLinkE {
    auto = "auto",
    always = "always",
    hover = "hover",
    none = "none"
}
declare enum ZRUWrapLinkE {
    wrap = "wrap",
    nowrap = "nowrap",
    pretty = "pretty",
    balance = "balance"
}
declare enum ZRULinkWeightE {
    light = "light",
    regular = "regular",
    medium = "medium",
    bold = "bold"
}

declare enum ReactToastifyTypeEnum {
    info = "info",
    success = "success",
    warning = "warning",
    error = "error",
    default = "default"
}

interface ILoginFormData {
    [LoginFormFieldsEnum.email]: string;
    [LoginFormFieldsEnum.password]: string;
}
interface IRegisterFormData extends ILoginFormData {
    [RegisterFormFieldsEnum.name]: string;
    [RegisterFormFieldsEnum.passwordConfirmation]: string;
}
interface ISelectOption {
    label: string;
    value: string;
}

interface ZCanI {
    children: React.ReactNode;
    permissions?: Array<PermissionEnum>;
    checkMode?: ZPermissionCheckModeEnum;
    returnPermissionDeniedView?: boolean;
    roles?: Array<RoleEnum> | null;
}

interface ZRUStyleI {
    p?: Responsive<string>;
    px?: Responsive<string>;
    py?: Responsive<string>;
    pt?: Responsive<string>;
    pr?: Responsive<string>;
    pb?: Responsive<string>;
    pl?: Responsive<string>;
    width?: Responsive<string>;
    minWidth?: Responsive<string>;
    maxWidth?: Responsive<string>;
    height?: Responsive<string>;
    minHeight?: Responsive<string>;
    maxHeight?: Responsive<string>;
    position?: Responsive<ZRUPositionE>;
    inset?: Responsive<string>;
    top?: Responsive<string>;
    right?: Responsive<string>;
    bottom?: Responsive<string>;
    left?: Responsive<string>;
    overflow?: Responsive<ZRUOverflowE>;
    overflowX?: Responsive<ZRUOverflowE>;
    overflowY?: Responsive<ZRUOverflowE>;
    flexBasis?: Responsive<string>;
    flexShrink?: Responsive<string>;
    flexGrow?: Responsive<string>;
    gridColumn?: Responsive<string>;
    gridColumnStart?: Responsive<string>;
    gridColumnEnd?: Responsive<string>;
    gridRow?: Responsive<string>;
    gridRowStart?: Responsive<string>;
    gridRowEnd?: Responsive<string>;
}
interface ZRUMarginI {
    m?: Responsive<string>;
    mx?: Responsive<string>;
    my?: Responsive<string>;
    mt?: Responsive<string>;
    mr?: Responsive<string>;
    mb?: Responsive<string>;
    ml?: Responsive<string>;
}
interface ZRUPaddingI {
    p?: Responsive<string>;
    px?: Responsive<string>;
    py?: Responsive<string>;
    pt?: Responsive<string>;
    pr?: Responsive<string>;
    pb?: Responsive<string>;
    pl?: Responsive<string>;
}
interface ZRUSelectValueI {
    value: string | number;
    label: string | number;
}
type ResponsiveT<T> = T | Record<string, T>;
type ZRUSizeT = '1' | '2' | '3' | '4';
type ZRUTextSizeT = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
type ZRUMarginT = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '-1' | '-2' | '-3' | '-4' | '-5' | '-6' | '-7' | '-8' | '-9';
interface ZRUShowable {
    show?: boolean;
}

interface ZRUButtonI extends ZRUMarginI, ZRUShowable, Omit<ZCanI, "children"> {
    children?: React.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    size?: Responsive<ZRUSizeT>;
    variant?: ZRUVariantE;
    color?: ZRUColorE;
    highContrast?: boolean;
    radius?: ZRURadiusE;
    loading?: boolean;
    disabled?: boolean;
    type?: "button" | "submit" | "reset";
    onClick?: React.MouseEventHandler<HTMLButtonElement>;
}
interface ZRURadioCardsGroupI extends ZRUShowable {
    children?: React.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    size?: Responsive<"1" | "2" | "3">;
    variant?: ZRUCommonVariantE;
    color?: ZRUColorE;
    highContrast?: boolean;
    columns?: Responsive<string>;
    gap?: Responsive<string>;
    defaultValue?: string;
    value?: string | null;
    onChange?: React.FormEventHandler<HTMLDivElement>;
    onValueChange?: (value: string) => void;
}
interface ZRURadioCardsItemI extends ZRUShowable {
    value: string;
    children?: React.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
}
interface ZRUBoxI extends ZRUStyleI, ZRUShowable, Omit<ZCanI, "children"> {
    children?: React.ReactNode;
    asChild?: boolean;
    className?: string;
    style?: CSSProperties;
    as?: ZRUAsE;
    display?: Responsive<ZRUBoxDisplayE>;
    onClick?: () => void;
}
interface ZRUAspectRatioI extends ZRUShowable {
    ratio?: number;
    className?: string;
    children?: React.ReactNode;
}
interface ZRUSkeletonI {
    children?: React.ReactNode;
    className?: string;
    loading?: boolean;
    width?: Responsive<string>;
    minWidth?: Responsive<string>;
    maxWidth?: Responsive<string>;
    height?: Responsive<string>;
    minHeight?: Responsive<string>;
    maxHeight?: Responsive<string>;
}
interface ZRUInputI extends ZRUShowable {
    children?: React.ReactNode;
    className?: string;
    inputClassName?: string;
    labelClassName?: string;
    style?: Record<string, unknown>;
    value?: string | number;
    disabled?: boolean;
    required?: boolean;
    placeholder?: string;
    size?: Responsive<"1" | "2" | "3">;
    color?: ZRUColorE;
    radius?: ZRURadiusE;
    isTouched?: boolean;
    errorMessage?: string;
    infoText?: string;
    label?: string;
    name?: string;
    type?: ZRUInputTypeE;
    onChange?: React.ChangeEventHandler<HTMLInputElement>;
    onBlur?: React.FocusEventHandler<HTMLInputElement>;
}
interface IZRUColumnCell extends ZRUPaddingI, ZRUShowable {
    children?: React.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    justify?: ZRUCellJustifyE;
    width?: Responsive<string>;
    minWidth?: Responsive<string>;
    maxWidth?: Responsive<string>;
}

interface IZImage extends Omit<ZRUAspectRatioI, "className" | "children">, Omit<ZRUSkeletonI, "className" | "children"> {
    src?: string;
    alt?: string;
    skeletonClassName?: string;
    aspectRatioClassName?: string;
    imgClassName?: string;
}

interface ZCurrencyI {
    value?: string;
    label?: string;
    symbol?: string;
}
interface ZPrizeInputStateI {
    currency?: ZCurrencyI;
    prize?: string;
}
type ZPrizeInputOnChange = (e: ZPrizeInputStateI) => void;

type ZRSelectI = {
    className?: string;
    loading?: boolean;
    labelClassName?: string;
    label?: string;
    selectClassName?: string;
    classNamePrefix?: string;
    required?: boolean;
    name?: string;
    placeholder?: React.ReactNode;
    disabled?: boolean;
    isClearable?: boolean;
    isDisabled?: boolean;
    isRtl?: boolean;
    isSearchable?: boolean;
    isTouched?: boolean;
    errorMessage?: string;
    value?: PropsValue<ZRSelectOptions>;
    defaultValue?: PropsValue<ZRSelectOptions>;
    options?: OptionsOrGroups<ZRSelectOptions, GroupBase<ZRSelectOptions>>;
    onBlur?: React.FocusEventHandler<HTMLInputElement>;
    onFocus?: React.FocusEventHandler<HTMLInputElement>;
    style?: React.CSSProperties;
    infoText?: string;
    styles?: StylesConfig<ZRSelectOptions, boolean, GroupBase<ZRSelectOptions>>;
    menuIsOpen?: boolean;
    components?: Partial<SelectComponents<ZRSelectOptions, boolean, GroupBase<ZRSelectOptions>>>;
    showLabelBtn?: boolean;
    labelBtnProps?: ZRUButtonI;
} & ({
    isMulti?: false;
    onChange?: (newValue: SingleValue<ZRSelectOptions>, actionMeta: ActionMeta<ZRSelectOptions>) => void;
} | {
    isMulti: true;
    onChange?: (newValue: MultiValue<ZRSelectOptions>, actionMeta: ActionMeta<ZRSelectOptions>) => void;
});

type ZGenericObject<T> = Record<string, T>;
interface ZRSelectOptions {
    readonly value?: string | number;
    readonly label?: ReactNode | string | number;
    readonly color?: string;
    readonly isFixed?: boolean;
    readonly isDisabled?: boolean;
    readonly className?: string;
    readonly extraData?: string;
    readonly symbol?: string;
}

interface ZSidebarI {
    isOpen?: boolean;
    component?: React.FC<unknown>;
    containerClassName?: string;
    rootConStyle?: React.CSSProperties;
    containerStyle?: React.CSSProperties;
    componentProps?: ZGenericObject<unknown>;
    width?: string;
    shouldBackdropClose?: boolean;
    side?: ZSideE;
}
interface ZPopoverI {
    isOpen?: boolean;
    component?: React.FC<unknown>;
    componentProps?: ZGenericObject<unknown>;
    containerClassName?: string;
    width?: string;
    height?: string;
}

interface LoginI {
    email: string;
    password: string;
    isApiError: boolean;
}
interface RegisterI extends LoginI {
    username: string;
}

interface ZUserAvatarI extends ZRUShowable {
    className?: string;
    avatarClassName?: string;
    variant?: ZRUAvatarVariantE;
    color?: ZRUColorE;
    src?: string;
    fallback: string;
    textClassName?: string;
    text?: string;
    arrowDownClassName?: string;
    onClick?: () => void;
    logoutBtnClickHandler?: React$1.MouseEventHandler<HTMLButtonElement>;
}
declare const ZUserAvatar: React$1.FC<ZUserAvatarI>;

interface IErrorBoundaryProps extends ZRUShowable {
    message?: string;
    showGoToHomeButton?: boolean;
    onClick?: React.MouseEventHandler<HTMLButtonElement>;
    btnText?: string;
}
declare const ErrorBoundary: React.FC<IErrorBoundaryProps>;

declare const FullPageLoader: React$1.FC;

interface IZAmount extends ZRUShowable {
    children: React$1.ReactNode;
}
declare const ZAmount: React$1.FC<IZAmount>;

declare const ZAmountInput: React$1.FC<ZRUInputI>;

declare const ZAppLoader: React$1.FC<{
    showAppLoader?: boolean;
}>;

declare const ZCan: React$1.FC<ZCanI>;

declare const ZClipboard: React$1.FC<{
    text?: string;
}>;

declare const _default_1: React$1.NamedExoticComponent<{
    date?: string | number;
    size?: ZRUTextSizeT;
    onComplete?: ((timeDelta: CountdownTimeDelta, completedOnStart: boolean) => void) | (() => void);
}>;

declare const ZErrorText: React$1.FC<{
    message?: string | Array<string>;
} & ZRUShowable>;

interface ZFileDropUploaderI {
    children?: React$1.ReactNode;
    className?: string;
    multiple?: boolean;
    noClick?: boolean;
    required?: boolean;
    loading?: boolean;
    loadingText?: string;
    noDrag?: boolean;
    isTouched?: boolean;
    errorMessage?: string;
    infoText?: string;
    accept?: ZDropzoneAccept;
    ratio?: number;
    labelClassName?: string;
    label?: string;
    localUrl?: string | null;
    disabled?: boolean;
    noKeyboard?: boolean;
    onFileDialogCancel?: () => void;
    onFileDialogOpen?: () => void;
    onDragEnter?: React$1.DragEventHandler<HTMLElement>;
    onDragLeave?: React$1.DragEventHandler<HTMLElement>;
    onDragOver?: React$1.DragEventHandler<HTMLElement>;
    onDropAccepted?: <T extends File>(files: T[], event: DropEvent) => void;
    onDropRejected?: (fileRejections: FileRejection[], event: DropEvent) => void;
    onChange?: <T extends File>(params: {
        acceptedFiles: T[];
        fileRejections: FileRejection[];
        event: DropEvent;
        localUrl: string;
    }) => void;
    validator?: <T extends File>(file: T) => FileError | FileError[] | null;
}
declare const ZFileDropUploader: React$1.FC<ZFileDropUploaderI>;

interface IZFormActionButtonsProps {
    showResetButton?: boolean;
    resetButtonColor?: ZRUColorE;
    showSubmitButton?: boolean;
    resetButtonText?: React.ReactNode;
    resetButtonDisable?: boolean;
    submitButtonText?: string;
    onResetClicked?: () => void;
    processing?: boolean;
    mode?: ZFormModeE;
    disableSubmitOnFormNotValid?: boolean;
}
declare const ZFormActionButtons: React.FC<IZFormActionButtonsProps>;

interface IZFullPageCenteredMessageProps {
    message: string;
    showGoToHomeButton?: boolean;
    homeBtnOnClick?: React.MouseEventHandler<HTMLButtonElement>;
}
declare const ZFullPageCenteredMessage: React.FC<IZFullPageCenteredMessageProps>;

declare const ZImage: React$1.FC<IZImage>;

declare const ZLanguageSelector: React$1.FC<{
    show?: boolean;
}>;

interface ZModalI {
    children: React$1.ReactNode;
    open?: boolean;
    className?: string;
    titleClassName?: string;
    title?: string;
    disableCrossBtn?: boolean;
    modalDescription?: string;
    onOpenChange?: (open: boolean) => void;
    crossOnClick?: React$1.MouseEventHandler<SVGSVGElement>;
}
declare const ZModal: React$1.FC<ZModalI>;

declare const ZNetworkDisconnected: React$1.FC;

declare const ZNotFound: React$1.FC<{
    showHomeBtn?: boolean;
    homeBtnOnClick?: React$1.MouseEventHandler<HTMLButtonElement>;
}>;

interface IZPage {
    children?: React$1.ReactNode;
    className?: string;
}
declare const ZPage: React$1.FC<IZPage>;

interface ZPaginationI {
    disablePrevious?: boolean;
    disableNext?: boolean;
    disableFirst?: boolean;
    disableLast?: boolean;
    currentPage?: number;
    paginationItems?: Array<string | number>;
    firstOnClick?: React$1.MouseEventHandler<HTMLElement>;
    lastOnClick?: React$1.MouseEventHandler<HTMLElement>;
    previousOnClick?: () => void;
    nextOnClick?: () => void;
    itemOnClick?: (e: number) => void;
}
declare const ZPagination: React$1.FC<ZPaginationI>;

interface ZPrizeInputI {
    onChange?: ZPrizeInputOnChange;
    value?: ZPrizeInputStateI;
    className?: string;
    labelClassName?: string;
    required?: boolean;
    isTouched?: boolean;
    errorMessage?: string;
    infoText?: string;
    label?: string;
    inputContainerClassName?: string;
    selectClassName?: string;
    inputClassName?: string;
    onBlur?: React$1.FocusEventHandler<HTMLInputElement>;
}
declare const ZPrizeInput: React$1.FC<ZPrizeInputI>;

declare const ZRCSelect: React$1.FC<ZRSelectI>;

declare const ZRSelect: React$1.FC<ZRSelectI>;

declare const ZRUBox: React$1.FC<ZRUBoxI>;

interface ZRUContainerI extends ZRUStyleI, ZRUShowable {
    children?: React$1.ReactNode;
    asChild?: boolean;
    className?: string;
    style?: Record<string, unknown>;
    size?: Responsive<ZRUSizeT>;
    display?: Responsive<ZRUContainerDisplayE>;
    align?: Responsive<ZRUGeneralAlignE>;
}
declare const ZRUContainer: React$1.FC<ZRUContainerI>;

interface ZRUFlexI extends ZRUStyleI, ZRUMarginI, ZRUShowable {
    children?: React$1.ReactNode;
    asChild?: boolean;
    className?: string;
    style?: Record<string, unknown>;
    as?: ZRUAsE;
    direction?: Responsive<ZRUDirectionE>;
    display?: Responsive<ZRUDisplayE>;
    align?: Responsive<ZRUAlignE>;
    justify?: Responsive<ZRUJustifyE>;
    wrap?: Responsive<ZRUWrapFlexE>;
    gap?: Responsive<string>;
    gapX?: Responsive<string>;
    gapY?: Responsive<string>;
    onClick?: () => void;
}
declare const ZRUFlex: React$1.FC<ZRUFlexI>;

interface ZRUHeadingI extends ZRUStyleI, ZRUMarginI, ZRUShowable {
    children?: React$1.ReactNode;
    asChild?: boolean;
    className?: string;
    style?: Record<string, unknown>;
    as?: ZRUHeadingAsE;
    size?: Responsive<ZRUTextSizeT>;
    weight?: Responsive<ZRUWeightE>;
    align?: Responsive<ZRUGeneralAlignE>;
    trim?: Responsive<ZRUTrimE>;
    truncate?: boolean;
    wrap?: Responsive<ZRUWrapE>;
    color?: ZRUColorE;
    highContrast?: boolean;
}
declare const ZRUHeading: React$1.FC<ZRUHeadingI>;

interface ZRUTextI extends ZRUMarginI, ZRUShowable, Omit<ZCanI, "children"> {
    children?: React$1.ReactNode;
    asChild?: boolean;
    className?: string;
    style?: Record<string, unknown>;
    as?: ZRUTextAsE;
    size?: Responsive<ZRUTextSizeT>;
    weight?: Responsive<ZRUWeightE>;
    align?: Responsive<ZRUGeneralAlignE>;
    trim?: Responsive<ZRUTrimE>;
    truncate?: boolean;
    wrap?: Responsive<ZRUWrapE>;
    color?: ZRUColorE;
    highContrast?: boolean;
    onClick?: React$1.MouseEventHandler<HTMLElement>;
}
declare const ZRUText: React$1.FC<ZRUTextI>;

declare const ZRUAccordionContent: React$1.FC<Accordion.AccordionContentProps & React$1.RefAttributes<HTMLDivElement> & ZRUShowable>;

declare const ZRUAccordingGroup: React$1.FC<Accordion.AccordionSingleProps | Accordion.AccordionMultipleProps>;

declare const ZRUAccordionItem: React$1.FC<Accordion.AccordionItemProps & React$1.RefAttributes<HTMLDivElement> & ZRUShowable>;

declare const ZRUAccordionTrigger: React$1.FC<{
    showIcon?: boolean;
} & Accordion.AccordionTriggerProps & React$1.RefAttributes<HTMLButtonElement> & ZRUShowable>;

declare const ZRUAspectRatio: React$1.FC<ZRUAspectRatioI>;

interface ZRUAvatarI extends ZRUShowable {
    className?: string;
    src?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    color?: ZRUColorE;
    highContrast?: boolean;
    radius?: ZRURadiusE;
    variant?: ZRUAvatarVariantE;
    fallback: NonNullable<React$1.ReactNode>;
    loading?: boolean;
    size?: Responsive<"1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9">;
}
declare const ZRUAvatar: React$1.FC<ZRUAvatarI>;

interface ZRUBadgeI extends ZRUShowable {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    size?: Responsive<"1" | "2" | "3">;
    variant?: ZRUBadgeVariantE;
    color?: ZRUColorE;
    highContrast?: boolean;
    radius?: ZRURadiusE;
    onClick?: React$1.MouseEventHandler<HTMLSpanElement>;
}
declare const ZRUBadge: React$1.FC<ZRUBadgeI>;

declare const ZRUButton: React$1.FC<ZRUButtonI>;

interface IZRUCallout extends ZRUShowable {
    asChild?: boolean;
    className?: string;
    size?: Responsive<"1" | "2" | "3">;
    variant?: ZRUCalloutVariantE;
    color?: ZRUColorE;
    highContrast?: boolean;
    icon?: React$1.ReactNode;
    content?: React$1.ReactNode;
    showIcon?: boolean;
    contentClassName?: string;
    iconClassName?: string;
}
declare const ZRUCallout: React$1.FC<IZRUCallout>;

interface ZRUCardI extends ZRUShowable {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    size?: Responsive<"1" | "2" | "3" | "4" | "5">;
    variant?: ZRUBasicVariantE;
    onClick?: React$1.MouseEventHandler<HTMLDivElement>;
}
declare const ZRUCard: React$1.FC<ZRUCardI>;

interface ZRUCheckboxI extends ZRUShowable {
    checked?: boolean;
    defaultChecked?: boolean;
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    variant?: ZRUTriggerVariantE;
    color?: ZRUColorE;
    size?: Responsive<"1" | "2" | "3">;
    disabled?: boolean;
    onChange?: React$1.FormEventHandler<HTMLButtonElement>;
    onCheckedChange?(checked: boolean): void;
}
declare const ZRUCheckbox: React$1.FC<ZRUCheckboxI>;

interface ZRUCheckboxCardsGroupI extends ZRUShowable {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    size?: Responsive<"1" | "2" | "3">;
    variant?: ZRUCommonVariantE;
    color?: ZRUColorE;
    highContrast?: boolean;
    columns?: Responsive<string>;
    gap?: Responsive<string>;
    defaultValue?: string[];
    value?: string[];
    onChange?: React$1.FormEventHandler<HTMLDivElement>;
    onValueChange?: (value: string[]) => void;
}
declare const ZRUCheckboxCardsGroup: React$1.FC<ZRUCheckboxCardsGroupI>;

interface ZRUCheckboxCardsItemI extends ZRUShowable {
    value: string;
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
}
declare const ZRUCheckboxCardsItem: React$1.FC<ZRUCheckboxCardsItemI>;

interface ZRUCheckboxGroupI extends ZRUShowable {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    size?: Responsive<"1" | "2" | "3">;
    color?: ZRUColorE;
    variant?: ZRUTriggerVariantE;
    highContrast?: boolean;
    value?: string[];
    defaultValue?: string[];
    name?: string;
    onChange?: React$1.FormEventHandler<HTMLDivElement>;
    onBlur?: React$1.FocusEventHandler<HTMLDivElement>;
    onValueChange?: (value: string[]) => void;
}
declare const ZRUCheckboxGroup: React$1.FC<ZRUCheckboxGroupI>;

interface ZRUCheckboxItemI extends ZRUShowable {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    value: string;
}
declare const ZRUCheckboxItem: React$1.FC<ZRUCheckboxItemI>;

interface ZRUDataListI extends ZRUShowable {
    orientation?: Responsive<ZRUOrientationE>;
    size?: Responsive<"1" | "2" | "3">;
    trim?: ZRUTrimE;
    className?: string;
    dataList: Array<{
        label: React$1.ReactNode;
        align?: ZRUAlignE;
        className?: string;
        labelProps?: {
            className?: string;
            width?: Responsive<string>;
            minWidth?: Responsive<string>;
            maxWidth?: Responsive<string>;
            color?: ZRUColorE;
            highContrast?: boolean;
        };
        value: React$1.ReactNode;
        valueProps?: {
            className?: string;
        };
    } & ZRUShowable>;
}
declare const ZRUDataList: React$1.FC<ZRUDataListI>;

interface ZRUDialogCloseI extends ZRUShowable {
    children?: React$1.ReactNode;
    disabled?: boolean;
}
declare const ZRUDialogClose: React$1.FC<ZRUDialogCloseI>;

interface ZRUDialogI extends ZRUShowable {
    children?: React$1.ReactNode;
    asChild?: boolean;
    size?: Responsive<"1" | "2" | "3" | "4">;
    width?: Responsive<string>;
    maxWidth?: Responsive<string>;
    minWidth?: Responsive<string>;
    height?: Responsive<string>;
    maxHeight?: Responsive<string>;
    minHeight?: Responsive<string>;
    highContrast?: boolean;
    open?: boolean;
    defaultOpen?: boolean;
    className?: string;
    onOpenChange?(open: boolean): void;
    trigger?: {
        children?: React$1.ReactNode;
    };
}
declare const ZRUDialog: React$1.FC<ZRUDialogI>;

interface ZRUDropdownMenuI extends ZRUShowable {
    children?: React$1.ReactNode;
    asChild?: boolean;
    style?: Record<string, unknown>;
    className?: string;
    size?: Responsive<"1" | "2">;
    color?: ZRUColorE;
    highContrast?: boolean;
    trigger?: {
        children?: React$1.ReactNode;
    };
}
declare const ZRUDropdownMenu: React$1.FC<ZRUDropdownMenuI>;

interface ZRUDropdownMenuItemI extends ZRUShowable {
    children?: React$1.ReactNode;
    asChild?: boolean;
    style?: Record<string, unknown>;
    className?: string;
    color?: ZRUColorE;
    shortcut?: string;
}
declare const ZRUDropdownMenuItem: React$1.FC<ZRUDropdownMenuItemI>;

interface ZRUIconButtonI extends ZRUShowable {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    size?: Responsive<ZRUSizeT>;
    variant?: ZRUVariantE;
    color?: ZRUColorE;
    highContrast?: boolean;
    radius?: ZRURadiusE;
    loading?: boolean;
    onClick?: React$1.MouseEventHandler<HTMLButtonElement>;
}
declare const ZRUIconButton: React$1.FC<ZRUIconButtonI>;

declare const ZRUInput: React$1.FC<ZRUInputI>;

interface ZRUInputSlotI extends ZRUShowable {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    side?: ZRUSideE;
    color?: ZRUColorE;
    gap?: Responsive<string>;
    px?: Responsive<string>;
    pl?: Responsive<string>;
    pr?: Responsive<string>;
}
declare const ZRUInputSlot: React$1.FC<ZRUInputSlotI>;

interface ZRULinkI extends ZRUMarginI, ZRUShowable {
    children?: React$1.ReactNode;
    asChild?: boolean;
    className?: string;
    style?: Record<string, unknown>;
    size?: Responsive<"1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9">;
    weight?: Responsive<ZRULinkWeightE>;
    trim?: Responsive<ZRUTrimE>;
    truncate?: boolean;
    wrap?: Responsive<ZRUWrapLinkE>;
    underline?: ZRUUnderlineLinkE;
    color?: ZRUColorE;
    highContrast?: boolean;
    href?: string;
    target?: React$1.HTMLAttributeAnchorTarget;
    onClick?: React$1.MouseEventHandler<HTMLAnchorElement>;
}
declare const ZRULink: React$1.FC<ZRULinkI>;

interface ZRUPopoverI extends ZRUShowable {
    children?: React$1.ReactNode;
    disabled?: boolean;
    asChild?: boolean;
    className?: string;
    size?: Responsive<"1" | "2" | "3" | "4">;
    width?: Responsive<string>;
    maxWidth?: Responsive<string>;
    minWidth?: Responsive<string>;
    height?: Responsive<string>;
    maxHeight?: Responsive<string>;
    minHeight?: Responsive<string>;
    highContrast?: boolean;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?(open: boolean): void;
    trigger?: {
        children?: React$1.ReactNode;
    };
}
declare const ZRUPopover: React$1.FC<ZRUPopoverI>;

interface ZRUProgressI extends ZRUShowable {
    className?: string;
    style?: Record<string, unknown>;
    size?: Responsive<"1" | "2" | "3">;
    variant?: ZRUTriggerVariantE;
    color?: ZRUColorE;
    highContrast?: boolean;
    radius?: ZRURadiusE;
    duration?: `${number}s` | `${number}ms`;
    value?: number;
}
declare const ZRUProgress: React$1.FC<ZRUProgressI>;

declare const ZRURadioCardsGroup: React$1.FC<ZRURadioCardsGroupI>;

declare const ZRURadioCardsItem: React$1.FC<ZRURadioCardsItemI>;

declare const ZRURadioCardList: React$1.FC<Omit<ZRURadioCardsGroupI, "children"> & {
    items: Array<Omit<ZRURadioCardsItemI, "children"> & {
        label: string;
    }>;
    labelClassName?: string;
    label?: string;
    required?: boolean;
    isTouched?: boolean;
    errorMessage?: string;
    infoText?: string;
} & ZRUShowable>;

interface ZRURadioGroupI {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    size?: Responsive<"1" | "2" | "3">;
    color?: ZRUColorE;
    highContrast?: boolean;
    value?: string;
    defaultValue?: string;
    name?: string;
    onChange?: React$1.FormEventHandler<HTMLDivElement>;
    onBlur?: React$1.FocusEventHandler<HTMLDivElement>;
}
declare const ZRURadioGroup: React$1.FC<ZRURadioGroupI>;

interface ZRURadioItemI {
    children?: React$1.ReactNode;
    value: string;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
}
declare const ZRURadioItem: React$1.FC<ZRURadioItemI>;

interface ZRUScrollAreaI {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    asChild?: boolean;
    size?: Responsive<"1" | "2" | "3">;
    radius?: ZRURadiusE;
    scrollbars?: ZRUScrollbarsE;
    type?: ZRUScrollbarTypeE;
}
declare const ZRUScrollArea: React$1.FC<ZRUScrollAreaI>;

interface IZRUSegmentedControl {
    children?: React$1.ReactNode;
    size?: Responsive<"1" | "2" | "3">;
    radius?: ZRURadiusE;
    variant?: ZRUCommonVariantE;
    value?: string;
    defaultValue?: string;
    className?: string;
    onValueChange?(value: string): void;
}
declare const ZRUSegmentedControl: React$1.FC<IZRUSegmentedControl>;

interface IZRUSegmentedControlItem {
    children?: React$1.ReactNode;
    value: string;
    className?: string;
}
declare const ZRUSegmentedControlItem: React$1.FC<IZRUSegmentedControlItem>;

interface ZRUSelectI extends ZRUShowable {
    children?: React$1.ReactNode;
    label?: string;
    asChild?: boolean;
    className?: string;
    labelClassName?: string;
    style?: Record<string, unknown>;
    size?: Responsive<'1' | '2' | '3'>;
    defaultOpen?: boolean;
    defaultValue?: string;
    autoComplete?: string;
    disabled?: boolean;
    name?: string;
    open?: boolean;
    required?: boolean;
    value?: string;
    isTouched?: boolean;
    errorMessage?: string;
    infoText?: string;
    triggerClassName?: string;
    onOpenChange?(open: boolean): void;
    onValueChange?(value: string): void;
    trigger?: {
        variant?: ZRUBasicVariantE;
        color?: ZRUColorE;
        radius?: ZRURadiusE;
        placeholder?: string;
        className?: string;
    } & ZRUMarginI;
    content?: {
        color?: ZRUColorE;
        highContrast?: boolean;
        position?: ZRUSelectContentPositionE;
    };
    options?: Array<ZRUSelectValueI>;
    labelOrientation?: ZRUOrientationE;
    position?: ZRUSelectContentPositionE;
    showLabelBtn?: boolean;
    labelBtnProps?: ZRUButtonI;
}
declare const ZRUSelect: React$1.FC<ZRUSelectI>;

interface ZRUSeparatorI {
    className?: string;
    style?: Record<string, unknown>;
    orientation?: Responsive<ZRUOrientationE>;
    size?: Responsive<"1" | "2" | "3" | "4">;
    color?: ZRUColorE;
    decorative?: boolean;
}
declare const ZRUSeparator: React$1.FC<ZRUSeparatorI>;

declare const ZRUSkeleton: React$1.FC<ZRUSkeletonI>;

interface ZRUSliderI {
    size?: Responsive<"1" | "2" | "3">;
    variant?: ZRUTriggerVariantE;
    color?: ZRUColorE;
    highContrast?: boolean;
    radius?: ZRURadiusE;
    className?: string;
    style?: Record<string, unknown>;
    value?: number[];
    defaultValue?: number[];
    onValueChange?(value: number[]): void;
    onBlur?: React$1.FocusEventHandler<HTMLDivElement>;
    name?: string;
    label?: string;
    required?: string;
    labelClassName?: string;
}
declare const ZRUSlider: React$1.FC<ZRUSliderI>;

interface ZRUSpinnerI {
    asChild?: boolean;
    className?: string;
    style?: Record<string, unknown>;
    size?: Responsive<"1" | "2" | "3">;
    loading?: boolean;
}
declare const ZRUSpinner: React$1.FC<ZRUSpinnerI>;

interface ZRUSwitchI {
    className?: string;
    style?: Record<string, unknown>;
    size?: Responsive<"1" | "2" | "3">;
    variant?: ZRUTriggerVariantE;
    color?: ZRUColorE;
    highContrast?: boolean;
    radius?: ZRURadiusE;
    checked?: boolean;
    defaultChecked?: boolean;
    onChange?: React$1.FormEventHandler<HTMLButtonElement>;
    onBlur?: React$1.FocusEventHandler<HTMLButtonElement>;
}
declare const ZRUSwitch: React$1.FC<ZRUSwitchI>;

interface IZRUTable extends ZRUShowable {
    children?: React$1.ReactNode;
    size?: Responsive<"1" | "2" | "3">;
    variant?: ZRUTableVariantE;
    layout?: ZRUTableLayoutE;
    lang?: string;
    className?: string;
    style?: Record<string, unknown>;
}
declare const ZRUTable: React$1.FC<IZRUTable>;

interface IZRUTableBody extends ZRUShowable {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
}
declare const ZRUTableBody: React$1.FC<IZRUTableBody>;

declare const ZRUCell: React$1.FC<IZRUColumnCell>;

declare const ZRUColumnHeaderCell: React$1.FC<IZRUColumnCell>;

interface IZRUTableHeader extends ZRUShowable {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
}
declare const ZRUTableHeader: React$1.FC<IZRUTableHeader>;

interface IZRUTableRow extends ZRUShowable {
    children?: React$1.ReactNode;
    className?: string;
    style?: Record<string, unknown>;
    align?: Responsive<ZRUTableRowAlignE>;
}
declare const ZRUTableRow: React$1.FC<IZRUTableRow>;

declare const ZRURowHeaderCell: React$1.FC<IZRUColumnCell>;

interface ZRUTextAreaI {
    className?: string;
    labelClassName?: string;
    textAriaClassName?: string;
    textAriaStyle?: Record<string, unknown>;
    style?: Record<string, unknown>;
    value?: string;
    size?: Responsive<"1" | "2" | "3">;
    variant?: ZRUTriggerVariantE;
    color?: ZRUColorE;
    name?: string;
    radius?: ZRURadiusE;
    required?: boolean;
    label?: string;
    placeholder?: string;
    rows?: number;
    isTouched?: boolean;
    errorMessage?: string;
    infoText?: string;
    onChange?: React$1.ChangeEventHandler<HTMLTextAreaElement>;
    onBlur?: React$1.FocusEventHandler<HTMLTextAreaElement>;
}
declare const ZRUTextArea: React$1.FC<ZRUTextAreaI>;

declare const configureZRTK: (options: {}) => void;

declare const ZCurrenciesData: Array<{
    value: string;
    label: string;
    symbol: string;
}>;

declare const NetworkDetectHOC: React.FC<{
    children: ReactNode;
    errorComponent?: {
        message?: string;
        showGoToHomeButton?: boolean;
        onClick?: React.MouseEventHandler<HTMLButtonElement>;
        btnText?: string;
    };
}>;

declare const ZGlobalComponentsHOC: React$1.FC;

declare const ZSafeAreaHOC: React.FC<{
    children: React.ReactNode;
}>;

declare const LoginPage$1: React$1.FC<{
    isProcessing?: boolean;
    onSubmit?: (values: LoginI, helpers: FormikHelpers<LoginI>) => void | Promise<void>;
    forgotBtnClickHandler?: React$1.MouseEventHandler<HTMLElement>;
    registerBtnClickHandler?: React$1.MouseEventHandler<HTMLElement>;
}>;

declare const LoginPage: React$1.FC<{
    isProcessing?: boolean;
    onSubmit?: (values: RegisterI, helpers: FormikHelpers<RegisterI>) => void | Promise<void>;
    loginBtnClickHandler?: React$1.MouseEventHandler<HTMLElement>;
}>;

declare const NotFound404Page: React$1.FC<{
    showHomeButton?: boolean;
    onClick?: React$1.MouseEventHandler<HTMLButtonElement>;
}>;

declare const ZSidebarRStateAtom: RecoilState<ZSidebarI>;
declare const ZPopoverRStateAtom: RecoilState<ZPopoverI>;

declare const ZUserRolesPermissionsRStateAtom: RecoilState<{
    permissions: Array<PermissionEnum> | null;
    roles: Array<RoleEnum> | null;
}>;

declare const defaultCurrency: {
    value: string;
    label: string;
    symbol: string;
};

declare const loginFormFields: {
    readonly email: {
        readonly type: ZRUInputTypeE.email;
        readonly placeholder: "Email";
    };
    readonly password: {
        readonly type: ZRUInputTypeE.password;
        readonly placeholder: "Password";
    };
};
declare const registerFormFields: {
    readonly passwordConfirmation: {
        readonly type: FormFieldsEnum.password;
        readonly placeholder: "Password Confirmation";
    };
    readonly email: {
        readonly type: ZRUInputTypeE.email;
        readonly placeholder: "Email";
    };
    readonly password: {
        readonly type: ZRUInputTypeE.password;
        readonly placeholder: "Password";
    };
    readonly name: {
        readonly type: ZRUInputTypeE.text;
        readonly placeholder: "Name";
    };
};
declare const userAccountDataFormFields: {
    readonly name: {
        readonly type: ZRUInputTypeE.text;
        readonly placeholder: "Name";
    };
};

declare const getRemainingTimeInMilliseconds: (tillDate?: string | Date | dayjs.Dayjs | number) => number;

declare const showNotification: (content: ToastContent, type?: ReactToastifyTypeEnum, options?: ToastOptions) => void;
declare const showSuccessNotification: (message?: ToastContent, options?: ToastOptions) => void;
declare const showErrorNotification: (message?: ToastContent, options?: ToastOptions) => void;

declare const useZSideBar: <T>({ component, props, width, containerClassName, containerStyle, }: {
    component: React.FC<any>;
    props?: ZGenericObject<T>;
    width?: string;
    containerClassName?: string;
    containerStyle?: React.CSSProperties;
}) => {
    openSidebar: () => void;
    closeSidebar: () => void;
};
declare const useZPopover: <T>({ component, componentProps, width, height, containerClassName, }: {
    component: React.FC<any>;
    width?: string;
    height?: string;
    containerClassName?: string;
    componentProps?: ZGenericObject<T>;
    onDidDismiss?: <P>(props?: P) => void;
}) => {
    showPopover: (showPopoverProps?: {
        componentProps?: ZGenericObject<T> | undefined;
        onDidDismiss?: (<P>(props?: P | undefined) => void) | undefined;
    }) => void;
    hidePopover: () => void;
};

declare const registerFormValidationSchema: z.ZodEffects<z.ZodObject<{
    name: z.ZodString;
    email: z.ZodString;
    password: z.ZodString;
    passwordConfirmation: z.ZodString;
}, "strip", z.ZodTypeAny, {
    name: string;
    email: string;
    password: string;
    passwordConfirmation: string;
}, {
    name: string;
    email: string;
    password: string;
    passwordConfirmation: string;
}>, {
    name: string;
    email: string;
    password: string;
    passwordConfirmation: string;
}, {
    name: string;
    email: string;
    password: string;
    passwordConfirmation: string;
}>;
declare const loginFormValidationSchema: z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>;

declare const userAccountFormValidationSchema: z.ZodObject<{
    name: z.ZodString;
}, "strip", z.ZodTypeAny, {
    name: string;
}, {
    name: string;
}>;

export { type ILoginFormData, type IRegisterFormData, type ISelectOption, type IZImage, type IZRUColumnCell, LoginFormFieldsEnum, type LoginI, LoginPage$1 as LoginPage, NetworkDetectHOC, NotFound404Page, ReactToastifyTypeEnum, RegisterFormFieldsEnum, type RegisterI, LoginPage as RegisterPage, type ResponsiveT, UserAccountDataFormFieldsEnum, ZRUAccordingGroup as ZAccordingGroup, ZRUAccordionContent as ZAccordionContent, ZRUAccordionItem as ZAccordionItem, ZRUAccordionTrigger as ZAccordionTrigger, ZAmount, ZAmountInput, ZAppLoader, ZRUAspectRatio as ZAspectRatio, ZRUAvatar as ZAvatar, ZRUBadge as ZBadge, ZRUBox as ZBox, ZRUButton as ZButton, ZRUCallout as ZCallout, ZCan, type ZCanI, ZRUCard as ZCard, ZRUCheckbox as ZCheckbox, ZRUCheckboxCardsGroup as ZCheckboxCardsGroup, ZRUCheckboxCardsItem as ZCheckboxCardsItem, ZRUCheckboxGroup as ZCheckboxGroup, ZRUCheckboxItem as ZCheckboxItem, ZClipboard, ZRUContainer as ZContainer, _default_1 as ZCountdown, ZCurrenciesData, type ZCurrencyI, ZRUDataList as ZDataList, ZRUDialog as ZDialog, ZRUDialogClose as ZDialogClose, ZRUDropdownMenu as ZDropdownMenu, ZRUDropdownMenuItem as ZDropdownMenuItem, ErrorBoundary as ZErrorBoundary, ZErrorText, ZFileDropUploader, ZRUFlex as ZFlex, ZFormActionButtons, ZFormModeE, ZFullPageCenteredMessage, FullPageLoader as ZFullPageLoader, type ZGenericObject, ZGlobalComponentsHOC, ZRUHeading as ZHeading, ZRUIconButton as ZIconButton, ZImage, ZRUInput as ZInput, ZRUInputSlot as ZInputSlot, ZLanguageSelector, ZRULink as ZLink, ZModal, ZNetworkDisconnected, ZNotFound, ZPage, ZPagination, ZPermissionCheckModeEnum, ZRUPopover as ZPopover, type ZPopoverI, ZPopoverRStateAtom, ZPrizeInput, type ZPrizeInputOnChange, type ZPrizeInputStateI, ZRUProgress as ZProgress, ZRCSelect, ZRSelect, type ZRSelectI, type ZRSelectOptions, ZRUAccordingTypeE, ZRUAlignE, ZRUAsE, type ZRUAspectRatioI, ZRUAvatarVariantE, ZRUBadgeVariantE, ZRUBasicVariantE, ZRUBoxDisplayE, type ZRUBoxI, type ZRUButtonI, ZRUCalloutVariantE, ZRUCellJustifyE, ZRUColorE, ZRUCommonVariantE, ZRUContainerDisplayE, ZRUDirectionE, ZRUDisplayE, ZRUGeneralAlignE, ZRUHeadingAsE, type ZRUInputI, ZRUInputTypeE, ZRUJustifyE, ZRULinkWeightE, type ZRUMarginI, type ZRUMarginT, ZRUOrientationE, ZRUOverflowE, type ZRUPaddingI, ZRUPositionE, type ZRURadioCardsGroupI, type ZRURadioCardsItemI, ZRURadiusE, ZRUScrollbarTypeE, ZRUScrollbarsE, ZRUSelectContentPositionE, type ZRUSelectValueI, type ZRUShowable, ZRUSideE, type ZRUSizeT, type ZRUSkeletonI, type ZRUStyleI, ZRUTableLayoutE, ZRUTableRowAlignE, ZRUTableVariantE, ZRUTextAsE, type ZRUTextSizeT, ZRUTriggerVariantE, ZRUTrimE, ZRUUnderlineLinkE, ZRUVariantE, ZRUWeightE, ZRUWrapE, ZRUWrapFlexE, ZRUWrapLinkE, ZRURadioCardList as ZRadioCardList, ZRURadioCardsGroup as ZRadioCardsGroup, ZRURadioCardsItem as ZRadioCardsItem, ZRURadioGroup as ZRadioGroup, ZRURadioItem as ZRadioItem, ZSafeAreaHOC, ZRUScrollArea as ZScrollArea, ZRUSegmentedControl as ZSegmentedControl, ZRUSegmentedControlItem as ZSegmentedControlItem, ZRUSelect as ZSelect, ZRUSeparator as ZSeparator, type ZSidebarI, ZSidebarRStateAtom, ZRUSkeleton as ZSkeleton, ZRUSlider as ZSlider, ZRUSpinner as ZSpinner, ZRUSwitch as ZSwitch, ZRUTable as ZTable, ZRUTableBody as ZTableBody, ZRUCell as ZTableCell, ZRUColumnHeaderCell as ZTableColumnHeaderCell, ZRUTableHeader as ZTableHeader, ZRUTableRow as ZTableRow, ZRURowHeaderCell as ZTableRowHeaderCell, ZRUText as ZText, ZRUTextArea as ZTextArea, ZUserAvatar, ZUserRolesPermissionsRStateAtom, configureZRTK, defaultCurrency, getRemainingTimeInMilliseconds, loginFormFields, loginFormValidationSchema, registerFormFields, registerFormValidationSchema, showErrorNotification, showNotification, showSuccessNotification, useZPopover, useZSideBar, userAccountDataFormFields, userAccountFormValidationSchema };