import * as React$1 from 'react';
import React__default, { ReactNode, HTMLAttributes } from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as react_hook_form from 'react-hook-form';
import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
import * as _socket_io_component_emitter from '@socket.io/component-emitter';
import { Socket } from 'socket.io-client';
import { ColumnDef, SortingState, ColumnFiltersState, RowData } from '@tanstack/react-table';
import * as z from 'zod';
import { z as z$1 } from 'zod';
import * as react_to_print from 'react-to-print';
import { UploadFile } from 'antd';
import * as zustand from 'zustand';
import * as react_router from 'react-router';
import dayjs from 'dayjs';

interface ButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
    variant?: "primary" | "secondary" | "outline" | "ghost" | "danger" | "warning";
    size?: "sm" | "md" | "lg";
    isLoading?: boolean;
    icon?: React__default.ReactNode;
}
declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;

interface InfoItem {
    label: string;
    value: React__default.ReactNode;
    /** Use monospace font for the value (useful for account numbers, IDs, etc.) */
    mono?: boolean;
}
interface InfoGridProps {
    items: InfoItem[];
    /** Grid columns count, defaults to 3 */
    cols?: number;
    /** Optional container class */
    className?: string;
    isLoading?: boolean;
}
/**
 * InfoGrid Component
 *
 * A clean, rounded grid container for displaying key information items
 * with labels and values.
 */
declare const InfoGrid: React__default.FC<InfoGridProps>;

/**
 * Props for the PageA4 component
 */
interface PageA4Props {
    /** The content to render inside the A4 page */
    children: React__default.ReactNode;
    /** Optional container class for the outer document viewer wrapper */
    className?: string;
    /** Optional class for the paper itself */
    pageClassName?: string;
    /** Optional page number for the footer */
    pageNumber?: number;
    /** Optional total pages for the footer */
    totalPages?: number;
    /** Whether this is the final page being printed */
    isLastPage?: boolean;
}
/**
 * PageA4 Component
 *
 * A reusable React component that renders its children inside a container that always
 * maintains an exact A4 paper width (210mm).
 *
 * It scales down proportionally on smaller screens.
 */
declare const PageA4: React__default.FC<PageA4Props>;

interface NavItem {
    label: string;
    icon?: React__default.ReactNode;
    path?: string;
    subItems?: (NavItem | false | null | undefined)[];
    hidden?: boolean;
    disabled?: boolean;
}
type NavItems = (NavItem | false | null | undefined)[];
interface DashboardLayoutProps {
    children: React__default.ReactNode;
    navItems: NavItems;
    title?: string;
    logo?: React__default.ReactNode | string;
    userProfile?: React__default.ReactNode;
    fontFamily?: string;
    sidebarFooter?: React__default.ReactNode;
}
declare const DashboardLayout: React__default.FC<DashboardLayoutProps>;

declare const ThemeToggle: React__default.FC<{
    className?: string;
}>;

interface ThemeContextType {
    isDarkMode: boolean;
    toggleTheme: () => void;
    setTheme: (theme: "light" | "dark") => void;
}
declare const ThemeProvider: ({ children }: {
    children: ReactNode;
}) => react_jsx_runtime.JSX.Element;
declare const useTheme: () => ThemeContextType;

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

interface LoadingSpinProps extends React__default.SVGAttributes<SVGSVGElement> {
    className?: string;
    size?: "sm" | "md" | "lg";
    color?: string;
}
declare const LoadingSpin: ({ className, size, color, ...props }: LoadingSpinProps) => react_jsx_runtime.JSX.Element;

declare const ClassicSpin: ({ msg }: {
    msg?: string;
}) => react_jsx_runtime.JSX.Element;

declare const OverlaySpin: ({ msg }: {
    msg?: string;
}) => react_jsx_runtime.JSX.Element;

interface CodeBlockProps {
    code: string;
    language?: string;
    className?: string;
}
declare const CodeBlock: React__default.FC<CodeBlockProps>;

interface CardProps extends React__default.HTMLAttributes<HTMLDivElement> {
    children: React__default.ReactNode;
    variant?: "default" | "flat" | "glass";
    isLoading?: boolean;
    loadingText?: string;
}
declare const Card: {
    ({ children, className, variant, isLoading, loadingText, ...props }: CardProps): react_jsx_runtime.JSX.Element;
    Header: ({ children, className, }: {
        children: React__default.ReactNode;
        className?: string;
    }) => react_jsx_runtime.JSX.Element;
    Title: ({ children, className, }: {
        children: React__default.ReactNode;
        className?: string;
    }) => react_jsx_runtime.JSX.Element;
    Description: ({ children, className, }: {
        children: React__default.ReactNode;
        className?: string;
    }) => react_jsx_runtime.JSX.Element;
    Content: ({ children, className, }: {
        children: React__default.ReactNode;
        className?: string;
    }) => react_jsx_runtime.JSX.Element;
    Footer: ({ children, className, }: {
        children: React__default.ReactNode;
        className?: string;
    }) => react_jsx_runtime.JSX.Element;
};
declare const CardHeader: ({ children, className, }: {
    children: React__default.ReactNode;
    className?: string;
}) => react_jsx_runtime.JSX.Element;
declare const CardTitle: ({ children, className, }: {
    children: React__default.ReactNode;
    className?: string;
}) => react_jsx_runtime.JSX.Element;
declare const CardDescription: ({ children, className, }: {
    children: React__default.ReactNode;
    className?: string;
}) => react_jsx_runtime.JSX.Element;
declare const CardContent: ({ children, className, }: {
    children: React__default.ReactNode;
    className?: string;
}) => react_jsx_runtime.JSX.Element;
declare const CardFooter: ({ children, className, }: {
    children: React__default.ReactNode;
    className?: string;
}) => react_jsx_runtime.JSX.Element;

interface ModalProps {
    isOpen: boolean;
    onClose: () => void;
    title: React__default.ReactNode;
    children: React__default.ReactNode;
    isLoading?: boolean;
    width?: number;
    closeOnOverlayClick?: boolean;
}
declare const Modal: React__default.FC<ModalProps>;

interface ConfirmModalProps {
    /**
     * The trigger component that will open the modal when clicked.
     */
    children: React__default.ReactNode;
    /**
     * Title shown at the top of the modal.
     */
    title: string;
    /**
     * Detailed message describing the action being confirmed.
     */
    description: React__default.ReactNode;
    /**
     * The word the user must type to enable the confirm button.
     * @default "delete"
     */
    confirmationWord?: string;
    /**
     * Callback fired when the cancel button is clicked or the modal is closed.
     */
    onCancel?: () => void | Promise<void>;
    /**
     * Async function called when the user confirms.
     * If it resolves, the modal closes automatically (unless it explicitly returns false).
     * If it rejects, the modal stays open.
     */
    onSubmit: () => Promise<void | boolean>;
    /**
     * Label for the confirm button.
     * @default "Confirm"
     */
    confirmButtonText?: string;
    /**
     * Label for the cancel button.
     * @default "Cancel"
     */
    cancelButtonText?: string;
    /**
     * Visual variant of the confirm button.
     * @default "danger"
     */
    variant?: "danger" | "primary" | "warning";
    /**
     * Width of the modal in pixels.
     * @default 500
     */
    width?: number;
    /**
     * Optional controlled open state.
     */
    isOpen?: boolean;
    /**
     * Optional controlled close handler.
     */
    onClose?: () => void;
    /**
     * Optional loading state.
     */
    isLoading?: boolean;
}
/**
 * A reusable confirmation modal component that wraps any element and triggers
 * a confirmation dialog with a required word input (e.g. for destructive actions).
 */
declare const ConfirmModal: React__default.FC<ConfirmModalProps>;

interface PageHeaderProps {
    title: string;
    description?: string;
    children?: React__default.ReactNode;
    className?: string;
}
declare const PageHeader: ({ title, description, children, className, }: PageHeaderProps) => react_jsx_runtime.JSX.Element;

interface UseModalReturn {
    isOpen: boolean;
    open: () => void;
    close: () => void;
    toggle: () => void;
    openState: (data: defaultStateT) => void;
    state: defaultStateT;
    Modal: () => JSX.Element | null;
    resetState: () => void;
    defaultState: defaultStateT;
}
type defaultStateT = {
    type: string | null;
    title: string;
    content: React.ReactNode;
    width: number;
    data?: any;
    closeOnOverlayClick?: boolean;
};
declare const useModal: (initialState?: boolean) => UseModalReturn;

interface DateInputProps$1<T extends FieldValues> {
    label?: string;
    error?: string;
    containerClassName?: string;
    name?: Path<T>;
    form?: UseFormReturn<T>;
    [key: string]: any;
}

interface DateInputProps<T extends FieldValues> {
    label?: string;
    error?: string;
    containerClassName?: string;
    name?: Path<T>;
    form?: UseFormReturn<T>;
    [key: string]: any;
}
declare const DateInput: <T extends FieldValues>(props: DateInputProps<T> & {
    ref?: React.ForwardedRef<HTMLInputElement>;
}) => React.ReactElement;

interface SearchApiProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value"> {
    label?: string;
    api?: string;
    placeholder?: string;
    value?: any;
    onChange?: (value: any) => void;
    onSelect?: (option: any) => void;
    onClear?: () => void;
    queryKey?: string;
    labelKey?: string;
    valueKey?: string;
    error?: string;
    containerClassName?: string;
    name?: any;
    form?: any;
    obj?: any;
    filter?: any[];
    v?: number;
    variant?: "ghost" | "default";
    children?: ReactNode;
}
interface SearchApiContextValue {
    isOpen: boolean;
    setIsOpen: (v: boolean) => void;
    searchTerm: string;
    setSearchTerm: (v: string) => void;
    selectedValue: any;
    setSelectedValue: (v: any) => void;
    onSelect?: (option: any) => void;
    onClear?: () => void;
    activeIndex: number;
    setActiveIndex: (v: number) => void;
    isFocused: boolean;
    setIsFocused: (v: boolean) => void;
    dropdownAnchorRef: React__default.RefObject<HTMLDivElement>;
    dropdownContentRef: React__default.RefObject<HTMLDivElement>;
    containerRef: React__default.RefObject<HTMLDivElement>;
    inputRef: React__default.RefObject<HTMLInputElement>;
    primaryColor?: string;
    error?: string;
    disabled?: boolean;
    fieldInternalProps?: any;
    options: any[];
    setOptions: (opts: any[]) => void;
    isLoading: boolean;
    clearSelection: (e: React__default.MouseEvent | any) => void;
    handleSelect: (opt: any) => void;
    getDisplayValue: () => string;
    placeholder?: string;
    variant?: string;
    labelKey: string;
    valueKey: string;
    form?: any;
    name?: any;
    obj?: any;
}
declare const useSearchApiContext: () => SearchApiContextValue;
declare const SearchApi: React__default.ForwardRefExoticComponent<SearchApiProps & React__default.RefAttributes<HTMLDivElement>>;
declare const SearchApiTrigger: React__default.ForwardRefExoticComponent<Omit<any, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
declare const SearchApiInput: React__default.ForwardRefExoticComponent<Omit<any, "ref"> & React__default.RefAttributes<HTMLInputElement>>;
declare const SearchApiContent: React__default.ForwardRefExoticComponent<Omit<any, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
declare const SearchApiItem: React__default.ForwardRefExoticComponent<Omit<any, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;

