bookez_test/dist/index.d.ts

A comprehensive documentation for your BookEz npm package, which includes React component libraries and utilities for book-keeping, accounting, banking, and finance applications.

import * as React from 'react';
import React__default, { PropsWithChildren } from 'react';
import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
import { VariantProps } from 'class-variance-authority';
import * as SelectPrimitive from '@radix-ui/react-select';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import * as LabelPrimitive from '@radix-ui/react-label';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { DayPicker } from 'react-day-picker';
import * as PopoverPrimitive from '@radix-ui/react-popover';
import * as TabsPrimitive from '@radix-ui/react-tabs';
import * as TogglePrimitive from '@radix-ui/react-toggle';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import * as SwitchPrimitives from '@radix-ui/react-switch';
import { ThemeProviderProps } from 'next-themes';
import { ColumnDef, OnChangeFn, RowSelectionState, SortingState, ColumnFiltersState, VisibilityState } from '@tanstack/react-table';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';

interface UIContextType {
    businessId: string;
    bookezToken: string;
    theme: "dark" | "light" | "";
    plaidClientUserId?: string;
    plaidClientUserName?: string;
    onError?: (error: Error) => void;
    onSuccess?: (apiType: "GET" | "POST" | "DOWNLOAD" | "OPTIONS", apiName: string, message: string) => void;
}
declare const UIContext: React.Context<UIContextType>;

interface UIProviderProps {
    businessId: string;
    bookezToken: string;
    theme: "dark" | "light" | "";
    plaidClientUserId?: string;
    plaidClientUserName?: string;
    children: React__default.ReactNode;
    onError?: (error: Error) => void;
    onSuccess?: (apiType: "GET" | "POST" | "DOWNLOAD" | "OPTIONS", apiName: string, message: string) => void;
}
declare const UIProvider: React__default.FC<UIProviderProps>;