interface TextareaProps<T extends FieldValues> extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "name" | "form"> {
    label: string;
    error?: string;
    containerClassName?: string;
    name?: Path<T>;
    form?: UseFormReturn<T>;
}
declare const Textarea: <T extends FieldValues>(props: TextareaProps<T> & {
    ref?: React.ForwardedRef<HTMLTextAreaElement>;
}) => React.ReactElement;

declare const Enums: {
    roles: readonly ["admin", "staff", "manager"];
    sex: readonly ["male", "female"];
    accountTypes: readonly ["employee", "supplier", "customer", "amaanah", "account"];
    verificationTypes: readonly ["email_verification", "password_reset"];
    auditActions: readonly ["create", "update", "delete", "login", "logout"];
    walletTypes: readonly ["bank", "cash", "mobile"];
    currencies: readonly ["USD", "TZS", "KES", "RMB", "AED"];
    packTypes: readonly ["pressure", "bag", "boxes"];
    journalTypes: readonly ["journal"];
    viaTypes: readonly ["direct", "via account"];
    actionTypes: readonly ["credit", "debit"];
    transactionTypes: readonly ["journal", "payment", "money transfer", "expense", "adjustment", "forex transfer", "stock", "forex dubai to china", "forex", "forex expense", "lease", "expense account"];
    stockTypes: readonly ["pack", "product"];
    saleStockTypes: readonly ["pack", "product"];
    sale: readonly ["cash", "credit"];
    stockTransferTypes: readonly ["pack", "product", "pack to product"];
    forexTypes: readonly ["direct", "exchange", "supplier exchange"];
    branchTypes: readonly ["shop", "store", "office", "apartment", "website"];
    documentTypes: readonly ["none", "id", "passport", "license"];
    whatsappMessageTypes: readonly ["greeting", "payment", "invoice"];
    whatsappMessageStatuses: readonly ["queued", "sent", "delivered", "read", "failed", "undelivered"];
    webhookProviders: readonly ["twilio-whatsapp"];
    messageTypes: readonly ["whatsapp"];
    leaseTypes: readonly ["sale", "rent"];
    leaseAction: readonly ["journal", "payment"];
    expenseAccount: readonly ["branch", "account"];
    integrationTypes: readonly ["twilio-whatsapp"];
    postTypes: readonly ["umrah", "hajj", "visa", "hotel"];
    postStatus: readonly ["draft", "published", "archived"];
};

interface ThemeConfig {
    primaryColor?: string;
    inputHeight?: string;
}
interface StoreConfig {
    name?: string;
    address?: string;
    phone?: string;
    email?: string;
    logo?: string;
}
type apiConfig = {
    accountStatementApi?: string;
    walletReportApi?: string;
    stockLevelReportApi?: string;
    itemStockLevelReportApi?: string;
    profitAndLossReportApi?: string;
    forexAccountApi?: string;
    realestateAccountApi?: string;
    accountReportApi?: string;
};
type EnumsConfig = {
    [K in keyof typeof Enums]: string[] | readonly string[];
};
interface WarqadConfig {
    api?: string;
    socketUrl?: string;
    apiConfig?: apiConfig;
    theme?: ThemeConfig;
    store?: StoreConfig;
    enums?: Partial<EnumsConfig>;
    currencies?: {
        [key: string]: string;
    };
    application?: string;
    customUrlBreadcrumbs?: (params: {
        id: string;
        profile: string;
        prevprofile: string;
        typeProfile: string;
        defaultUrl: string;
        params?: (key?: string) => any;
        query?: (key?: string) => any;
    }) => {
        finalUrl: string;
    };
    firebase?: {
        apiKey?: string;
        authDomain?: string;
        projectId?: string;
        storageBucket?: string;
        messagingSenderId?: string;
        appId?: string;
        measurementId?: string;
        folder?: string;
    };
}
interface WarqadConfigContextType {
    config: WarqadConfig & {
        api: string;
        apiConfig: Required<apiConfig>;
        theme: Required<ThemeConfig>;
        store: Required<StoreConfig>;
        enums: EnumsConfig;
        currencies: {
            [key: string]: string;
        };
    };
    socket?: Socket;
}
/**
 * Hook to access the current Warqad configuration.
 */
declare const useWarqadConfig: () => WarqadConfig & {
    api: string;
    apiConfig: Required<apiConfig>;
    theme: Required<ThemeConfig>;
    store: Required<StoreConfig>;
    enums: EnumsConfig;
    currencies: {
        [key: string]: string;
    };
};
/**
 * Hook to access the current Warqad socket connection.
 */
declare const useWarqadSocket: () => Socket<_socket_io_component_emitter.DefaultEventsMap, _socket_io_component_emitter.DefaultEventsMap> | undefined;
interface WarqadProviderProps {
    children: ReactNode;
    config?: WarqadConfig;
}
/**
 * WarqadProvider
 *
 * Provides configuration and theme values to the entire application.
 */
declare const WarqadProvider: ({ children, config }: WarqadProviderProps) => react_jsx_runtime.JSX.Element;

interface Option {
    value: string | number | boolean;
    label: string;
    disabled?: boolean;
}
interface SelectProps extends Omit<React__default.SelectHTMLAttributes<HTMLSelectElement>, "onChange" | "value"> {
    label?: string;
    options?: Option[];
    icon?: React__default.ReactNode;
    error?: string;
    containerClassName?: string;
    name?: any;
    form?: any;
    onChange?: (value: any) => void;
    value?: any;
    variant?: "ghost" | "default";
    children?: ReactNode;
    enum?: string[] | readonly string[];
    enumName?: keyof EnumsConfig;
    showSearch?: boolean;
}
interface SelectContextValue {
    isOpen: boolean;
    setIsOpen: (val: boolean) => void;
    selectedValue: any;
    setSelectedValue: (val: any) => void;
    activeIndex: number;
    setActiveIndex: (val: number) => void;
    isFocused: boolean;
    setIsFocused: (val: boolean) => void;
    dropdownAnchorRef: React__default.RefObject<HTMLDivElement>;
    dropdownContentRef: React__default.RefObject<HTMLDivElement>;
    containerRef: React__default.RefObject<HTMLDivElement>;
    primaryColor?: string;
    options: Option[];
    registerOption: (opt: Option) => void;
    fieldInternalProps?: any;
    disabled?: boolean;
    searchQuery: string;
    setSearchQuery: (val: string) => void;
    showSearch?: boolean;
}
declare const useSelectContext: () => SelectContextValue;
declare const Select: React__default.ForwardRefExoticComponent<SelectProps & React__default.RefAttributes<HTMLDivElement>>;
declare const SelectTrigger: React__default.ForwardRefExoticComponent<Omit<any, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
declare const SelectContent: React__default.ForwardRefExoticComponent<Omit<any, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
declare const SelectItem: React__default.ForwardRefExoticComponent<Omit<any, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;

interface PhoneInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange"> {
    label: string;
    icon?: React.ReactNode;
    error?: string;
    containerClassName?: string;
    name?: any;
    form?: any;
    onChange?: (value: string) => void;
    value?: string;
}
declare const PhoneInput: React$1.ForwardRefExoticComponent<PhoneInputProps & React$1.RefAttributes<any>>;

interface InputProps<T extends FieldValues> extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "name" | "form" | "onChange"> {
    label?: string;
    icon?: React.ReactNode;
    error?: string;
    containerClassName?: string;
    name?: Path<T>;
    form?: UseFormReturn<T>;
    type?: "text" | "number" | "email" | "password";
    variant?: "ghost" | "default";
    onChange?: (value: any) => void;
}
declare const Input: <T extends FieldValues>(props: InputProps<T> & {
    ref?: React.ForwardedRef<HTMLInputElement>;
}) => React.ReactElement;

declare const Fields: {
    Input: <T extends react_hook_form.FieldValues>(props: InputProps<T> & {
        ref?: React.ForwardedRef<HTMLInputElement>;
    }) => React.ReactElement;
    PhoneInput: React$1.ForwardRefExoticComponent<PhoneInputProps & React$1.RefAttributes<any>>;
    Select: React$1.ForwardRefExoticComponent<SelectProps & React$1.RefAttributes<HTMLDivElement>>;
    SelectTrigger: React$1.ForwardRefExoticComponent<Omit<any, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
    SelectContent: React$1.ForwardRefExoticComponent<Omit<any, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
    SelectItem: React$1.ForwardRefExoticComponent<Omit<any, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
    Textarea: <T extends react_hook_form.FieldValues>(props: TextareaProps<T> & {
        ref?: React.ForwardedRef<HTMLTextAreaElement>;
    }) => React.ReactElement;
    SearchApi: React$1.ForwardRefExoticComponent<SearchApiProps & React$1.RefAttributes<HTMLDivElement>>;
    SearchApiTrigger: React$1.ForwardRefExoticComponent<Omit<any, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
    SearchApiInput: React$1.ForwardRefExoticComponent<Omit<any, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
    SearchApiContent: React$1.ForwardRefExoticComponent<Omit<any, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
    SearchApiItem: React$1.ForwardRefExoticComponent<Omit<any, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
    DateInput: <T extends react_hook_form.FieldValues>(props: DateInputProps<T> & {
        ref?: React.ForwardedRef<HTMLInputElement>;
    }) => React.ReactElement;
    MonthInput: <T extends react_hook_form.FieldValues>(props: DateInputProps$1<T> & {
        ref?: React.ForwardedRef<HTMLInputElement>;
    }) => React.ReactElement;
};

type DataTableColumn<TData = any, TValue = any> = ColumnDef<TData, TValue> & {
    key?: string;
    hide?: boolean;
};
interface DataTableProps<TData, TValue> {
    columns: DataTableColumn<TData, TValue>[];
    data: TData[];
    isLoading?: boolean;
    pageRows?: number;
    searchPlaceholder?: string;
    className?: string;
    verticalLines?: boolean;
    verclines?: boolean;
    rowPadding?: string;
    index?: boolean;
    renderSubComponent?: (props: {
        row: TData;
        index: number;
    }) => React__default.ReactNode;
    hasSubComponent?: (row: TData) => boolean;
    defaultExpanded?: boolean;
    onChange?: (state: {
        pagination: {
            pageIndex: number;
            pageSize: number;
            pageCount: number;
        };
        sorting: SortingState;
        columnFilters: ColumnFiltersState;
        globalFilter: string;
        selectedRows: TData[];
        filteredData: TData[];
    }) => void;
    selectable?: boolean;
    filterables?: boolean;
    emptyState?: React__default.ReactNode;
}
declare function DataTable<TData, TValue>({ columns: userColumns, data, isLoading, pageRows, searchPlaceholder, className, verticalLines: userVerticalLines, verclines, rowPadding, index, renderSubComponent, hasSubComponent, // default to true
defaultExpanded, onChange, selectable, filterables, emptyState, }: DataTableProps<TData, TValue>): react_jsx_runtime.JSX.Element;

declare module "@tanstack/react-table" {
    interface ColumnMeta<TData extends RowData, TValue> {
        className?: string;
        width?: string | number;
        field?: (props: {
            value: any;
            onChange: (value: any) => void;
            rowData: Partial<TData>;
            setRowData: (data: Partial<TData>) => void;
        }) => React__default.ReactNode;
    }
}
interface PostTableActions {
    focus: (columnId: string) => void;
    setError: (columnId: string, error: boolean | string) => void;
}
interface PostTableChangeParams<TData> {
    entryData: Partial<TData>;
    actions: PostTableActions;
    actionType: "add" | "edit" | "delete";
    fullData: TData[];
}
interface PostTableProps<TData> {
    columns: (ColumnDef<TData, any> & {
        key?: string;
    })[];
    data?: TData[];
    onChange?: (params: PostTableChangeParams<TData>) => void | Promise<void | boolean>;
    isLoading?: boolean;
    className?: string;
    verticalLines?: boolean;
    verclines?: boolean;
    rowPadding?: string;
    index?: boolean;
    renderAddButton?: (entryData: Partial<TData>, handleSaveField: () => void, isSaving: boolean) => React__default.ReactNode;
    renderSubComponent?: (props: {
        row: TData;
        index: number;
    }) => React__default.ReactNode;
    hasSubComponent?: (row: TData) => boolean;
    defaultExpanded?: boolean;
    submitLoading?: boolean;
    onCancel?: () => void;
    onEdit?: (row: TData) => void;
    onDelete?: (row: TData) => void;
}
declare function PostTable<TData extends Record<string, any>>({ columns: userColumns, data: controlledData, onChange, isLoading, className, verticalLines: userVerticalLines, verclines, rowPadding, index, renderAddButton, renderSubComponent, hasSubComponent, // default to true if renderSubComponent is provided
defaultExpanded, submitLoading, onCancel, onEdit, onDelete, }: PostTableProps<TData>): react_jsx_runtime.JSX.Element;

type SimpleTableColumn<TData> = ColumnDef<TData, any> & {
    key?: string;
    render?: (row: TData) => React__default.ReactNode;
    renderFooter?: (data: TData[]) => React__default.ReactNode;
    className?: string;
    width?: number | string;
    minWidth?: number | string;
    maxWidth?: number | string;
    flex?: number;
    hide?: boolean;
    searchKeys?: string[];
};
interface SimpleTableProps<TData> {
    columns: SimpleTableColumn<TData>[];
    data: TData[];
    className?: string;
    renderFooter?: () => React__default.ReactNode;
    rowPadding?: string;
    verticalLines?: boolean;
    verclines?: boolean;
    index?: boolean;
    startIndex?: number;
    isLoading?: boolean;
    title?: string;
    enableSearch?: boolean;
    emptyState?: React__default.ReactNode;
    skeletonCount?: number;
    fixed?: boolean;
    onRowClick?: (row: TData) => void;
    onRowDoubleClick?: (row: TData) => void;
}
declare function SimpleTable<TData>({ columns: userColumns, data, className, renderFooter: componentFooter, rowPadding, verticalLines: userVerticalLines, verclines, index, startIndex, isLoading, title, enableSearch, emptyState, skeletonCount, fixed, onRowClick, onRowDoubleClick, }: SimpleTableProps<TData>): react_jsx_runtime.JSX.Element;

interface SummaryColumn<T> {
    title: React__default.ReactNode;
    key?: string;
    render?: (row: T, index: number) => React__default.ReactNode;
    className?: string;
}
interface SummaryTableProps<T> {
    title?: string;
    columns: SummaryColumn<T>[];
    data: T[];
    className?: string;
    isLoading?: boolean;
    verclines?: boolean;
}
declare function SummaryTable<T>({ title, columns, data, className, isLoading, verclines, }: SummaryTableProps<T>): react_jsx_runtime.JSX.Element;

interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
    variant?: "primary" | "danger" | "warning" | "success";
    size?: "sm" | "md" | "lg";
    outline?: boolean;
}
declare const Badge: React__default.ForwardRefExoticComponent<BadgeProps & React__default.RefAttributes<HTMLSpanElement>>;

interface BrandingProps {
    /**
     * The text to display.
     */
    text: string;
    /**
     * Whether the component is disabled.
     */
    disabled?: boolean;
    /**
     * Additional class names.
     */
    className?: string;
}
declare const Branding: React__default.FC<BrandingProps>;

interface ProfileCardProps {
    name: string;
    role?: string;
    image?: string;
    details: Record<string, string | number | undefined | null>;
    backUrl?: string;
    className?: string;
}
declare const ProfileCard: React__default.FC<ProfileCardProps>;

interface ProfileViewInfoItem {
    label: string;
    value: string | number | undefined | null;
    copiable?: boolean;
}
interface ProfileViewProps {
    name: string;
    role?: string;
    email?: string;
    imgUrl?: string;
    userId?: string;
    info?: ProfileViewInfoItem[];
    className?: string;
    title?: string;
    description?: string;
}
declare const ProfileView: React__default.FC<ProfileViewProps>;

type LoginTheme = "tech" | "travel" | "healthcare";
interface BaseLoginProps {
    form: UseFormReturn<LoginSchema>;
    onSubmit: (data: LoginSchema, form: UseFormReturn<LoginSchema>) => void;
    image?: string;
    theme?: LoginTheme;
    title?: string;
    subtitle?: string;
    heroTitle?: React__default.ReactNode;
    heroSubtitle?: React__default.ReactNode;
    logo?: React__default.ReactNode;
    footer?: React__default.ReactNode;
    brandName?: string;
    backUrl?: string;
    isLoading?: boolean;
}
declare const ThemedLogin: React__default.FC<BaseLoginProps>;

declare const defaultLoginSchema: z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>;
type LoginSchema = z.infer<typeof defaultLoginSchema>;
interface UseLoginProps {
    theme?: LoginTheme;
    image?: string;
    schema?: z.ZodType<any, any, any>;
    defaultValues?: any;
    onSubmit: (data: any, form: UseFormReturn<LoginSchema>) => void;
    brandName?: string;
    title?: string;
    subtitle?: string;
    heroTitle?: React__default.ReactNode;
    heroSubtitle?: React__default.ReactNode;
    backUrl?: string;
    isLoading?: boolean;
}
declare const useLogin: (props: UseLoginProps) => {
    form: UseFormReturn<{
        email: string;
        password: string;
    }, any, {
        email: string;
        password: string;
    }>;
    Login: React__default.FC<{}>;
};

interface DropdownItem {
    label: React__default.ReactNode;
    icon?: React__default.ReactNode;
    onClick?: () => void | Promise<void>;
    disabled?: boolean;
    loading?: boolean;
    className?: string;
    variant?: "default" | "danger";
}
interface DropdownProps {
    children: React__default.ReactNode;
    items: DropdownItem[];
    className?: string;
    menuClassName?: string;
    triggerMode?: "click" | "hover";
    align?: "left" | "right";
    width?: string;
    onOpenChange?: (isOpen: boolean) => void;
}
declare const Dropdown: React__default.FC<DropdownProps>;

interface ProfileDropdownItem extends DropdownItem {
}
interface ProfileDropdownProps {
    name: string;
    image?: string;
    items: ProfileDropdownItem[];
    className?: string;
    triggerMode?: "click" | "hover";
    size?: "sm" | "md" | "lg";
    role?: string;
}
declare const ProfileDropdown: React__default.FC<ProfileDropdownProps>;

interface FetchProps {
    url: string;
    body?: Record<string, any>;
    v?: 0 | 1 | 2;
    params?: Record<string, any>;
    delay?: number;
    form?: {
        setError: (field: string, error: {
            message: string;
        }) => void;
    };
    multipart?: boolean;
}
type FetchFunction = (props: Omit<FetchProps, "body">) => Promise<any>;
type PostFunction = (props: FetchProps) => Promise<any>;
type PutFunction = (props: FetchProps) => Promise<any>;
type DeleteFunction = (props: Omit<FetchProps, "body">) => Promise<any>;
declare const useApi: () => {
    data: any;
    error: string | null;
    isLoading: boolean;
    pdfLoading: boolean;
    get: FetchFunction;
    post: PostFunction;
    put: PutFunction;
    remove: DeleteFunction;
    fetchPdf: ({ url, v, method, body, }: FetchProps & {
        method: "GET" | "POST";
    }) => Promise<{
        ok: boolean;
        message: string;
        errors: never[];
        data?: undefined;
    } | {
        ok: boolean;
        data: string;
        message?: undefined;
        errors?: undefined;
    } | {
        ok: boolean;
        message: any;
        errors?: undefined;
        data?: undefined;
    }>;
};

declare const useA4StatementView: ({ url, v, delay, params, startPage, }?: {
    url?: string;
    v?: 0 | 1 | 2;
    delay?: number;
    params?: Record<string, any>;
    startPage?: number;
}) => {
    A4DataView: ({ columns, data, error, info, index, title, subtitle, printable, rowPadding, verticalLines, headers, tableTitle, startPage: componentStartPage, isLoading: externalLoading, fixed, onRowClick, onRowDoubleClick, }: {
        tableTitle?: string;
        columns?: SimpleTableColumn<any>[];
        data?: any[];
        error?: string | null;
        info?: any[];
        index?: boolean;
        title?: string;
        subtitle?: string;
        printable?: boolean;
        rowPadding?: string;
        verticalLines?: boolean;
        headers?: React.ReactNode;
        startPage?: number;
        isLoading?: boolean;
        fixed?: boolean;
        onRowClick?: (row: any) => void;
        onRowDoubleClick?: (row: any) => void;
    }) => react_jsx_runtime.JSX.Element;
    data: any;
    isLoading: boolean;
    get: FetchFunction;
    reactToPrintFn: react_to_print.UseReactToPrintFn;
    reload: () => Promise<void>;
};

declare const useA4CategoryView: ({ url, v, delay, params, startPage, }?: {
    url?: string;
    v?: 0 | 1 | 2;
    delay?: number;
    params?: Record<string, any>;
    startPage?: number;
}) => {
    A4CategoryView: ({ data, groups: incomingGroups, error, info, title, subtitle, printable, gridTitle, startPage: componentStartPage, isLoading: externalLoading, renderItem, gridColumns, }: {
        gridTitle?: string;
        data?: any[];
        groups?: {
            title: string;
            items: any[];
        }[];
        error?: string | null;
        info?: any[];
        title?: string;
        subtitle?: string;
        printable?: boolean;
        startPage?: number;
        isLoading?: boolean;
        renderItem: (item: any) => React.ReactNode;
        gridColumns?: number;
    }) => react_jsx_runtime.JSX.Element;
    data: any;
    isLoading: boolean;
    get: FetchFunction;
    reactToPrintFn: react_to_print.UseReactToPrintFn;
};