declare const buttonVariants: (props?: ({
    variant?: "default" | "outline" | "outlineBlack" | "ghost" | "filled" | "monthPicker" | "monthPickerDisabled" | "underline" | "underlineWithoutBorder" | null | undefined;
    size?: "auto" | "default" | "monthPicker" | "xs" | "sm" | "md" | "lg" | "icon" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
    asChild?: boolean;
    loading?: boolean;
}
declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;

declare const Select: React.FC<SelectPrimitive.SelectProps>;
declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    position?: "item-aligned" | "popper";
} & React.RefAttributes<HTMLDivElement>>;
declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;

declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: class_variance_authority_dist_types.ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;

declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & {
    tableTheme?: "default" | "gray";
} & React.RefAttributes<HTMLTableElement>>;
declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & {
    tableTheme?: "default" | "gray" | "transparent";
} & React.RefAttributes<HTMLTableSectionElement>>;
declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;

type CalendarProps = React.ComponentProps<typeof DayPicker>;
declare function Calendar({ className, classNames, showOutsideDays, disabled, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
declare namespace Calendar {
    var displayName: string;
}

declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

declare function DatePicker({ id, label, className, date, onDateChange, minDate, maxDate, showLabel, }: {
    id?: string;
    className?: string;
    label?: string;
    date?: Date | undefined;
    onDateChange?: (date: Date | undefined) => void;
    isIcon?: boolean;
    minDate?: Date | undefined;
    maxDate?: Date | undefined;
    showLabel?: boolean;
}): react_jsx_runtime.JSX.Element;
declare function IconDatePicker({ className, date, onDateChange, minDate, maxDate, }: {
    className?: string;
    date?: Date | undefined;
    onDateChange?: (date: Date | undefined) => void;
    minDate?: Date | undefined;
    maxDate?: Date | undefined;
}): react_jsx_runtime.JSX.Element;

declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    variant?: "blue" | "dark";
} & React.RefAttributes<HTMLDivElement>>;
declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

declare const toggleVariants: (props?: ({
    variant?: "default" | "outline" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
    variant?: "default" | "outline" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;

interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
    label?: string;
    labelClass?: string;
    error?: string;
    icon?: React.ReactNode;
    isRequired?: boolean;
}
declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;

declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DialogHeader: {
    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DialogFooter: {
    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;

interface SwitchProps extends React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root> {
    label?: string;
}
declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;

interface Theme {
    dark: {};
    light: {};
    globals: {};
}
interface CustomThemeProviderProps extends ThemeProviderProps {
    themeColors?: Theme;
}
declare function ThemeProvider({ children, themeColors, ...props }: CustomThemeProviderProps): react_jsx_runtime.JSX.Element;

declare const tableVariants: (props?: ({
    variant?: "default" | "transaction" | "striped" | "bordered" | "cards" | null | undefined;
    cellPadding?: "none" | "default" | "sm" | "md" | "lg" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
type TableVariant = "default" | "striped" | "bordered" | "cards" | "transaction";
type TableSize = "default" | "sm" | "lg" | "xl";
type TableCellPadding = "none" | "sm" | "default" | "md" | "lg";
interface DataTableProps<TData, TValue> {
    className?: string;
    columns: ColumnDef<TData, TValue>[];
    data: TData[];
    variant?: TableVariant;
    size?: TableSize;
    cellPadding?: TableCellPadding;
    currentPage?: number;
    showPagination?: boolean;
    pageSize?: number;
    totalPages?: number;
    totalRecords?: number;
    onPageChange?: (size: number) => void;
    onPageSizeChange?: (page: number) => void;
    rowSelection?: Record<string, boolean>;
    onRowSelectionChange?: OnChangeFn<RowSelectionState>;
    state?: {
        rowSelection?: RowSelectionState;
        sorting?: SortingState;
        columnFilters?: ColumnFiltersState;
        columnVisibility?: VisibilityState;
    };
}
declare function DataTable<TData, TValue>({ className, columns, data, variant, cellPadding, showPagination, pageSize, currentPage, totalPages, totalRecords, onPageChange, onPageSizeChange, rowSelection, onRowSelectionChange, }: DataTableProps<TData, TValue>): react_jsx_runtime.JSX.Element;

declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuShortcut: {
    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

type AllowableFields$1 = "status" | "startDate" | "endDate" | "customer";
interface PaymentFilterProps$1 {
    title?: string;
    clearFilterText?: string;
    btnText?: string;
    FilterFieldsLabel?: {
        [key in AllowableFields$1]?: string;
    };
    allowableFields?: AllowableFields$1[];
}

interface Filters {
    startDate?: string;
    endDate?: string;
    customerId?: string;
    status?: string;
}
interface FilterType<TData, TValue> {
    allowableFields?: AllowableFields$1[];
    statusList?: {
        label: string;
        value: string;
    }[];
    onApplyFilter?: (data: Filters) => void;
    onClearFilter?: () => void;
    clearFilterText?: string;
    btnText?: string;
    label?: string;
    FilterFieldsLabel?: {
        status?: string;
        startDate?: string;
        endDate?: string;
        customer?: string;
    };
}
declare function Filter<TData, TValue>({ label, allowableFields, statusList, FilterFieldsLabel, onApplyFilter, onClearFilter, clearFilterText, btnText, }: FilterType<TData, TValue>): react_jsx_runtime.JSX.Element;

interface pickerType {
    onMonthChange?: (month: string) => void;
    onYearChange?: (year: number) => void;
    date?: Date;
    setDate?: (date: Date) => void;
    trigger?: React__default.ReactNode;
}
declare const months: string[];
declare const years: number[];
declare function CustomMonthPicker({ onMonthChange, onYearChange, date, setDate, trigger, }: pickerType): react_jsx_runtime.JSX.Element;

interface LinkedAccountsProps {
    title?: string;
}

type Props$4 = PropsWithChildren & {
    asContainer?: boolean;
};
declare const Banking: {
    ({ children, asContainer, ...rest }: Props$4): react_jsx_runtime.JSX.Element;
    LinkedAccountsComponent: (props: LinkedAccountsProps) => react_jsx_runtime.JSX.Element;
    BankingData: (props: object) => react_jsx_runtime.JSX.Element;
};
declare const ProtectedLinkedAccounts: (props: LinkedAccountsProps) => react_jsx_runtime.JSX.Element;
declare const ProtectedBankingData: (props: object) => react_jsx_runtime.JSX.Element;

type StringOverrides = {
    profitBeforeTaxesLabel: string;
    netProfitLabel: string;
};
type ReportsProps = PropsWithChildren & {
    stringOverrides?: StringOverrides;
    withDownloadButton?: boolean;
};
declare const Reports: ({ children, stringOverrides, withDownloadButton, ...rest }: ReportsProps) => react_jsx_runtime.JSX.Element;

type ChartOfAccountTableStrings = {
    addAccountButtonText?: string;
    nameColumnHeader?: string;
    typeColumnHeader?: string;
    balanceColumnHeader?: string;
    subtypeColumnHeader?: string;
};
type JournalTableStrings = {
    idLabel?: string;
    dateLabel?: string;
    accountLabel?: string;
    transactionLabel?: string;
    debitLabel?: string;
    creditLabel?: string;
};
interface SourceDetailsStrings {
    label?: string;
    sourceLabel?: string;
    recipientLabel?: string;
    dateLabel?: string;
}
interface InvoiceStrings {
    invoiceTagLabel?: string;
    invoiceAmountTagLabel?: string;
}
interface TransactionTimelineStrings {
    transactionLabel?: string;
    effectiveDateLabel?: string;
    creationDateLabel?: string;
    reversalLabel?: string;
}
interface JournalDetailsStrings {
    headerLabel?: string;
    accountLabel?: string;
    debitLabel?: string;
    creditLabel?: string;
    totalLabel?: string;
}
interface PaymentDetailsStrings {
    headerLabel?: string;
    paymentTagLabel?: string;
    totalLabel?: string;
    paymentDateLabel?: string;
    invoiceTableHeaderLabel?: string;
}
interface VoucherWriteOffDetailsStrings {
    headerLabel?: string;
    voucherIdLabel?: string;
    totalAmountLabel?: string;
    writeOffDateLabel?: string;
}
interface RefundDetailsStrings {
    headerLabel?: string;
    refundIdLabel?: string;
    totalAmountLabel?: string;
    refundDateLabel?: string;
}
interface InvoiceListStrings {
    invoiceTableHeaderLabel?: string;
    invoiceIdLabel: string;
    invoiceAmountLabel: string;
    redemptionTypeAccountLabel: string;
}
interface CreditMemoStrings {
    creditMemoTableHeaderLabel?: string;
    creditMemoIdLabel: string;
    creditMemoAmountLabel: string;
    creditMemoDateLabel: string;
}
interface LedgerProps {
    withExpandAllButton?: boolean;
    withDownloadButton?: boolean;
    stringOverrides?: {
        chartOfAccountTable?: ChartOfAccountTableStrings;
        journalTable?: JournalTableStrings;
        journalEntry?: JournalEntryStrings;
        listing?: ListingItemsStrings;
    };
}
type JournalEntryStrings = {
    modalLabel?: string;
    sourceDetails?: SourceDetailsStrings;
    invoice?: InvoiceStrings;
    transactionTimeLine?: TransactionTimelineStrings;
    journalDetails?: JournalDetailsStrings;
    paymentDetails?: PaymentDetailsStrings;
    voucherWriteOffDetails?: VoucherWriteOffDetailsStrings;
    invoiceList?: InvoiceListStrings;
    creditMemoList?: CreditMemoStrings;
    refundDetails?: RefundDetailsStrings;
};
interface ListingItemsStrings {
    dateLabel: string;
    journalIdLabel: string;
    sourceLabel: string;
    debitLabel: string;
    creditLabel: string;
    runningBalanceLabel: string;
}

type GeneralLedgerProps = PropsWithChildren & LedgerProps;
type LedgerType = "journal" | "chartofaccounts";
declare const GeneralLedger: ({ children, withExpandAllButton, withDownloadButton, stringOverrides, ...rest }: GeneralLedgerProps) => react_jsx_runtime.JSX.Element;

type AllowableFields = "status" | "startDate" | "endDate" | "customer";
interface PaymentFilterProps {
    title?: string;
    clearFilterText?: string;
    btnText?: string;
    FilterFieldsLabel?: {
        [key in AllowableFields]?: string;
    };
    allowableFields?: AllowableFields[];
}

type Props$3 = PropsWithChildren & {
    asContainer?: boolean;
};
declare const Invoice: {
    ({ children, asContainer, ...rest }: Props$3): react_jsx_runtime.JSX.Element;
    InvoiceFilter: (props: PaymentFilterProps) => react_jsx_runtime.JSX.Element;
    InvoiceTable: (props: object) => react_jsx_runtime.JSX.Element;
};
declare const ProtectedInvoiceFilter: (props: PaymentFilterProps) => react_jsx_runtime.JSX.Element;
declare const ProtectedInvoiceTable: (props: object) => react_jsx_runtime.JSX.Element;

type Props$2 = PropsWithChildren & {
    asContainer?: boolean;
};
declare const Payment: {
    ({ children, asContainer, ...rest }: Props$2): react_jsx_runtime.JSX.Element;
    PaymentFilter: (props: PaymentFilterProps$1) => react_jsx_runtime.JSX.Element;
    PaymentTable: (props: object) => react_jsx_runtime.JSX.Element;
};
declare const ProtectedPaymentFilter: (props: PaymentFilterProps$1) => react_jsx_runtime.JSX.Element;
declare const ProtectedPaymentTable: (props: object) => react_jsx_runtime.JSX.Element;

type Props$1 = PropsWithChildren & {
    asContainer?: boolean;
};
declare const Customer: {
    ({ children, asContainer, ...rest }: Props$1): react_jsx_runtime.JSX.Element;
    CustomerTable: (props: {
        title?: string;
        filter?: boolean;
        isSearch?: boolean;
    }) => react_jsx_runtime.JSX.Element;
};
declare const ProtectedCustomerTable: (props: {
    title?: string;
    filter?: boolean;
    isSearch?: boolean;
}) => react_jsx_runtime.JSX.Element;

type Props = PropsWithChildren & {
    asContainer?: boolean;
};
declare const Accounting: ({ children, asContainer, ...rest }: Props) => react_jsx_runtime.JSX.Element;
declare const ProtectedSummary: (props: {
    stringOverrides?: {
        title?: string;
        revenueLabel?: string;
        expensesLabel?: string;
        netProfitLabel?: string;
    };
}) => react_jsx_runtime.JSX.Element;
declare const ProtectedDetailedCharts: (props: {}) => react_jsx_runtime.JSX.Element;
declare const ProtectedExpanse: (props: object) => react_jsx_runtime.JSX.Element;
declare const ProtectedRevenue: (props: object) => react_jsx_runtime.JSX.Element;

export { Accounting, ProtectedBankingData as BakingData, Banking, Button, Calendar, type CalendarProps, Checkbox, CustomMonthPicker, Customer, ProtectedCustomerTable as CustomerTable, DataTable, DatePicker, ProtectedDetailedCharts as DetailedCharts, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, ProtectedExpanse as Expanse, Filter, type Filters, GeneralLedger, IconDatePicker, Input, type InputProps, Invoice, ProtectedInvoiceTable as InvoiceFilter, ProtectedInvoiceFilter as InvoiceTable, Label, type LedgerType, ProtectedLinkedAccounts as LinkedAccountsComponent, Payment, ProtectedPaymentFilter as PaymentFilter, ProtectedPaymentTable as PaymentTable, Popover, PopoverContent, PopoverTrigger, Reports, ProtectedRevenue as Revenue, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, type StringOverrides, ProtectedSummary as Summaries, Switch, Table, TableBody, TableCaption, TableCell, type TableCellPadding, TableFooter, TableHead, TableHeader, TableRow, type TableSize, type TableVariant, Tabs, TabsContent, TabsList, TabsTrigger, ThemeProvider, Toggle, UIContext, UIProvider, buttonVariants, months, tableVariants, toggleVariants, years };