declare const useTransaction: ({ url, v, delay, params, dateFilter, }: {
    url: string;
    v?: 0 | 1 | 2;
    delay?: number;
    params?: Record<string, any>;
    dateFilter?: boolean;
}) => {
    TransactionViewComponent: ({ columns, data, error, pageRows, searchPlaceholder, selectable, filterables, verticalLines, index, rowPadding, className, title, description, showReload, onCreate, createTitle, headers, ...rest }: {
        columns: DataTableColumn[];
        data: any[];
        error?: any;
        pageRows?: number;
        searchPlaceholder?: string;
        selectable?: boolean;
        filterables?: boolean;
        verticalLines?: boolean;
        index?: boolean;
        rowPadding?: string;
        className?: string;
        title?: string;
        description?: string;
        showReload?: boolean;
        onCreate?: () => void;
        createTitle?: string;
        headers?: React.ReactNode;
    }) => react_jsx_runtime.JSX.Element;
    data: any;
    isLoading: boolean;
    get: FetchFunction;
    reload: () => Promise<any>;
    error: string | null;
    date: String | null | undefined;
    openPos: (datas: {
        data: any;
        columns: any;
        type: "payment" | "sale";
        title: string;
        printerType: "80mm";
        delivery?: boolean;
    }) => void;
    PosPrinter: () => react_jsx_runtime.JSX.Element;
};

interface PdfOptions {
    orientation?: "portrait" | "landscape";
    unit?: "mm" | "cm" | "in" | "px";
    format?: string | number[];
    filename?: string;
    margin?: number;
    windowWidth?: number;
    scale?: number;
    showPageNumbers?: boolean;
}
/**
 * Generates a text-based, searchable PDF from a DOM element.
 *
 * @param elementId The ID of the element to capture
 * @param options PDF generation options
 */
declare const generatePdf: (elementId: string, options?: PdfOptions) => Promise<void>;

/**
 * A robust localStorage manager utility with TypeScript support.
 * Suitable for production environments and reusable frontend packages.
 */
/**
 * Interface for the storage utility to support method overloads.
 */
interface StorageManager {
    /** Saves a value to localStorage using JSON.stringify. */
    set<T>(key: string, value: T): void;
    /** Retrieves a parsed value from localStorage. */
    get<T>(key: string): T | null;
    /** Retrieves all items from localStorage as an object. */
    get(): Record<string, any>;
    /** Removes a specific key from localStorage. */
    remove(key: string): void;
    /** Clears all localStorage. */
    clear(): void;
    /** Returns true if the key exists. */
    has(key: string): boolean;
    /** Returns all localStorage keys. */
    keys(): string[];
}
/**
 * Storage utility to manage browser localStorage with type safety and error handling.
 */
declare const storage: StorageManager;

declare const useAntdImageUpload: ({ length }: {
    length?: number | undefined;
}) => {
    ImageBox: () => react_jsx_runtime.JSX.Element;
    fileList: UploadFile<any>[];
    setFileList: React$1.Dispatch<React$1.SetStateAction<UploadFile<any>[]>>;
    PerviewBox: ({ src }: {
        src: string;
    }) => react_jsx_runtime.JSX.Element;
    setPreviewImage: React$1.Dispatch<React$1.SetStateAction<string>>;
};

interface CategoryItem {
    id: string | number;
    name: string;
    price: string | number;
    image: string;
}
interface CategoryViewProps {
    categoryName: string;
    items: CategoryItem[];
    className?: string;
}
declare const CategoryCard: React__default.FC<{
    item: CategoryItem;
}>;

declare const Views: {
    Transaction: ({ id, type, close, reverseable, }: {
        id: string;
        type: "" | "journal" | "payment" | "money transfer" | "expense" | "adjustment" | "forex transfer" | "stock" | "forex dubai to china" | "forex" | "forex expense" | "lease" | "expense account" | undefined;
        close: () => void;
        reverseable?: {
            reload: () => void;
        };
    }) => react_jsx_runtime.JSX.Element;
    CategoryView: React$1.FC<CategoryViewProps>;
    CategoryCard: React$1.FC<{
        item: CategoryItem;
    }>;
};

/**
 * Guard component that fetches the current user profile on every route change.
 * It ensures the auth state is synchronized with the server.
 */
declare const Guard: () => react_jsx_runtime.JSX.Element;
/**
 * Ensures the user is logged in to access child routes.
 */
declare const ProtectedRoute: () => react_jsx_runtime.JSX.Element;
/**
 * Ensures the user is NOT logged in to access child routes (e.g. Login/Signup pages).
 */
declare const UnProtectedRoute: () => react_jsx_runtime.JSX.Element;
/**
 * Ensures only users with 'admin' role can access child routes.
 */
declare const AdminProtectedRoute: () => react_jsx_runtime.JSX.Element;

type Role = string;
type AccountType = string;
type AuthData = {
    _id: string;
    role: Role;
    email: string;
    phoneNumber: string;
    isActive: boolean;
    isEmailVerified: boolean;
    isPhoneVerified: boolean;
    permissions?: Record<string, boolean>;
    homePath?: string;
    name?: string;
};
type AccountData = {
    _id: string;
    name: string;
    email: string;
    phoneNumber: string;
    type: AccountType;
};
type BranchesContext = {
    branches?: {
        _id: string;
        name: string;
        type: string;
        logo: string;
        currency: string;
        contact: {
            phoneNumber: string;
            email: string;
        };
        address: {
            location: string;
            city: string;
        };
        features: {
            stockTracking: boolean;
            moneyTracking: boolean;
        };
        isActive: boolean;
        by: {
            name: string;
        };
        createdAt: string;
    }[];
};
type AuthState = {
    auth: AuthData | null;
    account: AccountData | null;
    branches: BranchesContext["branches"] | null;
    isLoggedIn: boolean;
    isFetched: boolean;
    setAuth: (auth: AuthData, account: AccountData, branches?: BranchesContext["branches"]) => void;
    setBranches: (branches: BranchesContext["branches"]) => void;
    setIsLoggedIn: (isLoggedIn: boolean) => void;
    setIsFetched: (isFetched: boolean) => void;
    logout: () => void;
    updateAuth: (data: Partial<AuthData>) => void;
    updateAccount: (data: Partial<AccountData>) => void;
    hasPermission: (key: string) => boolean;
};
declare const useAuthStore: zustand.UseBoundStore<zustand.StoreApi<AuthState>>;

declare const useAuth: () => {
    auth: {
        _id: string;
        role: Role;
        email: string;
        phoneNumber: string;
        isActive: boolean;
        isEmailVerified: boolean;
        isPhoneVerified: boolean;
        permissions?: Record<string, boolean>;
        homePath?: string;
        name?: string;
    } | null;
    user: {
        _id: string;
        role: Role;
        email: string;
        phoneNumber: string;
        isActive: boolean;
        isEmailVerified: boolean;
        isPhoneVerified: boolean;
        permissions?: Record<string, boolean>;
        homePath?: string;
        name?: string;
    } | null;
    account: {
        _id: string;
        name: string;
        email: string;
        phoneNumber: string;
        type: AccountType;
    } | null;
    branches: {
        _id: string;
        name: string;
        type: string;
        logo: string;
        currency: string;
        contact: {
            phoneNumber: string;
            email: string;
        };
        address: {
            location: string;
            city: string;
        };
        features: {
            stockTracking: boolean;
            moneyTracking: boolean;
        };
        isActive: boolean;
        by: {
            name: string;
        };
        createdAt: string;
    }[] | null | undefined;
    isLoggedIn: boolean;
    isFetched: boolean;
    role: string | undefined;
    userId: string | undefined;
    accountId: string | undefined;
    userName: string | undefined;
    userEmail: string | undefined;
    permissions: Record<string, boolean>;
    isAdmin: boolean;
    isActive: boolean;
    isVerified: boolean;
    isEmailVerified: boolean;
    isPhoneVerified: boolean;
    logout: () => void;
    setIsLoggedIn: (isLoggedIn: boolean) => void;
    setIsFetched: (isFetched: boolean) => void;
    setAuth: (auth: {
        _id: string;
        role: Role;
        email: string;
        phoneNumber: string;
        isActive: boolean;
        isEmailVerified: boolean;
        isPhoneVerified: boolean;
        permissions?: Record<string, boolean>;
        homePath?: string;
        name?: string;
    }, account: {
        _id: string;
        name: string;
        email: string;
        phoneNumber: string;
        type: AccountType;
    }, branches?: BranchesContext["branches"]) => void;
    setBranches: (branches: BranchesContext["branches"]) => void;
    login: (data: any) => void;
    updateAuth: (data: Partial<{
        _id: string;
        role: Role;
        email: string;
        phoneNumber: string;
        isActive: boolean;
        isEmailVerified: boolean;
        isPhoneVerified: boolean;
        permissions?: Record<string, boolean>;
        homePath?: string;
        name?: string;
    }>) => void;
    updateUser: (data: Partial<{
        _id: string;
        role: Role;
        email: string;
        phoneNumber: string;
        isActive: boolean;
        isEmailVerified: boolean;
        isPhoneVerified: boolean;
        permissions?: Record<string, boolean>;
        homePath?: string;
        name?: string;
    }>) => void;
    updateAccount: (data: Partial<{
        _id: string;
        name: string;
        email: string;
        phoneNumber: string;
        type: AccountType;
    }>) => void;
    hasPermission: (key: string) => boolean;
    can: (key: string) => boolean;
};

declare function Accounts({ v, url }: {
    v?: 1 | 2;
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function ForexAccounts({ v, url }: {
    v?: 1 | 2;
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function ForexTransactions(): react_jsx_runtime.JSX.Element;

declare function TodayForexTransaction(): react_jsx_runtime.JSX.Element;

declare function AccountForm({ showCurrency, showDocument, }: {
    showCurrency?: boolean;
    showDocument?: boolean;
}): react_jsx_runtime.JSX.Element;

type AccountProps$2<T extends FieldValues> = {
    name: Path<T>;
    label: string;
    form: UseFormReturn<T>;
    placeholder?: string;
    api: string;
    filter?: string[];
    showBalance?: boolean;
    v?: number;
    required?: boolean;
    disabled?: boolean;
    obj?: string;
    className?: string;
};
declare function Account<T extends FieldValues>({ name, label, placeholder, api, form, filter, v, showBalance, required, disabled, obj, className, }: AccountProps$2<T>): react_jsx_runtime.JSX.Element;

type Props$2<T extends FieldValues> = {
    name?: Path<T>;
    label?: string;
    form: UseFormReturn<T>;
    placeholder?: string;
    api?: string;
    filter?: string[];
    showBalance?: boolean;
    v?: number;
    required?: boolean;
    disabled?: boolean;
    obj?: Path<T>;
    className?: string;
};
declare function Customer<T extends FieldValues>({ name, label, placeholder, api, form, filter, showBalance, required, disabled, v, obj, className, }: Props$2<T>): react_jsx_runtime.JSX.Element;

type Props$1<T extends FieldValues> = {
    name?: Path<T>;
    label?: string;
    form: UseFormReturn<T>;
    placeholder?: string;
    api?: string;
    filter?: string[];
    showBalance?: boolean;
    v?: number;
    required?: boolean;
    disabled?: boolean;
    obj: Path<T>;
    className?: string;
};
declare function Employee<T extends FieldValues>({ name, label, placeholder, api, form, filter, showBalance, required, disabled, obj, v, className, }: Props$1<T>): react_jsx_runtime.JSX.Element;

type Props<T extends FieldValues> = {
    name?: Path<T>;
    label?: string;
    form: UseFormReturn<T>;
    placeholder?: string;
    api?: string;
    filter?: string[];
    showBalance?: boolean;
    v?: number;
    required?: boolean;
    disabled?: boolean;
    obj?: Path<T>;
    className?: string;
};
declare function Branches<T extends FieldValues>({ name, label, placeholder, api, form, filter, showBalance, required, v, disabled, obj, className, }: Props<T>): react_jsx_runtime.JSX.Element;

declare const AccountFields: {
    Account: typeof Account;
    Customer: typeof Customer;
    Employee: typeof Employee;
    Branches: typeof Branches;
};

declare const createAccountSchema: z$1.ZodObject<{
    name: z$1.ZodString;
    email: z$1.ZodEffects<z$1.ZodEffects<z$1.ZodOptional<z$1.ZodString>, string | undefined, string | undefined>, string | undefined, string | undefined>;
    phoneNumber: z$1.ZodOptional<z$1.ZodString>;
    sex: z$1.ZodOptional<z$1.ZodEnum<["male", "female"]>>;
    branch: z$1.ZodOptional<z$1.ZodString>;
    currency: z$1.ZodOptional<z$1.ZodString>;
    documentType: z$1.ZodOptional<z$1.ZodEnum<["none", "id", "passport", "license"]>>;
    document: z$1.ZodOptional<z$1.ZodObject<{
        no: z$1.ZodString;
        name: z$1.ZodString;
        sex: z$1.ZodEnum<["male", "female"]>;
        surname: z$1.ZodString;
        nationality: z$1.ZodString;
        expiryDate: z$1.ZodOptional<z$1.ZodString>;
    }, "strip", z$1.ZodTypeAny, {
        sex: "male" | "female";
        name: string;
        no: string;
        surname: string;
        nationality: string;
        expiryDate?: string | undefined;
    }, {
        sex: "male" | "female";
        name: string;
        no: string;
        surname: string;
        nationality: string;
        expiryDate?: string | undefined;
    }>>;
    salary: z$1.ZodOptional<z$1.ZodNumber>;
}, "strip", z$1.ZodTypeAny, {
    name: string;
    branch?: string | undefined;
    sex?: "male" | "female" | undefined;
    email?: string | undefined;
    document?: {
        sex: "male" | "female";
        name: string;
        no: string;
        surname: string;
        nationality: string;
        expiryDate?: string | undefined;
    } | undefined;
    currency?: string | undefined;
    phoneNumber?: string | undefined;
    documentType?: "none" | "id" | "passport" | "license" | undefined;
    salary?: number | undefined;
}, {
    name: string;
    branch?: string | undefined;
    sex?: "male" | "female" | undefined;
    email?: string | undefined;
    document?: {
        sex: "male" | "female";
        name: string;
        no: string;
        surname: string;
        nationality: string;
        expiryDate?: string | undefined;
    } | undefined;
    currency?: string | undefined;
    phoneNumber?: string | undefined;
    documentType?: "none" | "id" | "passport" | "license" | undefined;
    salary?: number | undefined;
}>;
type CreateAccountSchemaType = z$1.infer<typeof createAccountSchema>;

declare function LinkUser({ type: initialType }: {
    type?: string;
}): react_jsx_runtime.JSX.Element;

declare function Users(): react_jsx_runtime.JSX.Element;

declare function UserForm(): react_jsx_runtime.JSX.Element;

declare function ResetPasswordPage(): react_jsx_runtime.JSX.Element;

interface UserProfileProps {
    items?: DropdownItem[];
    name?: string;
    role?: string;
    image?: string;
    onLogout?: () => void;
    showThemeToggle?: boolean;
}
declare const UserProfile: React__default.FC<UserProfileProps>;

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

declare function UserUpdate(): react_jsx_runtime.JSX.Element;

declare function UserBranches(): react_jsx_runtime.JSX.Element;

declare const useApp: () => {
    navigate: react_router.NavigateFunction;
    getQuery: (key?: string) => string | {
        [k: string]: string;
    } | null;
    getParams: (key?: string) => string | Readonly<react_router.Params<string>> | undefined;
    setQuery: (params: Record<string, string>) => void;
    branchId: string | undefined;
};

declare function useFirebaseStorage(): {
    uploadFile: (file: File | Blob, path: string) => Promise<string>;
    deleteFile: (pathOrUrl: string) => Promise<void>;
    isConfigured: boolean;
};

declare const linkUserSchema: z$1.ZodObject<{
    email: z$1.ZodEffects<z$1.ZodEffects<z$1.ZodString, string, string>, string, string>;
    name: z$1.ZodString;
    role: z$1.ZodEnum<["admin"]>;
}, "strip", z$1.ZodTypeAny, {
    name: string;
    email: string;
    role: "admin";
}, {
    name: string;
    email: string;
    role: "admin";
}>;
declare const verifyUserEmailSchema: z$1.ZodObject<{
    email: z$1.ZodEffects<z$1.ZodEffects<z$1.ZodString, string, string>, string, string>;
    token: z$1.ZodString;
}, "strip", z$1.ZodTypeAny, {
    email: string;
    token: string;
}, {
    email: string;
    token: string;
}>;
declare const updateUserEmailSchema: z$1.ZodObject<{
    currentEmail: z$1.ZodOptional<z$1.ZodString>;
    newEmail: z$1.ZodEffects<z$1.ZodEffects<z$1.ZodString, string, string>, string, string>;
}, "strip", z$1.ZodTypeAny, {
    newEmail: string;
    currentEmail?: string | undefined;
}, {
    newEmail: string;
    currentEmail?: string | undefined;
}>;
declare const resetPasswordSchema: z$1.ZodObject<{
    email: z$1.ZodOptional<z$1.ZodString>;
    token: z$1.ZodString;
    password: z$1.ZodString;
}, "strip", z$1.ZodTypeAny, {
    token: string;
    password: string;
    email?: string | undefined;
}, {
    token: string;
    password: string;
    email?: string | undefined;
}>;
declare const createUserSchema: z$1.ZodObject<{
    email: z$1.ZodEffects<z$1.ZodEffects<z$1.ZodString, string, string>, string, string>;
    phoneNumber: z$1.ZodOptional<z$1.ZodString>;
    name: z$1.ZodString;
    role: z$1.ZodEnum<["admin", "staff", "manager"]>;
}, "strip", z$1.ZodTypeAny, {
    name: string;
    email: string;
    role: "admin" | "staff" | "manager";
    phoneNumber?: string | undefined;
}, {
    name: string;
    email: string;
    role: "admin" | "staff" | "manager";
    phoneNumber?: string | undefined;
}>;
declare const updateUserSchema: z$1.ZodObject<{
    name: z$1.ZodOptional<z$1.ZodString>;
    phoneNumber: z$1.ZodOptional<z$1.ZodString>;
    role: z$1.ZodOptional<z$1.ZodEnum<["admin", "staff", "manager"]>>;
}, "strip", z$1.ZodTypeAny, {
    name?: string | undefined;
    role?: "admin" | "staff" | "manager" | undefined;
    phoneNumber?: string | undefined;
}, {
    name?: string | undefined;
    role?: "admin" | "staff" | "manager" | undefined;
    phoneNumber?: string | undefined;
}>;
declare const manageBranchSchema: z$1.ZodObject<{
    branchId: z$1.ZodOptional<z$1.ZodString>;
}, "strip", z$1.ZodTypeAny, {
    branchId?: string | undefined;
}, {
    branchId?: string | undefined;
}>;
type manageBranchSchemaType = z$1.infer<typeof manageBranchSchema>;
type linkUserSchemaType = z$1.infer<typeof linkUserSchema>;
type verifyUserEmailSchemaType = z$1.infer<typeof verifyUserEmailSchema>;
type updateUserEmailSchemaType = z$1.infer<typeof updateUserEmailSchema>;
type resetPasswordSchemaType = z$1.infer<typeof resetPasswordSchema>;
type createUserSchemaType = z$1.infer<typeof createUserSchema>;
type updateUserSchemaType = z$1.infer<typeof updateUserSchema>;

declare function Wallets({ v, url }: {
    v?: 1 | 2;
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function WalletForm(): react_jsx_runtime.JSX.Element;

type WalletFieldProps<T extends FieldValues> = {
    name: Path<T>;
    label: string;
    form: UseFormReturn<T>;
    placeholder?: string;
    api?: string;
    filter?: string[];
    showBalance?: boolean;
    v?: number;
    required?: boolean;
    disabled?: boolean;
    obj?: Path<T>;
    className?: string;
};
declare function Wallet<T extends FieldValues>({ name, label, placeholder, api, form, filter, v, showBalance, required, disabled, obj, className, }: WalletFieldProps<T>): react_jsx_runtime.JSX.Element;

declare const WalletField: {
    Wallet: typeof Wallet;
};

interface WalletOverViewProps {
    branchId?: string;
    className?: string;
}
declare function WalletOverView({ branchId, className }: WalletOverViewProps): react_jsx_runtime.JSX.Element;

declare const createWalletSchema: z$1.ZodObject<{
    name: z$1.ZodString;
    type: z$1.ZodEnum<["bank", "cash", "mobile"]>;
    currency: z$1.ZodEnum<["USD", "TZS", "KES", "RMB", "AED"]>;
    accountNo: z$1.ZodOptional<z$1.ZodString>;
    branch: z$1.ZodOptional<z$1.ZodString>;
}, "strip", z$1.ZodTypeAny, {
    name: string;
    type: "bank" | "cash" | "mobile";
    currency: "USD" | "TZS" | "KES" | "RMB" | "AED";
    branch?: string | undefined;
    accountNo?: string | undefined;
}, {
    name: string;
    type: "bank" | "cash" | "mobile";
    currency: "USD" | "TZS" | "KES" | "RMB" | "AED";
    branch?: string | undefined;
    accountNo?: string | undefined;
}>;
type CreateWalletSchemaType = z$1.infer<typeof createWalletSchema>;

declare function Brands({ v, url }: {
    v?: 1 | 2;
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function BrandForm(): react_jsx_runtime.JSX.Element;

type BrandFieldProps<T extends FieldValues> = {
    name: Path<T>;
    label: string;
    form: UseFormReturn<T>;
    placeholder?: string;
    api: string;
    filter?: string[];
    v?: number;
    required?: boolean;
    disabled?: boolean;
};
declare function Brand<T extends FieldValues>({ name, label, placeholder, api, form, filter, v, required, disabled, }: BrandFieldProps<T>): react_jsx_runtime.JSX.Element;

declare const BrandField: {
    Brand: typeof Brand;
};

declare const createBrandSchema: z$1.ZodObject<{
    name: z$1.ZodString;
}, "strip", z$1.ZodTypeAny, {
    name: string;
}, {
    name: string;
}>;
type CreateBrandSchemaType = z$1.infer<typeof createBrandSchema>;

declare function Categories({ v, url }: {
    v?: 1 | 2;
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function CategoryForm(): react_jsx_runtime.JSX.Element;

type CategoryFieldProps<T extends FieldValues> = {
    name: Path<T>;
    label: string;
    form: UseFormReturn<T>;
    placeholder?: string;
    api: string;
    filter?: string[];
    v?: number;
    required?: boolean;
    disabled?: boolean;
};
declare function Category<T extends FieldValues>({ name, label, placeholder, api, form, filter, v, required, disabled, }: CategoryFieldProps<T>): react_jsx_runtime.JSX.Element;

declare const CategoryField: {
    Category: typeof Category;
};

declare const createCategorySchema: z$1.ZodObject<{
    name: z$1.ZodString;
}, "strip", z$1.ZodTypeAny, {
    name: string;
}, {
    name: string;
}>;
type CreateCategorySchemaType = z$1.infer<typeof createCategorySchema>;

declare function Products({ v, url }: {
    v?: 1 | 2;
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function ProductForm(): react_jsx_runtime.JSX.Element;

type ProductFieldProps<T extends FieldValues> = {
    name: Path<T>;
    label: string;
    form: UseFormReturn<T>;
    placeholder?: string;
    api: string;
    filter?: string[];
    v?: number;
    required?: boolean;
    disabled?: boolean;
    onChange?: (val: any, opt?: any) => void;
    obj?: Path<T>;
    className?: string;
};
declare function Product<T extends FieldValues>({ name, label, placeholder, api, form, filter, v, required, disabled, onChange, obj, className, }: ProductFieldProps<T>): react_jsx_runtime.JSX.Element;

declare const ProductField: {
    Product: typeof Product;
};

declare const createProductSchema: z$1.ZodObject<{
    name: z$1.ZodString;
    category: z$1.ZodOptional<z$1.ZodString>;
    brand: z$1.ZodOptional<z$1.ZodString>;
    cost: z$1.ZodNumber;
    yard: z$1.ZodOptional<z$1.ZodNumber>;
}, "strip", z$1.ZodTypeAny, {
    name: string;
    cost: number;
    category?: string | undefined;
    brand?: string | undefined;
    yard?: number | undefined;
}, {
    name: string;
    cost: number;
    category?: string | undefined;
    brand?: string | undefined;
    yard?: number | undefined;
}>;
type CreateProductSchemaType = z$1.infer<typeof createProductSchema>;

declare function Packs({ v, url }: {
    v?: 1 | 2;
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function PackForm(): react_jsx_runtime.JSX.Element;

type PackFieldProps<T extends FieldValues> = {
    name: Path<T>;
    label: string;
    form: UseFormReturn<T>;
    placeholder?: string;
    api: string;
    filter?: string[];
    v?: number;
    required?: boolean;
    disabled?: boolean;
    onChange?: (val: any, opt?: any) => void;
    obj?: Path<T>;
    className?: string;
};
declare function Pack<T extends FieldValues>({ name, label, placeholder, api, form, filter, v, required, disabled, onChange, obj, className, }: PackFieldProps<T>): react_jsx_runtime.JSX.Element;
declare const _default: {
    Pack: typeof Pack;
};

declare const packProductItemSchema: z$1.ZodObject<{
    product: z$1.ZodString;
    cost: z$1.ZodNumber;
    quantity: z$1.ZodNumber;
    index: z$1.ZodNumber;
    productData: z$1.ZodOptional<z$1.ZodAny>;
}, "strip", z$1.ZodTypeAny, {
    product: string;
    index: number;
    quantity: number;
    cost: number;
    productData?: any;
}, {
    product: string;
    index: number;
    quantity: number;
    cost: number;
    productData?: any;
}>;
declare const packTypes: z$1.ZodEnum<["pressure", "bag", "boxes"]>;
declare const createPackSchema: z$1.ZodObject<{
    type: z$1.ZodEnum<["pressure", "bag", "boxes"]>;
    name: z$1.ZodString;
    products: z$1.ZodArray<z$1.ZodObject<{
        product: z$1.ZodString;
        cost: z$1.ZodNumber;
        quantity: z$1.ZodNumber;
        index: z$1.ZodNumber;
        productData: z$1.ZodOptional<z$1.ZodAny>;
    }, "strip", z$1.ZodTypeAny, {
        product: string;
        index: number;
        quantity: number;
        cost: number;
        productData?: any;
    }, {
        product: string;
        index: number;
        quantity: number;
        cost: number;
        productData?: any;
    }>, "many">;
    tempProduct: z$1.ZodOptional<z$1.ZodString>;
    tempQty: z$1.ZodOptional<z$1.ZodNumber>;
    tempCost: z$1.ZodOptional<z$1.ZodNumber>;
    tempData: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
}, "strip", z$1.ZodTypeAny, {
    name: string;
    type: "pressure" | "bag" | "boxes";
    products: {
        product: string;
        index: number;
        quantity: number;
        cost: number;
        productData?: any;
    }[];
    tempProduct?: string | undefined;
    tempQty?: number | undefined;
    tempCost?: number | undefined;
    tempData?: Record<string, any> | undefined;
}, {
    name: string;
    type: "pressure" | "bag" | "boxes";
    products: {
        product: string;
        index: number;
        quantity: number;
        cost: number;
        productData?: any;
    }[];
    tempProduct?: string | undefined;
    tempQty?: number | undefined;
    tempCost?: number | undefined;
    tempData?: Record<string, any> | undefined;
}>;
type CreatePackSchemaType = z$1.infer<typeof createPackSchema>;
type PackProductItemSchemaType = z$1.infer<typeof packProductItemSchema>;

declare function Journals$1({ url, journalType, }: {
    url?: string;
    journalType?: string;
}): react_jsx_runtime.JSX.Element;

type accountType$1 = (typeof Enums.accountTypes)[number] | "all";
declare function JournalForm$1({ isFee, accountType, }: {
    isFee?: boolean;
    accountType?: accountType$1;
}): react_jsx_runtime.JSX.Element;

declare const journalSchema: z$1.ZodObject<{
    date: z$1.ZodEffects<z$1.ZodString, string, string>;
    amount: z$1.ZodNumber;
    account: z$1.ZodString;
    description: z$1.ZodString;
    journalVia: z$1.ZodEnum<["direct", "via account"]>;
    action: z$1.ZodOptional<z$1.ZodEnum<["credit", "debit"]>>;
    viaAccount: z$1.ZodOptional<z$1.ZodString>;
    viaAccountObject: z$1.ZodOptional<z$1.ZodAny>;
    accountObject: z$1.ZodOptional<z$1.ZodAny>;
    rate: z$1.ZodOptional<z$1.ZodNumber>;
    exchangedAmount: z$1.ZodOptional<z$1.ZodNumber>;
    fee: z$1.ZodNumber;
    note: z$1.ZodOptional<z$1.ZodString>;
}, "strip", z$1.ZodTypeAny, {
    account: string;
    date: string;
    description: string;
    amount: number;
    fee: number;
    journalVia: "direct" | "via account";
    note?: string | undefined;
    action?: "credit" | "debit" | undefined;
    rate?: number | undefined;
    viaAccount?: string | undefined;
    viaAccountObject?: any;
    accountObject?: any;
    exchangedAmount?: number | undefined;
}, {
    account: string;
    date: string;
    description: string;
    amount: number;
    fee: number;
    journalVia: "direct" | "via account";
    note?: string | undefined;
    action?: "credit" | "debit" | undefined;
    rate?: number | undefined;
    viaAccount?: string | undefined;
    viaAccountObject?: any;
    accountObject?: any;
    exchangedAmount?: number | undefined;
}>;
type JournalSchemaType = z$1.infer<typeof journalSchema>;

declare function Payments$1({ url, paymentType, }: {
    url?: string;
    paymentType?: string;
}): react_jsx_runtime.JSX.Element;

declare function PaymentForm$1({ accountType, }: {
    accountType?: (typeof Enums.accountTypes)[number] | "all";
}): react_jsx_runtime.JSX.Element;

declare const paymentSchema: z$1.ZodObject<{
    date: z$1.ZodEffects<z$1.ZodString, string, string>;
    amount: z$1.ZodNumber;
    account: z$1.ZodString;
    action: z$1.ZodEnum<["credit", "debit"]>;
    branch: z$1.ZodOptional<z$1.ZodString>;
    fee: z$1.ZodOptional<z$1.ZodNumber>;
    note: z$1.ZodOptional<z$1.ZodString>;
    wallet: z$1.ZodString;
    description: z$1.ZodString;
    accountObject: z$1.ZodOptional<z$1.ZodAny>;
    walletObject: z$1.ZodOptional<z$1.ZodAny>;
    rate: z$1.ZodOptional<z$1.ZodNumber>;
    invoiceNumber: z$1.ZodOptional<z$1.ZodString>;
}, "strip", z$1.ZodTypeAny, {
    account: string;
    date: string;
    description: string;
    amount: number;
    action: "credit" | "debit";
    wallet: string;
    branch?: string | undefined;
    note?: string | undefined;
    fee?: number | undefined;
    rate?: number | undefined;
    accountObject?: any;
    walletObject?: any;
    invoiceNumber?: string | undefined;
}, {
    account: string;
    date: string;
    description: string;
    amount: number;
    action: "credit" | "debit";
    wallet: string;
    branch?: string | undefined;
    note?: string | undefined;
    fee?: number | undefined;
    rate?: number | undefined;
    accountObject?: any;
    walletObject?: any;
    invoiceNumber?: string | undefined;
}>;
type PaymentSchemaType = z$1.infer<typeof paymentSchema>;

declare function MoneyTransfers({ url }: {
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function MoneyTransferForm(): react_jsx_runtime.JSX.Element;

declare const moneyTransferSchema: z$1.ZodObject<{
    date: z$1.ZodEffects<z$1.ZodString, string, string>;
    amount: z$1.ZodNumber;
    branch: z$1.ZodOptional<z$1.ZodString>;
    note: z$1.ZodOptional<z$1.ZodString>;
    fromWallet: z$1.ZodString;
    toWallet: z$1.ZodString;
    fee: z$1.ZodOptional<z$1.ZodNumber>;
    fromWalletObject: z$1.ZodOptional<z$1.ZodAny>;
    toWalletObject: z$1.ZodOptional<z$1.ZodAny>;
    rate: z$1.ZodOptional<z$1.ZodNumber>;
}, "strip", z$1.ZodTypeAny, {
    date: string;
    amount: number;
    fromWallet: string;
    toWallet: string;
    branch?: string | undefined;
    note?: string | undefined;
    fee?: number | undefined;
    rate?: number | undefined;
    fromWalletObject?: any;
    toWalletObject?: any;
}, {
    date: string;
    amount: number;
    fromWallet: string;
    toWallet: string;
    branch?: string | undefined;
    note?: string | undefined;
    fee?: number | undefined;
    rate?: number | undefined;
    fromWalletObject?: any;
    toWalletObject?: any;
}>;
type MoneyTransferSchemaType = z$1.infer<typeof moneyTransferSchema>;

declare function Expenses({ url }: {
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function ExpenseForm(): react_jsx_runtime.JSX.Element;

declare const expenseSchema: z$1.ZodObject<{
    description: z$1.ZodString;
    date: z$1.ZodEffects<z$1.ZodString, string, string>;
    amount: z$1.ZodNumber;
    branch: z$1.ZodOptional<z$1.ZodString>;
    wallet: z$1.ZodString;
    note: z$1.ZodOptional<z$1.ZodString>;
    walletObject: z$1.ZodOptional<z$1.ZodAny>;
}, "strip", z$1.ZodTypeAny, {
    date: string;
    description: string;
    amount: number;
    wallet: string;
    branch?: string | undefined;
    note?: string | undefined;
    walletObject?: any;
}, {
    date: string;
    description: string;
    amount: number;
    wallet: string;
    branch?: string | undefined;
    note?: string | undefined;
    walletObject?: any;
}>;
type ExpenseSchemaType = z$1.infer<typeof expenseSchema>;

declare function ForexExpenses({ url }: {
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function ForexExpenseForm({ id, close, reload, }: {
    id?: string;
    close: () => void;
    reload: () => void;
}): react_jsx_runtime.JSX.Element;

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

declare function Breadcrumbs(): react_jsx_runtime.JSX.Element;

interface ErrorPageProps {
    title?: string;
    message?: string;
    statusCode?: number;
    action?: {
        label: string;
        onClick: () => void;
    };
    className?: string;
}

declare const ErrorPage: (({ title, message, statusCode, action, className, }: ErrorPageProps) => react_jsx_runtime.JSX.Element) & {
    500: (props: ErrorPageProps) => react_jsx_runtime.JSX.Element;
    404: (props: ErrorPageProps) => react_jsx_runtime.JSX.Element;
    401: (props: ErrorPageProps) => react_jsx_runtime.JSX.Element;
    400: (props: ErrorPageProps) => react_jsx_runtime.JSX.Element;
};

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

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

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

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

declare function WalletAdjustments({ url }: {
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function WalletAdjustmentForm(): react_jsx_runtime.JSX.Element;

declare const walletAdjustmentSchema: z$1.ZodObject<{
    date: z$1.ZodEffects<z$1.ZodString, string, string>;
    amount: z$1.ZodNumber;
    action: z$1.ZodEnum<["credit", "debit"]>;
    wallet: z$1.ZodString;
    description: z$1.ZodString;
    note: z$1.ZodOptional<z$1.ZodString>;
    branch: z$1.ZodOptional<z$1.ZodString>;
    walletObject: z$1.ZodOptional<z$1.ZodAny>;
}, "strip", z$1.ZodTypeAny, {
    date: string;
    description: string;
    amount: number;
    action: "credit" | "debit";
    wallet: string;
    branch?: string | undefined;
    note?: string | undefined;
    walletObject?: any;
}, {
    date: string;
    description: string;
    amount: number;
    action: "credit" | "debit";
    wallet: string;
    branch?: string | undefined;
    note?: string | undefined;
    walletObject?: any;
}>;
type WalletAdjustmentSchemaType = z$1.infer<typeof walletAdjustmentSchema>;

declare function ForexTransfers({ url }: {
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function ForexTransferForm(): react_jsx_runtime.JSX.Element;

declare const forexTransferSchema: z$1.ZodObject<{
    account: z$1.ZodString;
    wallet: z$1.ZodString;
    amount: z$1.ZodNumber;
    date: z$1.ZodEffects<z$1.ZodString, string, string>;
    description: z$1.ZodString;
    note: z$1.ZodOptional<z$1.ZodString>;
    fee: z$1.ZodOptional<z$1.ZodNumber>;
    branch: z$1.ZodOptional<z$1.ZodString>;
    accountObject: z$1.ZodOptional<z$1.ZodAny>;
    walletObject: z$1.ZodOptional<z$1.ZodAny>;
    rate: z$1.ZodOptional<z$1.ZodNumber>;
}, "strip", z$1.ZodTypeAny, {
    account: string;
    date: string;
    description: string;
    amount: number;
    wallet: string;
    branch?: string | undefined;
    note?: string | undefined;
    fee?: number | undefined;
    rate?: number | undefined;
    accountObject?: any;
    walletObject?: any;
}, {
    account: string;
    date: string;
    description: string;
    amount: number;
    wallet: string;
    branch?: string | undefined;
    note?: string | undefined;
    fee?: number | undefined;
    rate?: number | undefined;
    accountObject?: any;
    walletObject?: any;
}>;
type ForexTransferSchemaType = z$1.infer<typeof forexTransferSchema>;

declare function ClothendStockAdjustment({ url, type, }: {
    url?: string;
    type?: string;
}): react_jsx_runtime.JSX.Element;

type StockType$2 = (typeof Enums.stockTypes)[number];
declare const PosStockAdjustment: ({ type }: {
    type: StockType$2;
}) => react_jsx_runtime.JSX.Element;

declare function SaleStockAdjustment({ url, type, }: {
    url?: string;
    type?: string;
}): react_jsx_runtime.JSX.Element;

type StockType$1 = (typeof Enums.saleStockTypes)[number];
declare const SaleStockForm: ({ type }: {
    type: StockType$1;
}) => react_jsx_runtime.JSX.Element;

type TransferStockType = (typeof Enums.stockTransferTypes)[number];
declare function ClothendStockTransfer({ url, type, }: {
    url?: string;
    type?: TransferStockType;
}): react_jsx_runtime.JSX.Element;

declare const PosStockTransfer: ({ type }: {
    type: TransferStockType;
}) => react_jsx_runtime.JSX.Element;

declare function ForexDubaiToChina(): react_jsx_runtime.JSX.Element;

declare function ForexDubaiToChinaForm(): react_jsx_runtime.JSX.Element;

declare const forexDubaiToChinaSchema: z$1.ZodObject<{
    amount: z$1.ZodNumber;
    date: z$1.ZodEffects<z$1.ZodString, string, string>;
    viaAccount: z$1.ZodString;
    viaAccountObject: z$1.ZodOptional<z$1.ZodAny>;
    rmbToAedRate: z$1.ZodNumber;
    aedToUsdRate: z$1.ZodNumber;
    account: z$1.ZodString;
    accountObject: z$1.ZodOptional<z$1.ZodAny>;
    rmbToUsdRate: z$1.ZodNumber;
    fee: z$1.ZodNumber;
    note: z$1.ZodOptional<z$1.ZodString>;
    branch: z$1.ZodOptional<z$1.ZodString>;
}, "strip", z$1.ZodTypeAny, {
    account: string;
    date: string;
    amount: number;
    fee: number;
    viaAccount: string;
    rmbToAedRate: number;
    aedToUsdRate: number;
    rmbToUsdRate: number;
    branch?: string | undefined;
    note?: string | undefined;
    viaAccountObject?: any;
    accountObject?: any;
}, {
    account: string;
    date: string;
    amount: number;
    fee: number;
    viaAccount: string;
    rmbToAedRate: number;
    aedToUsdRate: number;
    rmbToUsdRate: number;
    branch?: string | undefined;
    note?: string | undefined;
    viaAccountObject?: any;
    accountObject?: any;
}>;
type ForexDubaiToChinaSchemaType = z$1.infer<typeof forexDubaiToChinaSchema>;

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

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

declare const StockLevel: ({ value }: {
    value: boolean;
}) => react_jsx_runtime.JSX.Element;

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

declare function DateSalesReport({ days, showChart, }: {
    days?: number;
    showChart?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function Messages(): react_jsx_runtime.JSX.Element;

declare function FloorsContainer({ type }: {
    type?: "sale" | "rent";
}): react_jsx_runtime.JSX.Element;
declare const Floors: typeof FloorsContainer;

type AccountProps$1<T extends FieldValues> = {
    name: Path<T>;
    label?: string;
    form: UseFormReturn<T>;
    placeholder?: string;
    api?: string;
    filter?: string[];
    v?: number;
    required?: boolean;
    disabled?: boolean;
    obj?: string;
};
declare function UnitField<T extends FieldValues>({ name, label, placeholder, api, form, filter, v, required, disabled, obj, }: AccountProps$1<T>): react_jsx_runtime.JSX.Element;

declare const Units: {
    Field: typeof UnitField;
};

type LeaseType$2 = (typeof Enums.leaseTypes)[number];

declare function LeaseJournals({ url, leaseType, }: {
    url?: string;
    leaseType: LeaseType$2;
}): react_jsx_runtime.JSX.Element;

declare function LeaseJornalFrom({ leaseType }: {
    leaseType: LeaseType$2;
}): react_jsx_runtime.JSX.Element;

type LeaseFormType = (typeof Enums.leaseTypes)[number];
declare function LeaseForm({ leaseType }: {
    leaseType: LeaseFormType;
}): react_jsx_runtime.JSX.Element;

type LeaseType$1 = (typeof Enums.leaseTypes)[number];

declare function LeasePayment({ url, leaseType, }: {
    url?: string;
    leaseType: LeaseType$1;
}): react_jsx_runtime.JSX.Element;

declare function LeasePaymentForm({ leaseType }: {
    leaseType: LeaseType$1;
}): react_jsx_runtime.JSX.Element;

type LeaseType = (typeof Enums.leaseTypes)[number];

declare function LeaseInvoice({ url, leaseType, }: {
    url?: string;
    leaseType: LeaseType;
}): react_jsx_runtime.JSX.Element;

declare function LeaseInvoiceForm({ leaseType }: {
    leaseType: LeaseType;
}): react_jsx_runtime.JSX.Element;

type AccountProps<T extends FieldValues> = {
    name: Path<T>;
    label?: string;
    form: UseFormReturn<T>;
    placeholder?: string;
    api?: string;
    filter?: string[];
    v?: number;
    required?: boolean;
    disabled?: boolean;
    obj?: string;
};
declare function LeaseField<T extends FieldValues>({ name, label, placeholder, api, form, filter, v, required, disabled, obj, }: AccountProps<T>): react_jsx_runtime.JSX.Element;

declare function Leases({ url, leaseType, }: {
    url?: string;
    leaseType: "sale" | "rent";
}): react_jsx_runtime.JSX.Element;

declare function EndLeases({ url, leaseType, }: {
    url?: string;
    leaseType: "sale" | "rent";
}): react_jsx_runtime.JSX.Element;

declare function EndLeaseForm({ leaseType }: {
    leaseType: LeaseType$2;
}): react_jsx_runtime.JSX.Element;

declare function Paybill(): react_jsx_runtime.JSX.Element;

declare function PaybillForm(): react_jsx_runtime.JSX.Element;

declare const Lease: {
    Form: typeof LeaseForm;
    Journals: typeof LeaseJournals;
    JournalForm: typeof LeaseJornalFrom;
    Payments: typeof LeasePayment;
    PaymentForm: typeof LeasePaymentForm;
    Invoice: typeof LeaseInvoice;
    InvoiceForm: typeof LeaseInvoiceForm;
    Field: typeof LeaseField;
    Leases: typeof Leases;
    EndLeases: typeof EndLeases;
    EndLeaseForm: typeof EndLeaseForm;
    Paybill: typeof Paybill;
    PaybillForm: typeof PaybillForm;
};

declare function ExpenseAccount({ url }: {
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function ExpenseAccountForm(): react_jsx_runtime.JSX.Element;

type accountType = (typeof Enums.accountTypes)[number] | "all";
declare function JournalForm({ accountType }: {
    accountType?: accountType;
}): react_jsx_runtime.JSX.Element;

declare function Journals({ url, journalType, }: {
    url?: string;
    journalType?: string;
}): react_jsx_runtime.JSX.Element;

declare function PaymentForm({ accountType, }: {
    accountType?: (typeof Enums.accountTypes)[number] | "all";
}): react_jsx_runtime.JSX.Element;

declare function Payments({ url, paymentType, }: {
    url?: string;
    paymentType?: string;
}): react_jsx_runtime.JSX.Element;

declare const CurrencyTransactions: {
    JournalForm: typeof JournalForm;
    Journals: typeof Journals;
    PaymentForm: typeof PaymentForm;
    Payments: typeof Payments;
    ExpenseAccount: typeof ExpenseAccount;
    ExpenseAccountForm: typeof ExpenseAccountForm;
};

declare const RealestateAccountReport: ({ modifUrl }: {
    modifUrl?: string;
}) => react_jsx_runtime.JSX.Element;

declare function RealEastateAccounts({ v, url, type, }: {
    v?: 1 | 2;
    url?: string;
    type?: string;
}): react_jsx_runtime.JSX.Element;

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

type CurrencyType = (typeof Enums.currencies)[number];
declare const LeaseAccountStatements: ({ leaseType, defaultCurrency, }: {
    leaseType: LeaseType$2;
    defaultCurrency?: CurrencyType;
}) => react_jsx_runtime.JSX.Element;

declare const LeaseAccountReport: ({ modifUrl, leaseType, defaultCurrency, }: {
    modifUrl?: string;
    leaseType: LeaseType$1;
    defaultCurrency?: CurrencyType;
}) => react_jsx_runtime.JSX.Element;

declare const ExpenseAccountStatement: ({ type }: {
    type?: string;
}) => react_jsx_runtime.JSX.Element;

declare const ExpenseAccountReport: ({ modifUrl }: {
    modifUrl?: string;
}) => react_jsx_runtime.JSX.Element;

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

declare function PostForm({ afterPostUrl }: {
    afterPostUrl?: string;
}): react_jsx_runtime.JSX.Element;

declare function PostsList({ url }: {
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function PostMediaForm(): react_jsx_runtime.JSX.Element;

declare const Posts: {
    List: typeof PostsList;
    Form: typeof PostForm;
    Media: typeof PostMediaForm;
};

type Reverseable$1 = {
    reload: () => void;
};
declare const usePostView: () => {
    open: boolean;
    id: string;
    reverseable: Reverseable$1 | null;
    openPost: (postId: string, rev?: Reverseable$1) => void;
    closePost: () => void;
    PostView: () => react_jsx_runtime.JSX.Element | null;
};

declare function ProfileAccountList({ v, url }: {
    v?: 1 | 2;
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare function ProfileAccountForm({ showCurrency, showDocument, }: {
    showCurrency?: boolean;
    showDocument?: boolean;
}): react_jsx_runtime.JSX.Element;

declare const ProfileAccount: {
    list: typeof ProfileAccountList;
    form: typeof ProfileAccountForm;
};

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

interface LeaseRentOverViewCardProps {
    currencyFilter?: string;
    selectedMonth?: dayjs.Dayjs | string;
    onChangeMonth?: (date: dayjs.Dayjs) => void;
    viewStatementRoute?: string;
    className?: string;
}
declare const LeaseRentOverViewCard: ({ currencyFilter, selectedMonth, onChangeMonth, viewStatementRoute, className, }: LeaseRentOverViewCardProps) => react_jsx_runtime.JSX.Element;

declare const ShopendAccountReport: ({ showInvoiceNumber, }: {
    showInvoiceNumber?: boolean;
}) => react_jsx_runtime.JSX.Element;

declare function TicketsList({ url }: {
    url?: string;
}): react_jsx_runtime.JSX.Element;

declare const Tickets: {
    List: typeof TicketsList;
};

type Reverseable = {
    reload: () => void;
};
declare const useTicketView: () => {
    open: boolean;
    id: string;
    reverseable: Reverseable | null;
    openTicket: (ticketId: string, rev?: Reverseable) => void;
    closeTicket: () => void;
    TicketView: () => react_jsx_runtime.JSX.Element | null;
};

type StockType = (typeof Enums.saleStockTypes)[number];

declare function Sale2List({ url, type }: {
    url?: string;
    type?: string;
}): react_jsx_runtime.JSX.Element;

declare const Sale2: {
    List: typeof Sale2List;
    Form: ({ type }: {
        type: StockType;
    }) => react_jsx_runtime.JSX.Element;
};

export { AccountFields, AccountForm, AccountReport, AccountStatements, type AccountType, Accounts, AdminProtectedRoute, Badge, type BadgeProps, type BranchesContext, BrandField, BrandForm, Branding, type BrandingProps, Brands, Breadcrumbs, Button, type ButtonProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Categories, CategoryCard, CategoryField, CategoryForm, type CategoryItem, ClassicSpin, ClothendStockAdjustment, ClothendStockTransfer, CodeBlock, ConfirmModal, type ConfirmModalProps, type CreateAccountSchemaType, type CreateBrandSchemaType, type CreateCategorySchemaType, type CreatePackSchemaType, type CreateProductSchemaType, type CreateWalletSchemaType, CurrencyTransactions, DashboardLayout, DataTable, type DataTableColumn, DateInput, type DateInputProps, DateSalesReport, type DeleteFunction, Dropdown, type DropdownItem, type DropdownProps, type EnumsConfig, ErrorPage, type ErrorPageProps, ExpenseAReport, ExpenseAccountReport, ExpenseAccountStatement as ExpenseAccountStatements, ExpenseForm, type ExpenseSchemaType, Expenses, type FetchFunction, type FetchProps, Fields, Floors, ForexAccountReport, ForexAccountStatements, ForexAccounts, ForexDubaiToChina, ForexDubaiToChinaForm, type ForexDubaiToChinaSchemaType, ForexExpenseForm, ForexExpenses, ForexExpensesReport, ForexTransactions, ForexTransferForm, type ForexTransferSchemaType, ForexTransfers, Guard, InfoGrid, Input, type InputProps, JournalForm$1 as JournalForm, type JournalSchemaType, Journals$1 as Journals, Lease, LeaseAccountReport, LeaseAccountStatements, LeaseRentOverViewCard, LeaseRentOverviews, LinkUser, LoadingBox, LoadingSpin, type LoginSchema, type LoginTheme, Messages, Modal, type ModalProps, MoneyTransferForm, type MoneyTransferSchemaType, MoneyTransfers, type NavItem, type NavItems, type Option, OverlaySpin, _default as PackField, PackForm, type PackProductItemSchemaType, Packs, PageA4, PageHeader, PaymentForm$1 as PaymentForm, type PaymentSchemaType, Payments$1 as Payments, type PdfOptions, PhoneInput, type PhoneInputProps, type PostFunction, PostTable, type PostTableActions, type PostTableChangeParams, Posts, ProductField, ProductForm, Products, ProfileAccount, ProfileCard, type ProfileCardProps, ProfileDropdown, type ProfileDropdownItem, type ProfileDropdownProps, ProfilePage, ProfileView, type ProfileViewInfoItem, type ProfileViewProps, ProfitAndLossReport, ProtectedRoute, type PutFunction, RealestateAccountReport, RealEastateStatements as RealestateAccountStatements, RealEastateAccounts as RealestateAccounts, ResetPasswordPage, type Role, Sale2, SaleStockAdjustment, SaleStockForm, SearchApi, SearchApiContent, SearchApiInput, SearchApiItem, type SearchApiProps, SearchApiTrigger, Select, SelectContent, SelectItem, type SelectProps, SelectTrigger, ShopendAccountReport, SimpleTable, type SimpleTableColumn, PosStockAdjustment as StockAdjustmentForm, StockLevel, PosStockTransfer as StockTransferForm, type StorageManager, type StoreConfig, type SummaryColumn, SummaryTable, type SummaryTableProps, Textarea, type TextareaProps, type ThemeConfig, ThemeProvider, ThemeToggle, ThemedLogin, Tickets, TodayForexTransaction, UnProtectedRoute, Units, type UseModalReturn, UserBranches, UserForm, UserProfile, UserUpdate, Users, Views, WalletAdjustmentForm, type WalletAdjustmentSchemaType, WalletAdjustments, WalletField, WalletForm, WalletOverView, WalletReport, WalletStatements, Wallets, type WarqadConfig, type WarqadConfigContextType, WarqadProvider, type apiConfig, createAccountSchema, createBrandSchema, createCategorySchema, createPackSchema, createProductSchema, createUserSchema, type createUserSchemaType, createWalletSchema, expenseSchema, forexDubaiToChinaSchema, forexTransferSchema, generatePdf, journalSchema, linkUserSchema, type linkUserSchemaType, manageBranchSchema, type manageBranchSchemaType, moneyTransferSchema, packProductItemSchema, packTypes, paymentSchema, resetPasswordSchema, type resetPasswordSchemaType, storage, updateUserEmailSchema, type updateUserEmailSchemaType, updateUserSchema, type updateUserSchemaType, useA4CategoryView, useA4StatementView, useAntdImageUpload, useApi, useApp, useAuth, useAuthStore, useFirebaseStorage, useLogin, useModal, usePostView, useSearchApiContext, useSelectContext, useTheme, useTicketView, useTransaction, useWarqadConfig, useWarqadSocket, verifyUserEmailSchema, type verifyUserEmailSchemaType, walletAdjustmentSchema };
