import * as AccordionPrimitive from '@radix-ui/react-accordion';
import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
import { AllowInDimension } from 'recharts/types/util/types';
import { AnimationDuration } from 'recharts/types/util/types';
import { AnimationTiming } from 'recharts/types/util/types';
import * as AvatarPrimitive from '@radix-ui/react-avatar';
import { CartesianViewBox } from 'recharts/types/util/types';
import { ChangeEvent } from 'react';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import { ClassNameValue } from 'tailwind-merge';
import { ClassProp } from 'class-variance-authority/types';
import { ClassValue } from 'clsx';
import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
import { ColumnDef } from '@tanstack/react-table';
import { ComponentType } from 'react';
import { ContentType } from 'recharts/types/component/Tooltip';
import { Context } from 'react';
import { Controller } from 'react-hook-form';
import { ControllerProps } from 'react-hook-form';
import { Coordinate } from 'recharts/types/util/types';
import { DateLib } from 'react-day-picker';
import { DateRange } from 'react-day-picker';
import { DayButton } from 'react-day-picker';
import { DayPicker } from 'react-day-picker';
import { default as default_2 } from 'react';
import { default as default_3 } from 'embla-carousel-react';
import { DevtoolsOptions } from 'zustand/middleware';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import { DialogProps } from '@radix-ui/react-dialog';
import { Draft } from 'immer';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
import { FC } from 'react';
import { FieldError } from 'react-hook-form';
import { FieldErrors } from 'react-hook-form';
import { FieldPath } from 'react-hook-form';
import { FieldValues } from 'react-hook-form';
import { FormProviderProps } from 'react-hook-form';
import { GoogleMaterialIcon } from 'google-material-icons/outlined';
import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
import { HTMLAttributes } from 'react';
import { HtmlHTMLAttributes } from 'react';
import { HugeiconsIconProps } from '@hugeicons/react';
import { JSX } from 'react/jsx-runtime';
import * as LabelPrimitive from '@radix-ui/react-label';
import { LocalizedStrings } from 'react-localization';
import { NameType } from 'recharts/types/component/DefaultTooltipContent';
import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
import { Payload } from 'recharts/types/component/DefaultTooltipContent';
import * as PopoverPrimitive from '@radix-ui/react-popover';
import * as ProgressPrimitive from '@radix-ui/react-progress';
import { PropsWithChildren } from 'react';
import { QueryClient } from '@tanstack/react-query';
import { QueryKey } from '@tanstack/react-query';
import { QuerySessionStatusArgs } from 'oidc-client-ts';
import { QueryStatus } from '@tanstack/react-query';
import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
import * as React_2 from 'react';
import { ReactNode } from 'react';
import * as RechartsPrimitive from 'recharts';
import { RenderProps } from 'input-otp';
import { RevokeTokensTypes } from 'oidc-client-ts';
import { Row } from '@tanstack/react-table';
import { RowSelectionState } from '@tanstack/react-table';
import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
import * as SelectPrimitive from '@radix-ui/react-select';
import * as SeparatorPrimitive from '@radix-ui/react-separator';
import { SeparatorProps } from '@radix-ui/react-separator';
import { SessionStatus } from 'oidc-client-ts';
import { SigninPopupArgs } from 'oidc-client-ts';
import { SigninRedirectArgs } from 'oidc-client-ts';
import { SigninResourceOwnerCredentialsArgs } from 'oidc-client-ts';
import { SigninSilentArgs } from 'oidc-client-ts';
import { SignoutPopupArgs } from 'oidc-client-ts';
import { SignoutRedirectArgs } from 'oidc-client-ts';
import { SignoutSilentArgs } from 'oidc-client-ts';
import * as SliderPrimitive from '@radix-ui/react-slider';
import { Slot } from '@radix-ui/react-slot';
import { SlotProps } from '@radix-ui/react-slot';
import { SlotProps as SlotProps_2 } from 'input-otp';
import { SortingState } from '@tanstack/react-table';
import { StateCreator } from 'zustand';
import { StoreApi } from 'zustand';
import { SubmitHandler } from 'react-hook-form';
import * as SwitchPrimitives from '@radix-ui/react-switch';
import * as TabsPrimitive from '@radix-ui/react-tabs';
import * as ToastPrimitives from '@radix-ui/react-toast';
import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
import * as TogglePrimitive from '@radix-ui/react-toggle';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import { UniqueOption } from 'recharts/types/util/payload/getUniqPayload';
import { UseBoundStore } from 'zustand';
import { useCommandState } from 'cmdk';
import { useController } from 'react-hook-form';
import { UseEmblaCarouselType } from 'embla-carousel-react';
import { useFieldArray } from 'react-hook-form';
import { useForm } from 'react-hook-form';
import { useFormContext } from 'react-hook-form';
import { UseFormProps } from 'react-hook-form';
import { UseFormReturn } from 'react-hook-form';
import { useFormState } from 'react-hook-form';
import { User } from 'oidc-client-ts';
import { UserManager } from 'oidc-client-ts';
import { UserManagerEvents } from 'oidc-client-ts';
import { UserManagerSettings } from 'oidc-client-ts';
import { useWatch } from 'react-hook-form';
import { ValueType as ValueType_3 } from 'recharts/types/component/DefaultTooltipContent';
import { VariantProps } from 'class-variance-authority';
import { VirtualItem } from '@tanstack/react-virtual';
import { VirtualizerOptions } from '@tanstack/react-virtual';
import { WritableDraft } from 'immer';

declare type AcceptedFormatsType = Record<string, string[]>;

export declare const accessibilityTools: UseBoundStore<Omit<Omit<StoreApi<Local_DTO.AccessibilityToolsStore>, "setState" | "devtools"> & {
setState(partial: Local_DTO.AccessibilityToolsStore | Partial<Local_DTO.AccessibilityToolsStore> | ((state: Local_DTO.AccessibilityToolsStore) => Local_DTO.AccessibilityToolsStore | Partial<Local_DTO.AccessibilityToolsStore>), replace?: false | undefined, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
setState(state: Local_DTO.AccessibilityToolsStore | ((state: Local_DTO.AccessibilityToolsStore) => Local_DTO.AccessibilityToolsStore), replace: true, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
devtools: {
cleanup: () => void;
};
}, "setState"> & {
setState(nextStateOrUpdater: Local_DTO.AccessibilityToolsStore | Partial<Local_DTO.AccessibilityToolsStore> | ((state: WritableDraft<Local_DTO.AccessibilityToolsStore>) => void), shouldReplace?: false, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
setState(nextStateOrUpdater: Local_DTO.AccessibilityToolsStore | ((state: WritableDraft<Local_DTO.AccessibilityToolsStore>) => void), shouldReplace: true, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
}>;

export declare const Accordion: React_2.ForwardRefExoticComponent<((Omit<AccordionPrimitive.AccordionSingleProps & React_2.RefAttributes<HTMLDivElement>, "ref"> | Omit<AccordionPrimitive.AccordionMultipleProps & React_2.RefAttributes<HTMLDivElement>, "ref">) & AccordionToggleType) & React_2.RefAttributes<HTMLDivElement>>;

export declare const AccordionContent: React_2.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const AccordionItem: React_2.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

declare type AccordionToggleType = {
    size?: 'default' | 'sm' | 'xs';
    isLeading?: boolean;
};

export declare const AccordionTrigger: React_2.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

declare type Action = {
    type: ActionType['ADD_TOAST'];
    toast: ToasterToast;
} | {
    type: ActionType['UPDATE_TOAST'];
    toast: Partial<ToasterToast>;
} | {
    type: ActionType['DISMISS_TOAST'];
    toastId?: ToasterToast['id'];
} | {
    type: ActionType['REMOVE_TOAST'];
    toastId?: ToasterToast['id'];
};

declare type Action_2 = {
    type: 'INITIALISED' | 'USER_LOADED';
    user: User | null;
} | {
    type: 'USER_UNLOADED';
} | {
    type: 'USER_SIGNED_OUT';
} | {
    type: 'NAVIGATOR_INIT';
    method: NonNullable<AuthState['activeNavigator']>;
} | {
    type: 'NAVIGATOR_CLOSE';
} | {
    type: 'ERROR';
    error: Error;
};

export declare const ActionLoader: ({ className }: {
    className?: string;
}) => JSX.Element;

declare type ActionType = typeof actionTypes;

declare const actionTypes: {
    readonly ADD_TOAST: "ADD_TOAST";
    readonly UPDATE_TOAST: "UPDATE_TOAST";
    readonly DISMISS_TOAST: "DISMISS_TOAST";
    readonly REMOVE_TOAST: "REMOVE_TOAST";
};

export declare const Alert: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
    variant?: "default" | "outline" | "ghost" | null | undefined;
    colors?: "error" | "default" | "info" | "warning" | "primary" | "secondary" | null | undefined;
} & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLDivElement>>;

export declare const AlertDescription: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare const AlertDialog: React_2.FC<AlertDialogPrimitive.AlertDialogProps>;

export declare const AlertDialogAction: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

export declare const AlertDialogCancel: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

export declare const AlertDialogContent: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    overlayClassName?: string;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const AlertDialogDescription: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare const AlertDialogFooter: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
    displayName: string;
};

export declare const AlertDialogHeader: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
    displayName: string;
};

export declare const AlertDialogOverlay: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const AlertDialogPortal: React_2.FC<AlertDialogPrimitive.AlertDialogPortalProps>;

export declare const AlertDialogTitle: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;

export declare const AlertDialogTrigger: React_2.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare const AlertTitle: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLHeadingElement> & React_2.RefAttributes<HTMLParagraphElement>>;

declare type AllowedElements = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';

declare type AllowedElements_2 = 'span' | 'label' | 'p';

export declare namespace API_DTO { }

export declare enum ArabicMonth {
    'يناير' = 0,
    'فبراير' = 1,
    'مارس' = 2,
    'أبريل' = 3,
    'مايو' = 4,
    'يونيو' = 5,
    'يوليو' = 6,
    'أغسطس' = 7,
    'سبتمبر' = 8,
    'اكتوبر' = 9,
    'نوفمبر' = 10,
    'ديسمبر' = 11
}

/**
 * @public
 */
export declare const AuthContext: default_2.Context<AuthContextProps | undefined>;

/**
 * @public
 */
export declare interface AuthContextProps extends AuthState {
    /**
     * UserManager functions. See [UserManager](https://github.com/authts/oidc-client-ts) for more details.
     */
    readonly settings: UserManagerSettings;
    readonly events: UserManagerEvents;
    clearStaleState(): Promise<void>;
    removeUser(): Promise<void>;
    signinPopup(args?: SigninPopupArgs): Promise<User>;
    signinSilent(args?: SigninSilentArgs): Promise<User | null>;
    signinRedirect(args?: SigninRedirectArgs): Promise<void>;
    signinResourceOwnerCredentials(args: SigninResourceOwnerCredentialsArgs): Promise<User>;
    signoutRedirect(args?: SignoutRedirectArgs): Promise<void>;
    signoutPopup(args?: SignoutPopupArgs): Promise<void>;
    signoutSilent(args?: SignoutSilentArgs): Promise<void>;
    querySessionStatus(args?: QuerySessionStatusArgs): Promise<SessionStatus | null>;
    revokeTokens(types?: RevokeTokensTypes): Promise<void>;
    startSilentRenew(): void;
    stopSilentRenew(): void;
}

/**
 * Provides the AuthContext to its child components.
 *
 * @public
 */
export declare const AuthProvider: (props: AuthProviderProps) => default_2.JSX.Element;

/**
 * @public
 */
export declare interface AuthProviderBaseProps {
    /**
     * The child nodes your Provider has wrapped
     */
    children?: default_2.ReactNode;
    /**
     * On sign in callback hook. Can be a async function.
     * Here you can remove the code and state parameters from the url when you are redirected from the authorize page.
     *
     * ```jsx
     * const onSigninCallback = (_user: User | void): void => {
     *     window.history.replaceState(
     *         {},
     *         document.title,
     *         window.location.pathname
     *     )
     * }
     * ```
     */
    onSigninCallback?: (user: User | void) => Promise<void> | void;
    /**
     * By default, if the page url has code/state params, this provider will call automatically the `userManager.signinCallback`.
     * In some cases the code might be for something else (another OAuth SDK perhaps). In these
     * instances you can instruct the client to ignore them.
     *
     * ```jsx
     * <AuthProvider
     *   skipSigninCallback={window.location.pathname === "/stripe-oauth-callback"}
     * >
     * ```
     */
    skipSigninCallback?: boolean;
    /**
     * Match the redirect uri used for logout (e.g. `post_logout_redirect_uri`)
     * This provider will then call automatically the `userManager.signoutCallback`.
     *
     * HINT:
     * Do not call `userManager.signoutRedirect()` within a `React.useEffect`, otherwise the
     * logout might be unsuccessful.
     *
     * ```jsx
     * <AuthProvider
     *   matchSignoutCallback={(args) => {
     *     window &&
     *     (window.location.href === args.post_logout_redirect_uri);
     *   }}
     * ```
     */
    matchSignoutCallback?: (args: UserManagerSettings) => boolean;
    /**
     * On sign out callback hook. Can be a async function.
     * Here you can change the url after the user is signed out.
     * When using this, specifying `matchSignoutCallback` is required.
     *
     * ```jsx
     * const onSignoutCallback = (): void => {
     *     // go to home after logout
     *     window.location.pathname = ""
     * }
     * ```
     */
    onSignoutCallback?: () => Promise<void> | void;
    /**
     * On remove user hook. Can be a async function.
     * Here you can change the url after the user is removed.
     *
     * ```jsx
     * const onRemoveUser = (): void => {
     *     // go to home after logout
     *     window.location.pathname = ""
     * }
     * ```
     */
    onRemoveUser?: () => Promise<void> | void;
}

/**
 * This interface (default) is used to pass `UserManagerSettings` together with `AuthProvider` properties to the provider.
 *
 * @public
 */
export declare interface AuthProviderNoUserManagerProps extends AuthProviderBaseProps, UserManagerSettings {
    /**
     * Prevent this property.
     */
    userManager?: never;
}

/**
 * @public
 */
export declare type AuthProviderProps = AuthProviderNoUserManagerProps | AuthProviderUserManagerProps;

/**
 * This interface is used to pass directly a `UserManager` instance together with `AuthProvider` properties to the provider.
 *
 * @public
 */
export declare interface AuthProviderUserManagerProps extends AuthProviderBaseProps {
    /**
     * Allow passing a custom UserManager instance.
     */
    userManager?: UserManager;
}

export declare class AuthService implements IAuthService {
    private static instance;
    private userManager;
    private config;
    user?: User | null;
    isLoading: boolean;
    isAuthenticated: boolean;
    error?: Error;
    private constructor();
    static getInstance(config: OIDCConfig): AuthService;
    private setupEventListeners;
    hasAuthParams(location?: Location): boolean;
    signin(customParams?: Record<string, any>): Promise<void>;
    completeSignIn(): Promise<void | User>;
    getUser(): Promise<User | null>;
    refreshToken(): Promise<User | null>;
    /**
     * function to call another url to kill opend session with 'sso service'
     */
    clearSession(): Promise<void>;
    /**
     * Revokes a token (access_token or refresh_token) by calling the revocation endpoint
     */
    private revokeToken;
    signout: (redirectUrl?: string) => Promise<void>;
}

/**
 * The auth state which, when combined with the auth methods, make up the return object of the `useAuth` hook.
 *
 * @public
 */
export declare interface AuthState {
    /**
     * See [User](https://authts.github.io/oidc-client-ts/classes/User.html) for more details.
     */
    user?: User | null;
    /**
     * True when the library has been initialized and no navigator request is in progress.
     */
    isLoading: boolean;
    /**
     * True while the user has a valid access token.
     */
    isAuthenticated: boolean;
    /**
     * Tracks the status of most recent signin/signout request method.
     */
    activeNavigator?: 'signinRedirect' | 'signinResourceOwnerCredentials' | 'signinPopup' | 'signinSilent' | 'signoutRedirect' | 'signoutPopup' | 'signoutSilent';
    /**
     * Was there a signin or silent renew error?
     */
    error?: Error;
}

export declare const authStore: UseBoundStore<Omit<Omit<StoreApi<Local_DTO.AuthStore>, "setState" | "devtools"> & {
setState(partial: Local_DTO.AuthStore | Partial<Local_DTO.AuthStore> | ((state: Local_DTO.AuthStore) => Local_DTO.AuthStore | Partial<Local_DTO.AuthStore>), replace?: false | undefined, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
setState(state: Local_DTO.AuthStore | ((state: Local_DTO.AuthStore) => Local_DTO.AuthStore), replace: true, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
devtools: {
cleanup: () => void;
};
}, "setState"> & {
setState(nextStateOrUpdater: Local_DTO.AuthStore | Partial<Local_DTO.AuthStore> | ((state: WritableDraft<Local_DTO.AuthStore>) => void), shouldReplace?: false, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
setState(nextStateOrUpdater: Local_DTO.AuthStore | ((state: WritableDraft<Local_DTO.AuthStore>) => void), shouldReplace: true, action?: (string | {
[x: string]: unknown;
[x: number]: unknown;
[x: symbol]: unknown;
type: string;
}) | undefined): void;
}>;

/**
 * Direct-input single-select Autocomplete with a suggestions popover.
 *
 * - Debounces remote queries via `onSearch` + `debounceTime`.
 * - Filters provided `options` locally by `label` and `keywords` when
 *   `filterOptions` is true (default).
 * - Virtualizes long lists with `@tanstack/react-virtual` based on
 *   `virtualized` and `virtualizeThreshold`.
 *
 * @example Basic local usage
 * ```tsx
 * const [value, setValue] = useState<string | null>(null)
 * <Autocomplete
 *   options={countries}
 *   value={value}
 *   onChange={(opt) => setValue(opt?.value ?? null)}
 * />
 * ```
 *
 * @example Remote async search
 * ```tsx
 * <Autocomplete
 *   options={results}
 *   value={value}
 *   inputValue={query}
 *   onInputChange={setQuery}
 *   onSearch={fetchUsers}
 *   filterOptions={false}
 *   isLoading={loading}
 *   onChange={(opt) => setValue(opt?.value ?? null)}
 * />
 * ```
 */
export declare function Autocomplete<T extends ValueType = ValueType>({ options, value, inputValue: controlledInputValue, onChange, onInputChange, onSearch, filterOptions, virtualized, virtualizeThreshold, itemSize, maxListHeight, debounceTime, placeholder, disabled, isLoading, emptyMessage, renderItem, className, contentClassName, dataTestId, modal, name, id, autoFocus, openOnFocus, showSearchIcon, showClearButton, variant, rounded, colors, size, }: Readonly<AutocompleteProps<T>>): JSX.Element;

/**
 * A single option rendered in the Autocomplete suggestions list.
 */
export declare interface AutocompleteOption<T extends ValueType = ValueType> {
    /** Text displayed in the suggestions list and used for local filtering. */
    label: string;
    /** Unique value committed to the parent via `onChange` when the option is selected. */
    value: T;
    /** Additional terms matched against the user query when local filtering is enabled. */
    keywords?: string[];
    /** When true, the option is rendered but cannot be selected. */
    disabled?: boolean;
}

/**
 * Props for the `Autocomplete` component — a debounced, optionally virtualized,
 * single-select text input with a suggestions popover.
 *
 * Supports two data modes:
 *  - **Local**: pass `options` and keep `filterOptions={true}` (default).
 *  - **Remote**: pass `onSearch` (and usually `filterOptions={false}`); the parent
 *    fetches results and feeds them back via `options` and `isLoading`.
 */
export declare interface AutocompleteProps<T extends ValueType = ValueType> extends VariantProps<typeof inputVariants> {
    /** The list of available options to display in the suggestions popover. */
    options: AutocompleteOption<T>[];
    /** The currently selected option's value, or `null` when no option is selected. */
    value?: T | null;
    /**
     * Controlled text shown in the input. When omitted, the component manages
     * its own input state internally and seeds it from the label of `value`.
     */
    inputValue?: string;
    /**
     * Called when the user picks an option (or clears the selection).
     * Receives the full option object or `null`.
     */
    onChange: (option: AutocompleteOption<T> | null) => void;
    /**
     * Called on every keystroke with the new input text. Useful when you need
     * to control the input value externally (e.g. for remote search).
     */
    onInputChange?: (value: string) => void;
    /**
     * Called with the input text after `debounceTime` has elapsed since the
     * last keystroke. Use this to trigger a remote search.
     */
    onSearch?: (value: string) => void;
    /**
     * When true, the component filters `options` locally by `label` and
     * `keywords` against the current input. Disable when filtering happens
     * on the server.
     * @default true
     */
    filterOptions?: boolean;
    /**
     * Controls list virtualization with `@tanstack/react-virtual`.
     * - `true`: always virtualize.
     * - `false`: never virtualize.
     * - `'auto'`: virtualize when the filtered list exceeds `virtualizeThreshold`.
     * @default 'auto'
     */
    virtualized?: boolean | 'auto';
    /**
     * Number of items above which virtualization kicks in when `virtualized` is `'auto'`.
     * @default 100
     */
    virtualizeThreshold?: number;
    /**
     * Estimated row height in pixels used by the virtualizer.
     * @default 36
     */
    itemSize?: number;
    /**
     * Maximum height in pixels of the scrollable suggestions list.
     * @default 300
     */
    maxListHeight?: number;
    /**
     * Delay in milliseconds before `onSearch` is invoked after the last keystroke.
     * @default 300
     */
    debounceTime?: number;
    /** Placeholder text shown when the input is empty. */
    placeholder?: string;
    /** When true, the input is non-interactive and the popover stays closed. */
    disabled?: boolean;
    /**
     * When true, shows a loading indicator inside the input. Typically driven
     * by the parent during a remote `onSearch` call.
     * @default false
     */
    isLoading?: boolean;
    /**
     * Content shown inside the popover when no options match the query.
     * @default 'No data found' (from i18n strings)
     */
    emptyMessage?: ReactNode;
    /** Optional custom renderer for each option. Falls back to `option.label`. */
    renderItem?: (option: AutocompleteOption<T>) => ReactNode;
    /** Extra class names applied to the input wrapper. */
    className?: string;
    /** Extra class names applied to the popover content. */
    contentClassName?: string;
    /**
     * Base value used to generate `data-testid` attributes on the input and
     * each rendered option (suffixed with `-option-<value>`).
     */
    dataTestId?: string;
    /**
     * Passed through to the underlying Radix Popover. When true, the popover
     * behaves modally and traps focus.
     */
    modal?: boolean;
    /** `name` attribute forwarded to the underlying input (useful with forms). */
    name?: string;
    /** `id` attribute forwarded to the underlying input. */
    id?: string;
    /** When true, focuses the input on mount. */
    autoFocus?: boolean;
    /**
     * When true, opens the suggestions popover as soon as the input receives focus.
     * @default true
     */
    openOnFocus?: boolean;
    /**
     * When true, renders the leading search icon inside the input.
     * @default true
     */
    showSearchIcon?: boolean;
    /**
     * When true, renders the trailing clear button while the input has text.
     * @default true
     */
    showClearButton?: boolean;
}

export declare const Avatar: React_2.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React_2.RefAttributes<HTMLSpanElement>, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;

export declare const AvatarFallback: React_2.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React_2.RefAttributes<HTMLSpanElement>, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;

export declare const AvatarImage: React_2.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React_2.RefAttributes<HTMLImageElement>, "ref"> & React_2.RefAttributes<HTMLImageElement>>;

export declare function Badge({ className, variant, size, rounded, colors, disabled, ...props }: BadgeProps): JSX.Element;

export declare interface BadgeProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
}

export declare const badgeVariants: (props?: ({
    variant?: "default" | "outline" | "ghost" | null | undefined;
    size?: "default" | "sm" | "xs" | null | undefined;
    rounded?: "full" | "default" | null | undefined;
    colors?: "error" | "success" | "info" | "warning" | "primary" | "secondary" | "tertiary" | "gray" | null | undefined;
    disabled?: boolean | null | undefined;
} & ClassProp) | undefined) => string;

export declare const Bootstrap: ({ children, onLanguageChange, onDirChange }: BootstrapProps) => ReactNode;

declare interface BootstrapProps extends PropsWithChildren {
    onLanguageChange?: () => void;
    onDirChange?: () => void;
}

declare interface BottomSectionProps {
    basicLinks?: FooterLink[];
    extraLinks?: FooterLink[];
    bottomImages?: default_2.ReactNode[];
    copyrightText?: string;
    colors?: Colors;
    showBasicLinks?: boolean;
    developedByText?: string;
    versionNumber?: string;
}

export declare const Breadcrumb: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
    separator?: React_2.ReactNode;
} & React_2.RefAttributes<HTMLElement>>;

export declare const BreadcrumbEllipsis: {
    ({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;
    displayName: string;
};

export declare const BreadcrumbItem: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React_2.RefAttributes<HTMLLIElement>>;

export declare const BreadcrumbLink: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
    asChild?: boolean;
    as?: typeof Slot;
    style?: React_2.CSSProperties;
} & React_2.RefAttributes<HTMLAnchorElement>>;

export declare const BreadcrumbList: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React_2.RefAttributes<HTMLOListElement>>;

export declare const BreadcrumbPage: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;

export declare const Breadcrumbs: {
    ({ items, dir }: PropsBreadcrumb): JSX.Element;
    displayName: string;
};

export declare const BreadcrumbSeparator: {
    ({ children, className, ...props }: React_2.ComponentProps<"li">): JSX.Element;
    displayName: string;
};

export declare const Button: React_2.ForwardRefExoticComponent<ButtonProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare interface ButtonProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
    asChild?: boolean;
    tooltip?: string;
    tooltipSide?: "top" | "bottom" | "right" | "left";
    isLoading?: boolean;
}

declare interface ButtonPropsExtend extends default_2.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof selectVariants> {
    isLoading?: boolean;
    isForm?: boolean;
    startAdornment?: ReactNode;
    placeholder?: string;
}

export declare const buttonVariants: (props?: ({
    variant?: "link" | "text" | "default" | "outline" | "ghost" | null | undefined;
    size?: "default" | "sm" | "xs" | "icon" | "icon-sm" | "icon-xs" | null | undefined;
    rounded?: "full" | "default" | null | undefined;
    colors?: "error" | "success" | "info" | "warning" | "primary" | "neutral" | "oncolor" | "secondary" | "tertiary" | "gray" | null | undefined;
} & ClassProp) | undefined) => string;

export declare const Card: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & {
    isClickable?: boolean;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const CardContent: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CardDescription: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare const CardFooter: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CardHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CardTitle: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLHeadingElement> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare function Carousel({ children, className, itemClassName, showDots, showArrows, loop, autoplay, autoplayInterval, containerClassName, maxDots, itemWidth, slidesToShow, showPartial, dir, type, slidesToScroll, }: Readonly<CustomCarouselProps>): JSX.Element;

export declare type CarouselApi = UseEmblaCarouselType[1];

export declare const CarouselContent: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CarouselItem: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;

declare type CarouselOptions = UseCarouselParameters[0];

declare type CarouselPlugin = UseCarouselParameters[1];

export declare const CarouselPrimitive: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & CarouselProps & React_2.RefAttributes<HTMLDivElement>>;

declare type CarouselProps = {
    opts?: CarouselOptions;
    plugins?: CarouselPlugin;
    orientation?: 'horizontal' | 'vertical';
    setApi?: (api: CarouselApi) => void;
};

export declare type ChartConfig = {
    [k in string]: {
        label?: React_2.ReactNode;
        icon?: React_2.ComponentType;
    } & ({
        color?: string;
        theme?: never;
    } | {
        color?: never;
        theme: Record<keyof typeof THEMES, string>;
    });
};

export declare const ChartContainer: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & {
    config: ChartConfig;
    children: React_2.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
}, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const ChartLegend: typeof RechartsPrimitive.Legend;

export declare const ChartLegendContent: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
    hideIcon?: boolean;
    nameKey?: string;
}, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const ChartStyle: ({ id, config }: {
    id: string;
    config: ChartConfig;
}) => JSX.Element | null;

export declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;

export declare const ChartTooltipContent: React_2.ForwardRefExoticComponent<Omit<RechartsPrimitive.DefaultTooltipContentProps<ValueType_3, NameType> & {
    accessibilityLayer?: boolean;
    active?: boolean | undefined;
    includeHidden?: boolean | undefined;
    allowEscapeViewBox?: AllowInDimension;
    animationDuration?: AnimationDuration;
    animationEasing?: AnimationTiming;
    content?: ContentType<ValueType_3, NameType> | undefined;
    coordinate?: Partial<Coordinate>;
    cursor?: boolean | React_2.ReactElement | React_2.SVGProps<SVGElement>;
    filterNull?: boolean;
    defaultIndex?: number;
    isAnimationActive?: boolean;
    offset?: number;
    payloadUniqBy?: UniqueOption<Payload<ValueType_3, NameType>> | undefined;
    position?: Partial<Coordinate>;
    reverseDirection?: AllowInDimension;
    shared?: boolean;
    trigger?: "hover" | "click";
    useTranslate3d?: boolean;
    viewBox?: CartesianViewBox;
    wrapperStyle?: React_2.CSSProperties;
} & React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & {
    hideLabel?: boolean;
    hideIndicator?: boolean;
    indicator?: "line" | "dot" | "dashed";
    nameKey?: string;
    labelKey?: string;
}, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const Checkbox: React_2.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
    colors?: "primary" | "neutral" | null | undefined;
    size?: "default" | "sm" | "xs" | null | undefined;
} & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLButtonElement>>;

export declare function cn(...inputs: ClassValue[]): string;

export declare const Collapsible: React_2.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React_2.RefAttributes<HTMLDivElement>>;

export declare const CollapsibleContent: React_2.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & React_2.RefAttributes<HTMLDivElement>>;

export declare const CollapsibleTrigger: React_2.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

declare type Colors = 'default' | 'neutral';

export { ColumnDef }

export declare const Combobox: typeof Popover;

export declare const ComboboxContent: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & default_2.RefAttributes<HTMLDivElement>>;

export declare const ComboboxControl: <_, T>({ options, optionLabel, placeholder, isLoading, optionValue, onChange, value, renderItem, isDate, triggerProps, contentClassName, modal, keywords, ...rest }: Props<T>) => JSX.Element;

export declare const ComboboxControlNoForm: <_, T>({ options, optionLabel, placeholder, isLoading, optionValue, renderItem, onChange, value, triggerProps, isDate, disabledOption, contentClassName, modal, keywords, ...rest }: Props<T>) => JSX.Element;

export declare const ComboboxEmpty: default_2.ForwardRefExoticComponent<Omit<{
    children?: default_2.ReactNode;
} & Pick<Pick<default_2.DetailedHTMLProps<default_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof default_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: default_2.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "key" | "asChild" | keyof default_2.HTMLAttributes<HTMLDivElement>> & default_2.RefAttributes<HTMLDivElement>, "ref"> & default_2.RefAttributes<HTMLDivElement>>;

export declare const ComboboxGroup: default_2.ForwardRefExoticComponent<Omit<Omit<{
    children?: default_2.ReactNode;
} & Omit<Pick<Pick<default_2.DetailedHTMLProps<default_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof default_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: default_2.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "key" | "asChild" | keyof default_2.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
    heading?: default_2.ReactNode;
    value?: string;
    forceMount?: boolean;
} & default_2.RefAttributes<HTMLDivElement>, "ref"> & default_2.RefAttributes<HTMLDivElement>, "ref"> & {
    placeholder?: string;
} & default_2.RefAttributes<HTMLDivElement>>;

export declare const ComboboxInput: default_2.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<default_2.DetailedHTMLProps<default_2.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof default_2.InputHTMLAttributes<HTMLInputElement>> & {
    ref?: default_2.Ref<HTMLInputElement>;
} & {
    asChild?: boolean;
}, "key" | "asChild" | keyof default_2.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
    value?: string;
    onValueChange?: (search: string) => void;
} & default_2.RefAttributes<HTMLInputElement>, "ref"> & default_2.RefAttributes<HTMLInputElement>>;

export declare const ComboboxItem: default_2.ForwardRefExoticComponent<Omit<{
    children?: default_2.ReactNode;
} & Omit<Pick<Pick<default_2.DetailedHTMLProps<default_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof default_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: default_2.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "key" | "asChild" | keyof default_2.HTMLAttributes<HTMLDivElement>>, "value" | "onSelect" | "disabled"> & {
    disabled?: boolean;
    onSelect?: (value: string) => void;
    value?: string;
    keywords?: string[];
    forceMount?: boolean;
} & default_2.RefAttributes<HTMLDivElement>, "ref"> & default_2.RefAttributes<HTMLDivElement>>;

export declare const ComboboxTrigger: default_2.ForwardRefExoticComponent<ButtonPropsExtend & default_2.RefAttributes<HTMLButtonElement>>;

export declare const Command: React_2.ForwardRefExoticComponent<Omit<{
    children?: React_2.ReactNode;
} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    label?: string;
    shouldFilter?: boolean;
    filter?: (value: string, search: string, keywords?: string[]) => number;
    defaultValue?: string;
    value?: string;
    onValueChange?: (value: string) => void;
    loop?: boolean;
    disablePointerSelection?: boolean;
    vimBindings?: boolean;
} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandDialog: ({ children, ...props }: CommandDialogProps) => JSX.Element;

declare interface CommandDialogProps extends DialogProps {
    disabled?: boolean;
}

export declare const CommandEmpty: React_2.ForwardRefExoticComponent<Omit<{
    children?: React_2.ReactNode;
} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>> & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandGroup: React_2.ForwardRefExoticComponent<Omit<{
    children?: React_2.ReactNode;
} & Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
    heading?: React_2.ReactNode;
    value?: string;
    forceMount?: boolean;
} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandInput: React_2.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React_2.InputHTMLAttributes<HTMLInputElement>> & {
    ref?: React_2.Ref<HTMLInputElement>;
} & {
    asChild?: boolean;
}, "key" | "asChild" | keyof React_2.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
    value?: string;
    onValueChange?: (search: string) => void;
} & React_2.RefAttributes<HTMLInputElement>, "ref"> & React_2.RefAttributes<HTMLInputElement>>;

export declare const CommandItem: React_2.ForwardRefExoticComponent<Omit<{
    children?: React_2.ReactNode;
} & Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>>, "value" | "onSelect" | "disabled"> & {
    disabled?: boolean;
    onSelect?: (value: string) => void;
    value?: string;
    keywords?: string[];
    forceMount?: boolean;
} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandList: React_2.ForwardRefExoticComponent<Omit<{
    children?: React_2.ReactNode;
} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    label?: string;
} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandSeparator: React_2.ForwardRefExoticComponent<Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    alwaysRender?: boolean;
} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const CommandShortcut: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): JSX.Element;
    displayName: string;
};

export { Controller }

export declare const createIdentityConfig: (config: OIDCConfig) => {
    authority: string;
    client_id: string;
    client_secret: string | undefined;
    redirect_uri: string;
    login: string;
    automaticSilentRenew: boolean;
    loadUserInfo: boolean;
    silent_redirect_uri: string;
    post_logout_redirect_uri: string;
    audience: string;
    responseType: string;
    grantType: string;
    scope: string;
    webAuthResponseType: string;
    disablePKCE: boolean;
};

export declare const createMetadataConfig: (authUrl: string, jwks: string) => {
    issuer: string;
    jwks_uri: string;
    authorization_endpoint: string;
    token_endpoint: string;
    userinfo_endpoint: string;
    end_session_endpoint: string;
    check_session_iframe: string;
    revocation_endpoint: string;
    introspection_endpoint: string;
};

declare interface CustomCarouselProps {
    children: React_2.ReactNode;
    className?: string;
    itemClassName?: string;
    showDots?: boolean;
    showArrows?: boolean;
    loop?: boolean;
    autoplay?: boolean;
    autoplayInterval?: number;
    containerClassName?: string;
    maxDots?: number | null;
    itemWidth?: number | string;
    slidesToShow?: number;
    showPartial?: boolean;
    dir?: 'ltr' | 'rtl';
    type?: 'single' | 'multiple';
    slidesToScroll?: number | 'auto';
}

export declare function d2g(jdn: number): {
    gy: number;
    gm: number;
    gd: number;
};

export declare function d2h(jdn: number): {
    hy: number;
    hm: number;
    hd: number;
};

export declare function DataTable<TData, TValue>({ columns, data, loading, NoDataComponent, itemsPerPage, hasPagination, onClickRow, isFirstRowSelected, enableRowSelection, enableMultiRowSelection, rowSelection, onRowSelectionChange, onSortingChange, theme, variant, alternating, contained, showTotalResults, showOnSmallScreen, ...rest }: DataTableProps<TData, TValue> & tableProps): JSX.Element | null;

declare interface DataTableProps<TData, TValue> {
    columns: ColumnDef<TData, TValue>[];
    data: TData[];
    loading: boolean;
    NoDataComponent?: default_2.ReactNode;
    onPageChange?: (number: number) => void;
    totalItems?: number;
    pageNumber?: number;
    itemsPerPage?: number;
    setLimit?: (number: number) => void;
    hasPagination?: boolean;
    isFirstRowSelected?: boolean;
    onClickRow?: (data: Row<TData>) => void;
    enableRowSelection?: boolean;
    enableMultiRowSelection?: boolean;
    rowSelection?: RowSelectionState;
    onRowSelectionChange?: (updater: RowSelectionState | ((old: RowSelectionState) => RowSelectionState)) => void;
    onSortingChange?: (sorting: SortingState) => void;
    theme?: Theme;
    showTotalResults?: boolean;
    showOnSmallScreen?: boolean;
}

export declare enum DateFormat {
    ArShort = "DD MMMM YYYY",
    EnShort = "MMM DD, YYYY"
}

export declare const dateFormatter: ({ date, format, isHijri, hasHijriFormat, }: {
    date: string | Date | undefined;
    format: "short" | "mid" | "long";
    isHijri?: boolean;
    hasHijriFormat?: boolean;
}) => string;

export { DateLib }

export declare function DatePicker({ lang, controlProps, dir, shouldDisableDate, isWeekendDisable, customTrigger, hijriToggle, disablePast, closeOnSelect, sideOffset, modal, ...rest }: Props_3): JSX.Element;

export { DateRange }

export declare function DayCalendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, lang, ...props }: React_2.ComponentProps<typeof DayPicker> & {
    buttonVariant?: React_2.ComponentProps<typeof Button>['variant'];
}): JSX.Element;

export declare function DayCalendarDayButton({ className, day, modifiers, ...props }: React_2.ComponentProps<typeof DayButton>): JSX.Element;

export declare function daysInMonth(year: number, month: number): number;

export declare function debounce<T extends (...args: any[]) => void>(func: T, wait: number): T;

export declare const Description: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & {
    children?: default_2.ReactNode | undefined;
} & default_2.RefAttributes<HTMLDivElement>>;

export declare const DescriptionItem: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDListElement> & {
    title: string;
    icon?: HugeiconsIconProps["icon"] | GoogleMaterialIcon;
    isSingleLine?: boolean;
} & VariantProps<(props?: ({
    variant?: "list" | "default" | null | undefined;
    size?: "default" | "sm" | null | undefined;
    orientation?: "vertical" | "horizental" | null | undefined;
    lastItem?: boolean | null | undefined;
    stretch?: boolean | null | undefined;
    padding?: "none" | "default" | null | undefined;
} & ClassProp) | undefined) => string> & {
    children?: default_2.ReactNode | undefined;
} & default_2.RefAttributes<HTMLDListElement>>;

export declare type DescriptionProps = {
    title: string;
    icon?: HugeiconsIconProps['icon'] | GoogleMaterialIcon;
    isSingleLine?: boolean;
} & VariantProps<typeof dlVariants>;

export declare const DevtoolsMiddlewares: <T>(f: StateCreator<T, [["zustand/devtools", never], ["zustand/immer", never]]>, devtoolsOptions?: DevtoolsOptions) => StateCreator<T, [], [["zustand/devtools", never], ["zustand/immer", never]]>;

export declare const Dialog: React_2.FC<DialogPrimitive.DialogProps>;

export declare const DialogBody: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DialogClose: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare const DialogContent: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    ignoreInteractOutside?: boolean;
    hideOverlay?: boolean;
    overlayClassName?: string;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const DialogDescription: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare const DialogFooter: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
    displayName: string;
};

export declare const DialogHeader: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
    displayName: string;
};

export declare const DialogOverlay: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DialogPortal: React_2.FC<DialogPrimitive.DialogPortalProps>;

export declare const DialogTitle: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;

export declare const DialogTrigger: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare const DigitalSignature: ({ extension, linkProps, children, ...props }: DigitalSignatureProps) => JSX.Element;

declare interface DigitalSignatureProps extends HtmlHTMLAttributes<HTMLDivElement> {
    extension?: extensions;
    linkProps?: LinkProps;
}

declare const dlVariants: (props?: ({
    variant?: "list" | "default" | null | undefined;
    size?: "default" | "sm" | null | undefined;
    orientation?: "vertical" | "horizental" | null | undefined;
    lastItem?: boolean | null | undefined;
    stretch?: boolean | null | undefined;
    padding?: "none" | "default" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function DraggableGrid({ configs, isEditMode, componentMap, onConfigChange, onOrderChange, onSave, onCancel, onReset, onAdd, isSidePanelShown, isSaving, }: Readonly<DraggableGridProps>): JSX.Element;

declare interface DraggableGridProps {
    configs: WidgetConfig[];
    isEditMode: boolean;
    componentMap: Record<string, React.ComponentType<WidgetBaseProps>>;
    onConfigChange: (changes: Partial<WidgetConfig>) => void;
    onOrderChange: (newConfigs: WidgetConfig[]) => void;
    onSave?: () => void;
    onCancel?: () => void;
    onReset?: () => void;
    onAdd?: () => void;
    isSidePanelShown?: boolean;
    isSaving?: boolean;
}

export declare const DropdownMenu: React_2.FC<DropdownMenuPrimitive.DropdownMenuProps>;

export declare const DropdownMenuCheckboxItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuContent: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuLabel: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuPortal: React_2.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;

export declare const DropdownMenuRadioGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuRadioItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuSeparator: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuShortcut: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): JSX.Element;
    displayName: string;
};

export declare const DropdownMenuSub: React_2.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;

export declare const DropdownMenuSubContent: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuSubTrigger: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuTrigger: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare const Emoji: ({ variant, size, disabled, className, ...props }: EmojiProps) => JSX.Element;

export declare interface EmojiProps extends React.SVGProps<SVGSVGElement>, VariantProps<typeof EmojiVariants> {
}

declare const EmojiVariants: (props?: ({
    variant?: "awful" | "bad" | "ok" | "good" | "great" | null | undefined;
    size?: "default" | null | undefined;
    disabled?: boolean | null | undefined;
} & ClassProp) | undefined) => string;

export declare const EmptySection: default_2.FC<EmptySectionProps>;

export declare interface EmptySectionProps extends VariantProps<typeof emptySectionVariants> {
    className?: string;
    title?: string;
    description?: string | default_2.ReactNode;
    icon?: default_2.ReactNode;
    children?: default_2.ReactNode;
    bordered?: boolean;
}

declare const emptySectionVariants: (props?: ({
    layout?: "horizontal" | "vertical" | null | undefined;
    background?: "gray" | "white" | "transparent" | null | undefined;
} & ClassProp) | undefined) => string;

declare type extensions = '.gov.sa' | '.edu.sa' | '.org.sa' | '.sch.sa' | '.sa';

declare interface Extra {
    startAdornment?: React_2.ReactNode | string;
    endAdornment?: React_2.ReactNode | string;
}

declare interface Extra_2 {
    startAdornment?: React_2.ReactNode | string;
    endAdornment?: React_2.ReactNode | string;
}

export { FieldError }

export { FieldErrors }

export { FieldValues }

export declare type FileInfo = {
    id: string;
    file: File;
    progress: number;
    status?: 'uploading' | 'success' | 'error';
    error?: string;
};

export declare function FileUpload({ acceptedFormats, onFileSelect, multiple, disabled, maxSize, maxFiles, customError, isInvalid, isRequired, label, browseLabel, description, value, onChange, }: Readonly<FileUploadProps>): JSX.Element;

declare interface FileUploadProps extends SharedProps {
    multiple?: boolean;
    maxFiles?: number;
    customError?: string;
    isInvalid?: boolean;
    value?: FileInfo[];
    acceptedFormats?: AcceptedFormatsType;
    onFileSelect?: (files: FileInfo[], updateCallback: (id: string, progress: number, status?: FileInfo['status'], error?: string) => void) => void;
    onChange: (files: FileInfo[]) => void;
}

declare type FilterData = {
    value: string;
    label: string;
};

export declare const FilterGroup: default_2.ForwardRefExoticComponent<FilterGroupProps & default_2.RefAttributes<HTMLDivElement>>;

declare interface FilterGroupProps extends default_2.HTMLAttributes<HTMLDivElement> {
    value: FilterValue;
    /** Optional label for the filter group */
    label?: string;
    /** Callback when filter values change */
    onValueChange?: (value?: FilterValue) => void;
    /** Callback when filters are reset */
    onValueReset?: () => void;
    /** Custom label for the reset button */
    resetButtonLabel?: string;
    /** Additional props for the reset button */
    resetButtonProps?: ButtonProps;
    /** Additional props for the filter button */
    filterButtonProps?: ButtonProps;
    /** Icon for the filter button */
    filterIcon?: default_2.ReactNode;
}

export declare const FilterSelect: default_2.MemoExoticComponent<({ multi, data, placeholder, disabled, isLoading, rounded, size, name, defaultOpen, label, orientation, renderItem }: FilterSelectProps) => JSX.Element>;

declare interface FilterSelectProps {
    placeholder: string;
    name: string;
    multi?: boolean;
    data: FilterData[];
    disabled?: boolean;
    isLoading?: boolean;
    rounded?: 'default' | 'full';
    size?: 'default' | 'sm';
    defaultOpen?: boolean;
    currentValue?: string | string[] | undefined;
    label?: string;
    orientation?: 'horizontal' | 'vertical';
    renderItem?: (opt: FilterData) => default_2.ReactNode;
}

declare type FilterValue = {
    [name: string]: string | string[] | number | undefined;
};

export declare const FloatingButton: React_2.ForwardRefExoticComponent<FloatingButtonProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare interface FloatingButtonProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof floatingButtonVariants> {
    asChild?: boolean;
    position?: 'bottomRight' | 'bottomLeft';
}

export declare const floatingButtonVariants: (props?: ({
    size?: "default" | "sm" | null | undefined;
    colors?: "primary" | "neutral" | "oncolor" | "Secondary-Solid" | null | undefined;
} & ClassProp) | undefined) => string;

export declare const Footer: ({ colors, ...props }: FooterProps) => JSX.Element;

declare function FooterLink({ label, href, render, ...props }: FooterLinkProps): JSX.Element;

declare interface FooterLink {
    label: string;
    href?: string;
    render?: ReactNode;
}

declare interface FooterLinkProps extends FooterLink, LinkProps {
}

export declare interface FooterProps extends BottomSectionProps {
    showGroupLinks?: boolean;
    groupLinks?: GroupLink[];
    socialMediaTitle: string;
    socialMediaLinks: SocialLink[];
    accessibilityTools?: default_2.ReactNode;
    className?: string;
}

export declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues extends FieldValues = TFieldValues>(props: FormProviderProps<TFieldValues, TContext, TTransformedValues> & {
    formId?: string;
}) => JSX.Element;

/**
 * Flexible Hijri date formatter.
 *
 * Format tokens:
 *  - iYYYY: hijri year (e.g. 1445)
 *  - iYY:   hijri year 2 digits (e.g. 45)
 *  - iM:    hijri month (1-12, no leading zero)
 *  - iMM:   hijri month (01-12, with leading zero)
 *  - iD:    hijri day (1-31, no leading zero)
 *  - iDD:   hijri day (01-31, with leading zero)
 *
 * Example:
 *   formatHijri("1445-10-14", "iYYYY/iMM/iDD") // 1445/10/14
 *   formatHijri("1445.2.7", "iD-iM-iYY")      // 7-2-45
 */
export declare function formatHijri(str: string, format?: string): string;

export declare const formatter: (dir: string) => Intl.DateTimeFormat;

export declare const formatterTime: (dir: string) => Intl.DateTimeFormat;

export declare const FormControl: React_2.ForwardRefExoticComponent<Omit<SlotProps & React_2.RefAttributes<HTMLElement>, "ref"> & React_2.RefAttributes<HTMLElement>>;

export declare const FormDescription: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => JSX.Element;

export declare const FormItem: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;

export declare const FormLabel: React_2.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React_2.RefAttributes<HTMLLabelElement>, "ref"> & React_2.RefAttributes<HTMLLabelElement>>;

export declare const FormMessage: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare function g2d(gy: number, gm: number, gd: number): number;

export declare enum Gender {
    male = 1,
    female = 2
}

export declare function getGregorianToHijri(gy: number, gm: number, gd: number): {
    hy: number;
    hm: number;
    hd: number;
};

export declare function getHijriDate(date: Date): string;

export declare function getHijriToGregorian(hy: number, hm: number, hd: number): {
    gy: number;
    gm: number;
    gd: number;
};

export declare function getNewMoonMJDNIndex(hy: number, hm: number): number;

export declare function getNewMoonMJDNIndexByJDN(mjdn: number): number | undefined;

export declare function getYear(): number[];

export declare const Grid: default_2.FC<GridProps>;

export declare const GridItem: default_2.FC<GridItemProps>;

declare const gridItemColVariants: (props?: ({
    base?: 2 | 1 | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | 11 | null | undefined;
    sm?: 2 | 1 | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | 11 | null | undefined;
    md?: 2 | 1 | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | 11 | null | undefined;
    lg?: 2 | 1 | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | 11 | null | undefined;
    xl?: 2 | 1 | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | 11 | null | undefined;
    '2xl'?: 2 | 1 | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | 11 | null | undefined;
} & ClassProp) | undefined) => string;

declare interface GridItemProps extends default_2.HTMLAttributes<HTMLDivElement> {
    columns?: VariantProps<typeof gridItemColVariants> | VariantProps<typeof gridItemColVariants>['base'];
    children?: default_2.ReactNode[] | default_2.ReactNode;
}

declare type GridProps = default_2.ComponentPropsWithoutRef<'div'> & VariantProps<typeof gridStyles>;

declare const gridStyles: (props?: ({
    cols?: 2 | 1 | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | 11 | null | undefined;
    gap?: 2 | 1 | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | "none" | 11 | null | undefined;
    gapX?: 2 | 1 | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | "none" | 11 | null | undefined;
    gapY?: 2 | 1 | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | "none" | 11 | null | undefined;
    autoFlow?: "col" | "row" | "dense" | "rowDense" | "colDense" | null | undefined;
    alignItems?: "center" | "start" | "end" | "stretch" | null | undefined;
    justifyItems?: "center" | "start" | "end" | "stretch" | null | undefined;
    alignContent?: "center" | "start" | "end" | "between" | "around" | "evenly" | null | undefined;
    justifyContent?: "center" | "start" | "end" | "between" | "around" | "evenly" | null | undefined;
} & ClassProp) | undefined) => string;

declare interface GroupLink {
    title: string;
    links: FooterLink[];
}

export declare function h2d(hy: number, hm: number, hd: number): number;

export declare const handleArabicNumbers: (e: React.ChangeEvent<HTMLInputElement>, watch: any) => ChangeEvent<HTMLInputElement>;

/**
 * @public
 */
export declare const hasAuthParams: (location?: Location) => boolean;

declare type hasText = {
    hasText?: boolean;
};

export declare const Heading: default_2.ForwardRefExoticComponent<{
    as?: AllowedElements | undefined;
    asChild?: boolean;
    children?: ReactNode;
} & Omit<default_2.DetailedHTMLProps<default_2.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & default_2.RefAttributes<"symbol" | "object" | "code" | "map" | "filter" | "search" | "big" | "link" | "small" | "sub" | "sup" | "stop" | "set" | "g" | "label" | "a" | "button" | "div" | "form" | "h2" | "h3" | "img" | "input" | "li" | "nav" | "ol" | "p" | "select" | "span" | "svg" | "ul" | "abbr" | "address" | "area" | "article" | "aside" | "audio" | "b" | "base" | "bdi" | "bdo" | "blockquote" | "body" | "br" | "canvas" | "caption" | "center" | "cite" | "col" | "colgroup" | "data" | "datalist" | "dd" | "del" | "details" | "dfn" | "dialog" | "dl" | "dt" | "em" | "embed" | "fieldset" | "figcaption" | "figure" | "footer" | "h1" | "h4" | "h5" | "h6" | "head" | "header" | "hgroup" | "hr" | "html" | "i" | "iframe" | "ins" | "kbd" | "keygen" | "legend" | "main" | "mark" | "menu" | "menuitem" | "meta" | "meter" | "noindex" | "noscript" | "optgroup" | "option" | "output" | "param" | "picture" | "pre" | "progress" | "q" | "rp" | "rt" | "ruby" | "s" | "samp" | "slot" | "script" | "section" | "source" | "strong" | "style" | "summary" | "table" | "template" | "tbody" | "td" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "u" | "var" | "video" | "wbr" | "webview" | "animate" | "animateMotion" | "animateTransform" | "circle" | "clipPath" | "defs" | "desc" | "ellipse" | "feBlend" | "feColorMatrix" | "feComponentTransfer" | "feComposite" | "feConvolveMatrix" | "feDiffuseLighting" | "feDisplacementMap" | "feDistantLight" | "feDropShadow" | "feFlood" | "feFuncA" | "feFuncB" | "feFuncG" | "feFuncR" | "feGaussianBlur" | "feImage" | "feMerge" | "feMergeNode" | "feMorphology" | "feOffset" | "fePointLight" | "feSpecularLighting" | "feSpotLight" | "feTile" | "feTurbulence" | "foreignObject" | "image" | "line" | "linearGradient" | "marker" | "mask" | "metadata" | "mpath" | "path" | "pattern" | "polygon" | "polyline" | "radialGradient" | "rect" | "switch" | "text" | "textPath" | "tspan" | "use" | "view" | default_2.ComponentClass<any, any> | default_2.FunctionComponent<any>>>;

export declare const HoverCard: React_2.FC<HoverCardPrimitive.HoverCardProps>;

export declare const HoverCardContent: React_2.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    variant?: "default" | "inverted";
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const HoverCardDescription: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare const HoverCardTitle: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLHeadingElement> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare const HoverCardTrigger: React_2.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React_2.RefAttributes<HTMLAnchorElement>>;

/**
 * @public
 */
export declare interface IAuthService {
    /**
     * See [User](https://authts.github.io/oidc-client-ts/classes/User.html) for more details.
     */
    user?: User | null;
    /**
     * True when the library has been initialized and no navigator request is in progress.
     */
    isLoading: boolean;
    /**
     * True while the user has a valid access token.
     */
    isAuthenticated: boolean;
    /**
     * Was there a signin or silent renew error?
     */
    error?: Error;
    hasAuthParams(): boolean;
    getUser(): Promise<User | null>;
    signin(): Promise<void>;
    completeSignIn(): Promise<void | User>;
    signout(): Promise<void>;
    clearSession(): Promise<void>;
}

export declare interface IconConfig {
    isHugeIcons: boolean;
}

export declare const IconConfigContext: Context<IconConfig>;

export declare const IconConfigProvider: ({ children, isHugeIcons }: IconConfigProviderProps) => default_2.JSX.Element;

export declare interface IconConfigProviderProps {
    children?: default_2.ReactNode;
    isHugeIcons?: boolean;
}

export declare enum IdentityProvider {
    None = 0,
    Local = 1,
    IAM = 2
}

/**
 * The initial auth state.
 */
export declare const initialAuthState: AuthState;

export declare const Input: React_2.ForwardRefExoticComponent<InputProps & React_2.RefAttributes<HTMLInputElement>>;

export declare const InputOTP: React_2.ForwardRefExoticComponent<(Omit<Omit<React_2.InputHTMLAttributes<HTMLInputElement>, "value" | "maxLength" | "onChange" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
    value?: string;
    onChange?: (newValue: string) => unknown;
    maxLength: number;
    textAlign?: "left" | "center" | "right";
    onComplete?: (...args: any[]) => unknown;
    pushPasswordManagerStrategy?: "increase-width" | "none";
    pasteTransformer?: (pasted: string) => string;
    containerClassName?: string;
    noScriptCSSFallback?: string | null;
} & {
    render: (props: RenderProps) => React_2.ReactNode;
    children?: never;
} & React_2.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React_2.InputHTMLAttributes<HTMLInputElement>, "value" | "maxLength" | "onChange" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
    value?: string;
    onChange?: (newValue: string) => unknown;
    maxLength: number;
    textAlign?: "left" | "center" | "right";
    onComplete?: (...args: any[]) => unknown;
    pushPasswordManagerStrategy?: "increase-width" | "none";
    pasteTransformer?: (pasted: string) => string;
    containerClassName?: string;
    noScriptCSSFallback?: string | null;
} & {
    render?: never;
    children: React_2.ReactNode;
} & React_2.RefAttributes<HTMLInputElement>, "ref">) & React_2.RefAttributes<HTMLInputElement>>;

export declare const InputOTPGroup: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const InputOTPSeparator: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const InputOTPSlot: React_2.ForwardRefExoticComponent<SlotProps_2 & Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare interface InputProps extends Omit<React_2.InputHTMLAttributes<HTMLInputElement>, 'size'>, VariantProps<typeof inputVariants>, Extra {
}

export declare const inputVariants: (props?: ({
    variant?: "default" | "outline" | "lighter" | null | undefined;
    rounded?: "full" | "default" | null | undefined;
    colors?: "default" | "destructive" | "success" | null | undefined;
    size?: "default" | "sm" | null | undefined;
} & ClassProp) | undefined) => string;

/**
 validate hijri date
 @param str Hijri date string
 @return { hy: number, hm: number, hd: number } or null if invalid.
     */
 export declare function isValidHijriDate(str: string): {
     hy: number;
     hm: number;
     hd: number;
 } | boolean;

 declare type Item = {
     title: string | string[];
     path?: string;
     state?: unknown;
     render?: React_2.ReactNode;
 };

 export declare const Label: React_2.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React_2.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: ({
     size?: "default" | "sm" | null | undefined;
 } & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLLabelElement>>;

 export declare const langRegex: {
     enRegex: RegExp;
     arRegex: RegExp;
     bothArAndEnRegexonlyLetters: RegExp;
     bothArAndEnRegexonlyLettersAndNumbers: RegExp;
     enletterAndNumbersRegex: RegExp;
     mobileNumber: RegExp;
     TelPhone: RegExp;
     nationalId: RegExp;
     nationalOrResidentId: RegExp;
     nonSaudianNationalId: RegExp;
     tags: RegExp;
     specialCharcter: RegExp;
     arSpaceRegex: RegExp;
 };

 export declare const LinesPerPage: ({ value, onChange, linesPerPageOptions, label, placeholder, }: {
     value: number;
     onChange: (value: string) => void;
     linesPerPageOptions?: number[];
     label?: string;
     placeholder?: string;
 }) => JSX.Element;

 export declare const Link: React_2.ForwardRefExoticComponent<LinkProps & React_2.RefAttributes<HTMLAnchorElement>>;

 export declare interface LinkProps extends React_2.AnchorHTMLAttributes<HTMLAnchorElement>, VariantProps<typeof linkVariants> {
     asChild?: boolean;
 }

 export declare const linkVariants: (props?: ({
     size?: "default" | "sm" | null | undefined;
     colors?: "primary" | "neutral" | "oncolor" | null | undefined;
     underline?: "always" | "hover" | null | undefined;
     disabled?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;

 export declare const List: {
     ({ children, variant, colors, items, icon, className, ...props }: ListProps): JSX.Element;
     displayName: string;
 };

 export declare const ListItem: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLLIElement> & default_2.RefAttributes<HTMLLIElement>>;

 declare type ListProps = default_2.HTMLAttributes<HTMLUListElement> & VariantProps<typeof listVariants> & {
     items?: string[] | default_2.ReactNode[];
     icon?: default_2.ReactNode;
 };

 declare const listVariants: (props?: ({
     variant?: "ordered" | "unordered" | "with-icon" | null | undefined;
     colors?: "primary" | "neutral" | "onColor" | null | undefined;
 } & ClassProp) | undefined) => string;

 export declare namespace Local_DTO {
     export type User = {
         ProfilePicture?: string;
         Id: string;
         roles: UserTypes[];
         defaultRole?: UserTypes;
         personIdentifier?: string;
         refIdentificationTypeCode?: string;
         refIdentificationTypeName?: string;
         birthdate?: string;
         firstName: string;
         secondName: string;
         thridName: string;
         lastName: string;
         refSexName?: string;
         refSexCode?: string;
         refNationalityCountryCode?: string;
         refNationalityCountryName?: string;
         email: string;
         ssoEmail?: string;
         mobile?: string;
     };
     export type AuthStore = {
         accessToken: string | undefined;
         refreshToken: string | undefined;
         isAuthenticated: boolean | undefined;
         user: User;
         nationalId?: string | null;
         sessionExpired?: boolean;
         login: (nationalId: string) => void;
         setUser: (user: Partial<User>) => void;
         updateUser: (user: Partial<User>) => void;
         logout: () => void;
         setDefaultRole: (defaultRole?: UserTypes) => void;
         setExpireSession: () => void;
     };
     export interface ServiceCategory {
         CategoryName: string;
         Link: string;
         Id: string;
         Icon: (props: default_2.SVGProps<SVGSVGElement>) => default_2.JSX.Element;
         isActive: boolean;
     }
     export interface MenuList {
         Category: string;
         ClassName?: string | null;
         ShortName?: string | null;
         Id: string;
         Services?: {
             Name: string;
             Value: string;
             Id: string;
             Categories?: ServiceCategory[];
         }[];
     }
     export interface NavigationMenuProps {
         menuList: MenuList[];
     }
     export interface NavigationMenuMobileProps extends NavigationMenuProps {
         isOpen: boolean;
         onMenuClose: () => void;
         UserLinks: UserLink[];
         changeLang: (lang: 'ar' | 'en') => void;
         logout: () => void;
         isAuthenticated: boolean;
         user: {
             Name: string;
             ProfilePicture?: string;
         };
         isUP?: boolean;
     }
     export interface LabelProps {
         isRequired?: boolean;
     }
     export interface TopMenuProps {
         changeLang: (lang: 'ar' | 'en') => void;
         isAuthenticated: boolean;
         user: {
             Name: string;
             ProfilePicture?: string;
         };
         logout: () => void;
         navigateTo?: (pathname: string) => void;
         currenLocation?: string;
         isUP?: boolean;
     }
     export type AccessibilityToolsStore = {
         isActive: boolean;
         toggleColors: () => void;
         fontSize: string;
         isMax: boolean;
         isMin: boolean;
         isDesktop: boolean;
         increaseSize: () => void;
         decreaseSize: () => void;
         defaultSize: () => void;
     };
     export interface UserLink {
         Name: string;
         Link?: string;
         onClick?: () => void;
         Id?: number;
         Icon: (props: default_2.SVGProps<SVGSVGElement>) => default_2.JSX.Element;
     }
     export interface UserInfoProps {
         UserLinks: UserLink[];
         user: {
             Name: string;
             ProfilePicture?: string;
         };
         changeLang: (lang: 'ar' | 'en') => void;
         logout: () => void;
         isUP?: boolean;
     }
     export interface Crumb {
         crumb: (data: any) => ReactNode | string;
     }
     export interface TextareaProps extends LabelProps {
         label: string;
         control: any;
         name: string;
         placeholder?: string;
         maxLength?: number;
     }
     export interface DropdownProps extends TextareaProps {
         options: {
             label: string;
             value: string | number;
         }[];
         disabled?: boolean;
     }
     export interface InputProps extends TextareaProps {
         isNumber?: boolean;
         watch?: any;
     }
     export type useLanguageStore = {
         lang: string;
         dir: 'rtl' | 'ltr';
         changeLang: (lang: 'ar' | 'en') => void;
     };
 }

 export declare enum MaritalStatus {
     single = 1,
     married = 2
 }

 export declare function mergeRefs<T = any>(refs: Array<React.Ref<T> | undefined | null>): React.RefCallback<T>;

 export declare function MultiSelect<T extends ValueType_2>({ placeholder, options, selectedValues, onChange, disabled, size, dataTestId, rounded, variant, colors, isLoading, className, checkboxSize, threshold, showSelectButton, selectButtonTitle, modal, }: Readonly<MultiSelectProps<T>>): JSX.Element;

 export declare interface MultiSelectProps<T extends ValueType_2> extends VariantProps<typeof selectVariants> {
     placeholder: string;
     options: Options<T>[];
     selectedValues: T[];
     onChange: (values: T[]) => void;
     disabled?: boolean;
     dataTestId?: string;
     className?: string;
     isLoading?: boolean;
     checkboxSize?: 'default' | 'sm' | 'xs';
     threshold?: number;
     showSelectButton?: boolean;
     selectButtonTitle?: string;
     modal?: boolean;
 }

 export declare const NavigationAction: React_2.ForwardRefExoticComponent<React_2.HtmlHTMLAttributes<HTMLButtonElement> & {
     asChild?: boolean;
 } & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const NavigationActions: React_2.ForwardRefExoticComponent<React_2.HtmlHTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const NavigationHeader: React_2.ForwardRefExoticComponent<React_2.HtmlHTMLAttributes<HTMLHeadElement> & {
     divider?: boolean;
     collapsed?: boolean;
     onToggleCollapsed?: () => void;
 } & React_2.RefAttributes<HTMLHeadElement>>;

 export declare const NavigationHeaderLogo: React_2.ForwardRefExoticComponent<React_2.HtmlHTMLAttributes<HTMLAnchorElement> & {
     logoSrc: string;
     logoAlt?: string;
 } & React_2.RefAttributes<HTMLAnchorElement>>;

 export declare const NavigationMain: React_2.ForwardRefExoticComponent<React_2.HtmlHTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const NavigationMenu: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & React_2.RefAttributes<HTMLElement>, "ref"> & {
     viewport?: boolean;
 } & React_2.RefAttributes<HTMLElement>>;

 export declare const NavigationMenuContent: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const NavigationMenuIndicator: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const NavigationMenuItem: React_2.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuItemProps & React_2.RefAttributes<HTMLLIElement>>;

 export declare const NavigationMenuLink: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuLinkProps & React_2.RefAttributes<HTMLAnchorElement>, "ref"> & React_2.RefAttributes<HTMLAnchorElement>>;

 export declare const NavigationMenuList: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & React_2.RefAttributes<HTMLUListElement>, "ref"> & React_2.RefAttributes<HTMLUListElement>>;

 export declare const NavigationMenuMegaDropdownMenu: ({ title, className, children }: {
     title: string;
     className?: string;
     children?: React_2.ReactNode;
 }) => JSX.Element;

 export declare const NavigationMenuTrigger: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const navigationMenuTriggerStyle: (props?: ClassProp | undefined) => string;

 export declare const NavigationMenuViewport: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const NavigationMobileBody: ({ children, className, ...props }: React_2.HtmlHTMLAttributes<HTMLDivElement>) => JSX.Element;

 export declare const NavigationMobileFooter: ({ children, className, hideSwitchLang, ...props }: React_2.HtmlHTMLAttributes<HTMLDivElement> & {
     hideSwitchLang?: boolean;
 }) => JSX.Element;

 export declare const NavigationMobileHeader: ({ children, className, ...props }: React_2.HtmlHTMLAttributes<HTMLDivElement>) => JSX.Element;

 export declare const NavigationMobileLink: React_2.ForwardRefExoticComponent<React_2.AnchorHTMLAttributes<HTMLAnchorElement> & {
     asChild?: boolean;
 } & React_2.RefAttributes<HTMLAnchorElement>>;

 export declare const NavigationMobileSideBar: ({ open, onOpenChange, children, }: React_2.PropsWithChildren<{
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
 }>) => JSX.Element;

 export declare const NavigationMobileSwitchLanguage: () => JSX.Element;

 export declare const NavigationSearch: ({ onSearch, onValueChange, showIconOnly, children, }: {
     onSearch: (value: string) => void;
     onValueChange?: (value: string) => void;
     showIconOnly?: boolean;
     children?: React_2.ReactNode;
 }) => JSX.Element;

 export declare const NavigationSwitchLanguage: ({ onValueChange, className }: {
     onValueChange?: () => void;
     className?: string;
 }) => JSX.Element;

 export declare const NavigationSwitchTheme: ({ colors, size }: {
     colors?: ButtonProps["colors"];
     size?: "icon-sm" | "icon" | "icon-xs";
 }) => JSX.Element;

 export declare interface OIDCConfig {
     clientId: string;
     clientSecret?: string;
     baseUrl: string;
     authUrl: string;
     jwks?: string;
     disablePKCE?: boolean;
     oauth20LogoutUrl: string;
 }

 /**
  * Handles how that state changes in the `useAuth` hook.
  */
 export declare const oidcReducer: (state: AuthState, action: Action_2) => AuthState;

 declare type Options<T> = {
     label: string;
     value: T;
     icon?: ComponentType<{
         className?: string;
     }>;
 };

 export declare const PageLoader: () => JSX.Element;

 export declare const Pagination: ({ totalItems, onPageChange, selectedPage, className, withoutText, itemsPerPage }: Props_2) => JSX.Element | null;

 declare const Pagination_2: ({ className, ...props }: React_2.ComponentProps<"nav">) => JSX.Element;

 declare const PaginationContent: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React_2.RefAttributes<HTMLUListElement>>;

 export declare const PaginationDescription: ({ currentPage, totalCount, limit, showTotalResults, }: {
     currentPage: number;
     totalCount: number;
     limit: number;
     showTotalResults?: boolean;
 }) => JSX.Element;

 declare const PaginationEllipsis: ({ className, ...props }: React_2.ComponentProps<"span">) => JSX.Element;

 declare const PaginationItem: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React_2.RefAttributes<HTMLLIElement>>;

 declare const PaginationLink: {
     ({ className, isActive, ...props }: PaginationLinkProps): JSX.Element;
     displayName: string;
 };

 declare type PaginationLinkProps = {
     isActive?: boolean;
 } & Pick<ButtonProps, 'size'> & React_2.ComponentProps<'button'>;

 declare const PaginationNext: ({ className, hasText, ...props }: React_2.ComponentProps<typeof PaginationLink> & hasText) => JSX.Element;

 declare const PaginationPrevious: {
     ({ className, hasText, ...props }: React_2.ComponentProps<typeof PaginationLink> & hasText): JSX.Element;
     displayName: string;
 };

 export declare function Popover({ ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Root>): JSX.Element;

 export declare function PopoverAnchor({ ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Anchor>): JSX.Element;

 export declare function PopoverClose({ ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Close>): JSX.Element;

 export declare function PopoverContent({ className, align, sideOffset, ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Content>): JSX.Element;

 export declare function PopoverTrigger({ ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Trigger>): JSX.Element;

 export declare const Progress: React_2.ForwardRefExoticComponent<ProgressProps & React_2.RefAttributes<HTMLDivElement>>;

 declare interface ProgressProps extends React_2.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> {
     colors?: 'bg-primary' | 'bg-secondary' | 'bg-tertiary' | 'bg-error' | 'bg-warning' | 'bg-success' | 'bg-info' | 'bg-secondary-light' | 'bg-disabled';
     icon?: React_2.ReactNode;
     rounded?: boolean;
 }

 declare interface Props<T> extends VariantProps<typeof selectVariants> {
     options?: T[];
     optionLabel: keyof T;
     optionValue: keyof T;
     renderItem?: (option: T) => default_2.ReactNode;
     value: string;
     placeholder: string;
     isLoading?: boolean;
     onChange: (value: string) => void;
     triggerProps?: ButtonPropsExtend;
     disabled?: boolean;
     isDate?: boolean;
     disabledOption?: (option: T) => boolean;
     className?: string;
     startAdornment?: ReactNode;
     contentClassName?: string;
     modal?: boolean;
     keywords?: (keyof T)[];
 }

 declare interface Props_2 {
     totalItems: number;
     onPageChange: (page: number) => void;
     selectedPage: number;
     className?: string;
     withoutText?: boolean;
     itemsPerPage?: number;
 }

 declare type Props_3 = React_2.ComponentProps<typeof DayCalendar> & {
     lang?: 'ar' | 'en';
     controlProps?: React_2.ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<typeof selectVariants> & {
         [key: `data-${string}`]: string;
         placeholder?: string;
     };
     shouldDisableDate?: (date: Date) => boolean;
     isWeekendDisable?: boolean;
     customTrigger?: React_2.ReactNode;
     hijriToggle?: boolean;
     disablePast?: boolean;
     closeOnSelect?: boolean;
     sideOffset?: number;
     modal?: boolean;
 };

 declare interface Props_4 extends VariantProps<typeof selectVariants> {
     lang?: 'ar' | 'en';
     placeholder?: string | null;
     value?: string | null;
     onChange: (time: string) => void;
     className?: string;
     ampm?: boolean;
     disabled?: boolean;
     timeStep?: number;
     modal?: boolean;
 }

 declare type PropsBreadcrumb = {
     items: Item[];
     dir?: 'rtl' | 'ltr';
 };

 /**
  * Represents the state of a query.
  *
  * @template T - The type of data being queried.
  */
 declare type QueryState<T> = {
     /**
      * The cached data for the query, if available.
      */
     data?: T;
     /**
      * The current status of the query.
      * Can be 'idle', "pending" | "error" | "success", or any other status provided by `react-query`.
      */
     status: QueryStatus | 'idle';
     /**
      * Indicates if the query is currently in a pending state.
      * This is a custom state that can be used to differentiate between idle and pending states.
      */
     isPending: boolean;
     /**
      * Indicates if the query is currently being fetched.
      * This reflects whether a network request is in progress.
      */
     isFetching: boolean;
     /**
      * Indicates if the query has successfully fetched data.
      * This is true if the query has completed successfully and data is available.
      */
     isSuccess: boolean;
     /**
      * Indicates if the query has incountered any error.
      */
     isError: boolean;
     /**
      * The error associated with the query, if any.
      */
     error?: unknown;
     /**
      * refetch quiery based on provided key
      */
     refetch: () => void;
 };

 export declare interface RadialStep {
     id: number;
     title?: string;
     description?: string;
 }

 export declare const RadialStepper: default_2.ForwardRefExoticComponent<RadialStepperProps & default_2.RefAttributes<HTMLDivElement>>;

 export declare interface RadialStepperProps extends default_2.ComponentPropsWithoutRef<'div'>, VariantProps<typeof radialStepperVariants> {
     steps: RadialStep[];
     activeStep: number;
     size?: 120 | 80 | 64 | 48 | 40;
     showDetails?: boolean;
 }

 declare const radialStepperVariants: (props?: ({
     colors?: "primary" | "neutral" | null | undefined;
     onColor?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;

 export declare const RadioGroup: React_2.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & VariantProps<(props?: ({
     colors?: "primary" | "neutral" | null | undefined;
     size?: "default" | "sm" | "xs" | null | undefined;
 } & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const RadioGroupItem: React_2.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare function Rating({ max, onChange, value, className, ...props }: RatingProps): JSX.Element;

 declare interface RatingProps extends Themes {
     max?: number;
     value?: number;
     onChange?: (value: number) => void;
 }

 export declare const reducer: (state: State, action: Action) => State;

 export declare function ResponsiveScroll({ children, scrollAmount, margin, className, buttonClassName, }: Readonly<ResponsiveScrollProps>): JSX.Element;

 declare interface ResponsiveScrollProps {
     children: React_2.ReactNode;
     scrollAmount?: number;
     className?: string;
     margin?: number;
     buttonClassName?: string;
 }

 export declare enum Roles {
     Anonymous = 0,
     User = 1,
     Admin = 2
 }

 export declare const ScrollArea: React_2.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const ScrollBar: React_2.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SearchInput: default_2.ForwardRefExoticComponent<SearchInputProps & InputProps & default_2.RefAttributes<HTMLInputElement>>;

 declare interface SearchInputProps {
     placeholder?: string;
     type: 'onType' | 'onButton';
     validationMessage?: string;
     value?: string;
     onSearch: (value: string) => void;
     disabled?: boolean;
     debounceTime?: number;
     className?: string;
 }

 export declare const SecondNavHeader: ({ colors, hideDivider, className, children, ...props }: SecondNavHeaderProps) => JSX.Element;

 export declare interface SecondNavHeaderAction {
     hideTrail?: boolean;
     hideSwitchTheme?: boolean;
 }

 export declare const SecondNavHeaderAction: ({ className, hideTrail, hideSwitchTheme, ...props }: HTMLAttributes<HTMLDivElement> & SecondNavHeaderAction) => JSX.Element;

 export declare const SecondNavHeaderContent: ({ className, ...props }: HTMLAttributes<HTMLDivElement>) => JSX.Element;

 declare interface SecondNavHeaderProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof secondNavHeaderVariants> {
 }

 declare const secondNavHeaderVariants: (props?: ({
     colors?: "primary" | "gray" | null | undefined;
     hideDivider?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;

 export declare const Select: ({ variant, size, colors, rounded, children, ...props }: React_2.ComponentPropsWithoutRef<typeof SelectPrimitive.Root> & VariantProps<typeof selectVariants>) => JSX.Element;

 export declare const SelectContent: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SelectGroup: React_2.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SelectItem: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SelectLabel: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SelectScrollDownButton: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SelectScrollUpButton: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SelectSeparator: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SelectTrigger: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & {
     placeholder?: string;
 } & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const SelectValue: React_2.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React_2.RefAttributes<HTMLSpanElement>>;

 export declare const selectVariants: (props?: ({
     variant?: "default" | "outline" | "lighter" | null | undefined;
     rounded?: "full" | "default" | null | undefined;
     colors?: "default" | "destructive" | "success" | null | undefined;
     size?: "default" | "sm" | null | undefined;
 } & ClassProp) | undefined) => string;

 export declare const Separator: React_2.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const setLanguage: (lang: string) => void;

 export declare namespace ShadPagination {
     export {
         Pagination_2 as Pagination,
         PaginationContent,
         PaginationEllipsis,
         PaginationItem,
         PaginationLink,
         PaginationNext,
         PaginationPrevious
     }
 }

 declare interface SharedProps {
     maxSize?: number;
     description?: string | ReactNode;
     label?: string;
     browseLabel?: string;
     isRequired?: boolean;
     disabled?: boolean;
 }

 export declare const Sheet: default_2.FC<DialogPrimitive.DialogProps>;

 export declare const SheetBody: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & default_2.RefAttributes<HTMLDivElement>>;

 export declare const SheetClose: default_2.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & default_2.RefAttributes<HTMLButtonElement>>;

 export declare const SheetContent: default_2.ForwardRefExoticComponent<SheetContentProps & default_2.RefAttributes<HTMLDivElement>>;

 export declare interface SheetContentProps extends default_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
     ignoreInteractOutside?: boolean;
     hideOverlay?: boolean;
     overlayClassName?: string;
 }

 export declare const SheetDescription: default_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & default_2.RefAttributes<HTMLParagraphElement>, "ref"> & default_2.RefAttributes<HTMLParagraphElement>>;

 export declare const SheetFooter: {
     ({ className, ...props }: default_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
     displayName: string;
 };

 export declare const SheetForm: default_2.FC<DialogProps>;

 export declare const SheetFormBody: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & default_2.RefAttributes<HTMLDivElement>>;

 export declare const SheetFormContent: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & default_2.RefAttributes<HTMLDivElement>>;

 export declare const SheetFormFooter: {
     ({ className, title, ...props }: default_2.ComponentPropsWithoutRef<typeof SheetFooter>): JSX.Element;
     displayName: string;
 };

 export declare const SheetFormHeader: {
     ({ className, title, ...props }: default_2.ComponentPropsWithoutRef<typeof SheetHeader>): JSX.Element;
     displayName: string;
 };

 export declare const SheetFormTrigger: default_2.ForwardRefExoticComponent<ButtonProps & default_2.RefAttributes<HTMLButtonElement>>;

 export declare const SheetHeader: {
     ({ className, title, hideCenter, children, ...props }: default_2.HTMLAttributes<HTMLDivElement> & {
         hideCenter?: boolean;
     }): JSX.Element;
     displayName: string;
 };

 export declare const SheetOverlay: default_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & default_2.RefAttributes<HTMLDivElement>, "ref"> & default_2.RefAttributes<HTMLDivElement>>;

 export declare const SheetPortal: default_2.FC<DialogPrimitive.DialogPortalProps>;

 export declare const SheetTitle: default_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & default_2.RefAttributes<HTMLHeadingElement>, "ref"> & default_2.RefAttributes<HTMLHeadingElement>>;

 export declare const SheetTrigger: default_2.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & default_2.RefAttributes<HTMLButtonElement>>;

 declare const sheetVariants: (props?: ({
     side?: "top" | "center" | "bottom" | "right" | "left" | null | undefined;
 } & ClassProp) | undefined) => string;

 export declare const ShouldRender: FC<ShouldRenderProps>;

 declare type ShouldRenderProps = {
     children: ReactNode;
     shouldRender?: boolean;
     other?: ReactNode;
 };

 export declare const Sidebar: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & {
     side?: "left" | "right";
     variant?: "sidebar" | "floating" | "inset";
     collapsible?: "offcanvas" | "icon" | "none";
 }, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SidebarContent: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 declare type SidebarContext = {
     state: 'expanded' | 'collapsed';
     open: boolean;
     setOpen: (open: boolean) => void;
     openMobile: boolean;
     setOpenMobile: (open: boolean) => void;
     isMobile: boolean;
     toggleSidebar: () => void;
 };

 declare const SidebarContext: React_2.Context<SidebarContext | null>;

 export declare const SidebarFooter: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SidebarGroup: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SidebarGroupAction: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLButtonElement> & React_2.ButtonHTMLAttributes<HTMLButtonElement> & {
     asChild?: boolean;
 }, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const SidebarGroupContent: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SidebarGroupLabel: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & {
     asChild?: boolean;
 }, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SidebarHeader: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SidebarInput: React_2.ForwardRefExoticComponent<Omit<InputProps & React_2.RefAttributes<HTMLInputElement>, "ref"> & React_2.RefAttributes<HTMLInputElement>>;

 export declare const SidebarInset: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SidebarMenu: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React_2.RefAttributes<HTMLUListElement>>;

 export declare const SidebarMenuAction: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLButtonElement> & React_2.ButtonHTMLAttributes<HTMLButtonElement> & {
     asChild?: boolean;
     showOnHover?: boolean;
 }, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const SidebarMenuBadge: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SidebarMenuButton: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLButtonElement> & React_2.ButtonHTMLAttributes<HTMLButtonElement> & {
     asChild?: boolean;
     isActive?: boolean;
     tooltip?: string | React_2.ComponentProps<typeof TooltipContent>;
 } & VariantProps<(props?: ({
     variant?: "default" | "outline" | null | undefined;
     size?: "default" | "sm" | "lg" | null | undefined;
     rounded?: "full" | "default" | null | undefined;
 } & ClassProp) | undefined) => string>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const SidebarMenuItem: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React_2.RefAttributes<HTMLLIElement>>;

 export declare const SidebarMenuSkeleton: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & {
     showIcon?: boolean;
 }, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SidebarMenuSub: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React_2.RefAttributes<HTMLUListElement>>;

 export declare const SidebarMenuSubButton: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLAnchorElement> & React_2.AnchorHTMLAttributes<HTMLAnchorElement> & {
     asChild?: boolean;
     size?: "sm" | "md";
     isActive?: boolean;
 }, "ref"> & React_2.RefAttributes<HTMLAnchorElement>>;

 export declare const SidebarMenuSubItem: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React_2.RefAttributes<HTMLLIElement>>;

 export declare const SidebarProvider: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & {
     defaultOpen?: boolean;
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
 }, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SidebarRail: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const SidebarSeparator: React_2.ForwardRefExoticComponent<Omit<Omit<SeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const SidebarTrigger: React_2.ForwardRefExoticComponent<Omit<ButtonProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const signinError: (error: unknown) => Error;

 export declare const signoutError: (error: unknown) => Error;

 export declare const SimpleGrid: default_2.FC<SimpleGridProps>;

 declare interface SimpleGridProps extends default_2.HTMLAttributes<HTMLDivElement> {
     /**
      * The minimum width of each child element. When specified, the grid will adjust its columns
      * to fit as many items as possible per row based on this minimum width.
      */
     minChildWidth?: string | number;
     /**
      * The number of columns or responsive array of columns.
      * If `minChildWidth` is specified, this will be overridden.
      */
     cols?: number;
     /**
      * The gap between grid items.
      */
     gap?: string;
     /**
      * The column gap between grid items.
      */
     gapX?: string;
     /**
      * The row gap between grid items.
      */
     gapY?: string;
 }

 export declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): JSX.Element;

 export declare const Slider: React_2.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React_2.RefAttributes<HTMLSpanElement>, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;

 export declare const SliderPagination: ({ setCurrentPage, currentPage, totalPages, disabled }: SliderPaginationProps) => JSX.Element | null;

 export declare interface SliderPaginationProps {
     setCurrentPage: default_2.Dispatch<default_2.SetStateAction<number>>;
     currentPage: number;
     totalPages: number;
     disabled?: boolean;
 }

 declare interface SocialLink {
     title?: string;
     target: string;
     icon: default_2.ReactNode;
 }

 export { SortingState }

 export declare const Stack: default_2.FC<StackProps>;

 declare type StackProps = default_2.ComponentPropsWithoutRef<'div'> & VariantProps<typeof stackStyles>;

 declare const stackStyles: (props?: ({
     direction?: "col" | "row" | "row-reverse" | "col-reverse" | null | undefined;
     gap?: 2 | 1 | "small" | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | "medium" | "none" | 11 | null | undefined;
     gapX?: 2 | 1 | "small" | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | "medium" | "none" | 11 | null | undefined;
     gapY?: 2 | 1 | "small" | 3 | 12 | 8 | 6 | 4 | 9 | 5 | 10 | 7 | "medium" | "none" | 11 | null | undefined;
     alignItems?: "center" | "start" | "end" | "stretch" | null | undefined;
     justifyItems?: "center" | "start" | "end" | "stretch" | null | undefined;
     alignContent?: "center" | "start" | "end" | "between" | "around" | "evenly" | null | undefined;
     justifyContent?: "center" | "start" | "end" | "between" | "around" | "evenly" | null | undefined;
 } & ClassProp) | undefined) => string;

 declare interface State {
     toasts: ToasterToast[];
 }

 export declare enum StatusCodes {
     OK = 200,
     BadRequest = 400,
     Unauthorized = 401,
     PaymentRequired = 402,
     Forbidden = 403,
     NotFound = 404,
     TooManyRequests = 429,
     InternalServerError = 500,
     BadGateway = 502,
     ServerUnavailable = 503
 }

 export declare const Step: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
     'data-index'?: number;
     lastStep?: boolean;
     progressClassName?: string;
 } & React_2.RefAttributes<HTMLDivElement>>;

 export declare const StepDescription: React_2.ForwardRefExoticComponent<React_2.HtmlHTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;

 export declare const Stepper: React_2.ForwardRefExoticComponent<StepperProps & React_2.RefAttributes<HTMLDivElement>>;

 declare type StepperContextType = VariantProps<typeof stepperVariants> & {
     activeStep: number;
 };

 declare interface StepperProps extends React_2.HTMLAttributes<HTMLDivElement>, StepperContextType {
 }

 declare const stepperVariants: (props?: ({
     variant?: "circle" | "dot" | null | undefined;
     orientation?: "horizontal" | "vertical" | null | undefined;
 } & ClassProp) | undefined) => string;

 export declare const StepTitle: React_2.ForwardRefExoticComponent<React_2.HtmlHTMLAttributes<HTMLSpanElement> & React_2.RefAttributes<HTMLSpanElement>>;

 export declare const strings: LocalizedStrings<    {
 messages: {
 exceedlimitedField: string;
 required: string;
 };
 Shared: {
 trialVersion: string;
 soon: string;
 NationalId: string;
 ResidentID: string;
 Welcome: string;
 Login: string;
 Logout: string;
 InformationPanel: string;
 AccountSettings: string;
 Chat: string;
 TechnicalSupport: string;
 FullName: string;
 PersonalInformation: string;
 TicketInformation: string;
 TicketDetails: string;
 Title: string;
 Description: string;
 Enter: string;
 AddSupportingFiles: string;
 Send: string;
 Submit: string;
 Cancel: string;
 Main: string;
 Select: string;
 NotRobot: string;
 Search: string;
 Number: string;
 Date: string;
 hijriCalendar: string;
 male: string;
 female: string;
 submit: string;
 next: string;
 previous: string;
 morePages: string;
 Total: string;
 YearTitle: string;
 MonthTitle: string;
 PaginationDesc: string;
 LinesPerPage: string;
 Actions: string;
 ViewDetails: string;
 Language: string;
 Specify: string;
 ServerError: string;
 BackToHome: string;
 NoDataFound: string;
 showResults: string;
 reset: string;
 CopiedSuccessfully: string;
 comma: string;
 accessibilityTools: string;
 sortBy: string;
 siteLanguageText: string;
 lightMode: string;
 darkMode: string;
 showLess: string;
 showMore: string;
 noResultsFound: string;
 Clear: string;
 Of: string;
 totalResults: string;
 loadingMore: string;
 nothingMoreToLoad: string;
 };
 Footer: {
 KSA: string;
 TermsAndConditions: string;
 PolicyAndPrivacy: string;
 RegulationsPolicies: string;
 Rights: string;
 Version: string;
 DevelopedByTetco: string;
 };
 DragAndDrop: {
 SaveCustomization: string;
 Delete: string;
 Half: string;
 Full: string;
 Width: string;
 Show: string;
 AddToDashboard: string;
 };
 Attachments: {
 error: string;
 Attachments: string;
 AddAttachment: string;
 dragFiles: string;
 browseFile: string;
 uploadFiles: string;
 allowedFormats: string;
 maxSize: string;
 ApplyFile: string;
 maxAcceptedFilesCount: string;
 attachedFile: string;
 };
 Accessibility: {
 Accessibility: string;
 FontSize: string;
 IncreaseFontSize: string;
 DecreaseFontSize: string;
 ColorContrast: string;
 SignLanguage: string;
 VoiceCommands: string;
 };
 DigitalSignatureContent: {
 secureTitle: string;
 secureDesc: string;
 registered: string;
 howCheck: string;
 officialSite: string;
 govSaTitle: string;
 govSaDesc: string;
 eduSaTitle: string;
 eduSaDesc: string;
 orgSaTitle: string;
 orgSaDesc: string;
 saTitle: string;
 saDesc: string;
 schSaTitle: string;
 schSaDesc: string;
 };
 } | {
 messages: {
 exceedlimitedField: string;
 required: string;
 };
 Shared: {
 trialVersion: string;
 soon: string;
 NationalId: string;
 ResidentID: string;
 Welcome: string;
 Login: string;
 Logout: string;
 InformationPanel: string;
 AccountSettings: string;
 Chat: string;
 TechnicalSupport: string;
 FullName: string;
 PersonalInformation: string;
 TicketInformation: string;
 TicketDetails: string;
 Title: string;
 Description: string;
 Enter: string;
 AddSupportingFiles: string;
 Send: string;
 Submit: string;
 Cancel: string;
 Main: string;
 Select: string;
 NotRobot: string;
 Search: string;
 Number: string;
 Date: string;
 hijriCalendar: string;
 male: string;
 female: string;
 submit: string;
 next: string;
 previous: string;
 morePages: string;
 Total: string;
 YearTitle: string;
 MonthTitle: string;
 PaginationDesc: string;
 LinesPerPage: string;
 Actions: string;
 ViewDetails: string;
 Language: string;
 Specify: string;
 ServerError: string;
 BackToHome: string;
 NoDataFound: string;
 showResults: string;
 reset: string;
 CopiedSuccessfully: string;
 comma: string;
 accessibilityTools: string;
 sortBy: string;
 siteLanguageText: string;
 lightMode: string;
 darkMode: string;
 showLess: string;
 showMore: string;
 noResultsFound: string;
 Clear: string;
 Of: string;
 totalResults: string;
 loadingMore: string;
 nothingMoreToLoad: string;
 };
 Footer: {
 KSA: string;
 TermsAndConditions: string;
 PolicyAndPrivacy: string;
 RegulationsPolicies: string;
 Rights: string;
 Version: string;
 DevelopedByTetco: string;
 };
 DragAndDrop: {
 SaveCustomization: string;
 Delete: string;
 Half: string;
 Full: string;
 Width: string;
 Show: string;
 AddToDashboard: string;
 };
 Attachments: {
 error: string;
 Attachments: string;
 AddAttachment: string;
 dragFiles: string;
 browseFile: string;
 uploadFiles: string;
 allowedFormats: string;
 maxSize: string;
 ApplyFile: string;
 maxAcceptedFilesCount: string;
 attachedFile: string;
 };
 Accessibility: {
 Accessibility: string;
 FontSize: string;
 IncreaseFontSize: string;
 DecreaseFontSize: string;
 ColorContrast: string;
 SignLanguage: string;
 VoiceCommands: string;
 };
 DigitalSignatureContent: {
 secureTitle: string;
 secureDesc: string;
 registered: string;
 howCheck: string;
 officialSite: string;
 govSaTitle: string;
 govSaDesc: string;
 eduSaTitle: string;
 eduSaDesc: string;
 orgSaTitle: string;
 orgSaDesc: string;
 saTitle: string;
 saDesc: string;
 schSaTitle: string;
 schSaDesc: string;
 };
 }>;

 export { SubmitHandler }

 export declare enum SupportStatusProcess {
     New = 1,
     InProgress = 2,
     Closed = 3,
     Resolved = 6,
     Cancelled = 7,
     OnHold = 13
 }

 export declare const Switch: React_2.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const Table: React_2.ForwardRefExoticComponent<tableProps & React_2.RefAttributes<HTMLTableElement>>;

 export declare const TableBody: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;

 export declare const TableCaption: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableCaptionElement> & React_2.RefAttributes<HTMLTableCaptionElement>>;

 export declare const TableCell: React_2.ForwardRefExoticComponent<React_2.TdHTMLAttributes<HTMLTableCellElement> & {
     isLast?: boolean;
 } & React_2.RefAttributes<HTMLTableCellElement>>;

 export declare interface tableContainerProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof tableContainerVariants> {
 }

 declare const tableContainerVariants: (props?: ({
     contained?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;

 export declare const TableFooter: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;

 export declare const TableHead: React_2.ForwardRefExoticComponent<React_2.ThHTMLAttributes<HTMLTableCellElement> & React_2.RefAttributes<HTMLTableCellElement>>;

 export declare const TableHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;

 export declare interface tableProps extends React_2.HTMLAttributes<HTMLTableElement>, VariantProps<typeof tableVariants> {
 }

 export declare const TableRow: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableRowElement> & React_2.RefAttributes<HTMLTableRowElement>>;

 declare const tableVariants: (props?: ({
     variant?: "default" | "compact" | null | undefined;
     alternating?: boolean | null | undefined;
     contained?: boolean | null | undefined;
     borderedCells?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;

 export declare const Tabs: React_2.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React_2.RefAttributes<HTMLDivElement>>;

 export declare const TabsContent: React_2.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const TabsList: React_2.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & VariantProps<(props?: ({
     container?: "transparent" | "underline" | "filled" | null | undefined;
     variant?: "transparent" | "underline" | "filled" | null | undefined;
     size?: "default" | "sm" | null | undefined;
     disabled?: boolean | null | undefined;
     underline?: boolean | null | undefined;
     orientation?: "horizontal" | "vertical" | null | undefined;
 } & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const TabsTrigger: React_2.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const tabVariants: (props?: ({
     container?: "transparent" | "underline" | "filled" | null | undefined;
     variant?: "transparent" | "underline" | "filled" | null | undefined;
     size?: "default" | "sm" | null | undefined;
     disabled?: boolean | null | undefined;
     underline?: boolean | null | undefined;
     orientation?: "horizontal" | "vertical" | null | undefined;
 } & ClassProp) | undefined) => string;

 declare const Text_2: default_2.ForwardRefExoticComponent<TextProps<AllowedElements_2> & default_2.RefAttributes<"symbol" | "object" | "code" | "map" | "filter" | "search" | "big" | "link" | "small" | "sub" | "sup" | "stop" | "set" | "g" | "label" | "a" | "button" | "div" | "form" | "h2" | "h3" | "img" | "input" | "li" | "nav" | "ol" | "p" | "select" | "span" | "svg" | "ul" | "abbr" | "address" | "area" | "article" | "aside" | "audio" | "b" | "base" | "bdi" | "bdo" | "blockquote" | "body" | "br" | "canvas" | "caption" | "center" | "cite" | "col" | "colgroup" | "data" | "datalist" | "dd" | "del" | "details" | "dfn" | "dialog" | "dl" | "dt" | "em" | "embed" | "fieldset" | "figcaption" | "figure" | "footer" | "h1" | "h4" | "h5" | "h6" | "head" | "header" | "hgroup" | "hr" | "html" | "i" | "iframe" | "ins" | "kbd" | "keygen" | "legend" | "main" | "mark" | "menu" | "menuitem" | "meta" | "meter" | "noindex" | "noscript" | "optgroup" | "option" | "output" | "param" | "picture" | "pre" | "progress" | "q" | "rp" | "rt" | "ruby" | "s" | "samp" | "slot" | "script" | "section" | "source" | "strong" | "style" | "summary" | "table" | "template" | "tbody" | "td" | "textarea" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "u" | "var" | "video" | "wbr" | "webview" | "animate" | "animateMotion" | "animateTransform" | "circle" | "clipPath" | "defs" | "desc" | "ellipse" | "feBlend" | "feColorMatrix" | "feComponentTransfer" | "feComposite" | "feConvolveMatrix" | "feDiffuseLighting" | "feDisplacementMap" | "feDistantLight" | "feDropShadow" | "feFlood" | "feFuncA" | "feFuncB" | "feFuncG" | "feFuncR" | "feGaussianBlur" | "feImage" | "feMerge" | "feMergeNode" | "feMorphology" | "feOffset" | "fePointLight" | "feSpecularLighting" | "feSpotLight" | "feTile" | "feTurbulence" | "foreignObject" | "image" | "line" | "linearGradient" | "marker" | "mask" | "metadata" | "mpath" | "path" | "pattern" | "polygon" | "polyline" | "radialGradient" | "rect" | "switch" | "text" | "textPath" | "tspan" | "use" | "view" | default_2.ComponentClass<any, any> | default_2.FunctionComponent<any>>>;
 export { Text_2 as Text }

 export declare const Textarea: React_2.ForwardRefExoticComponent<TextareaProps & React_2.RefAttributes<HTMLTextAreaElement>>;

 export declare interface TextareaProps extends React_2.TextareaHTMLAttributes<HTMLTextAreaElement>, VariantProps<typeof textAreaVariants>, Extra_2 {
 }

 declare const textAreaVariants: (props?: ({
     variant?: "default" | "outline" | "lighter" | null | undefined;
     rounded?: "full" | "default" | null | undefined;
     colors?: "default" | "destructive" | "success" | null | undefined;
 } & ClassProp) | undefined) => string;

 declare type TextProps<T extends AllowedElements_2 = 'span'> = {
     as?: T;
     asChild?: boolean;
     children: ReactNode;
 } & default_2.ComponentPropsWithoutRef<T>;

 export declare enum THEME {
     LIGHT = 1,
     DARK = 2,
     SYSTEM = 3
 }

 declare interface Theme {
     table?: {
         className?: string;
     };
     tableCaption?: {
         className?: string;
     };
     tableHeader?: {
         className?: string;
     };
     tableHead?: {
         className?: string;
     };
     tableBody?: {
         className?: string;
     };
     tableRow?: {
         className?: string;
     };
     tableCell?: {
         className?: string;
     };
     tableFooter?: {
         className?: string;
     };
     headerSelect?: {
         className?: string;
     };
     bodySelect?: {
         className?: string;
     };
 }

 declare const THEMES: {
     readonly light: "";
     readonly dark: ".dark";
 };

 declare interface Themes {
     size?: 'xs' | 'sm' | 'default';
     variant?: 'default' | 'brand';
     readOnly?: boolean;
     className?: string;
 }

 declare interface ThemeStore {
     theme: THEME | string;
     setTheme: (newTheme: THEME) => void;
 }

 export declare const TimePicker: ({ placeholder, value, onChange, rounded, lang, variant, className, colors, size, timeStep, ampm, disabled, modal, }: TimePickerProps) => JSX.Element;

 export declare type TimePickerProps = Props_4;

 export declare const Toast: React_2.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React_2.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
     variant?: "default" | "destructive" | "success" | "info" | "warning" | null | undefined;
     position?: "top" | "bottom" | "top-right" | "top-left" | "bottom-right" | "bottom-left" | null | undefined;
 } & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLLIElement>>;

 export declare function toast({ ...props }: Toast_2): {
     id: string;
     dismiss: () => void;
     update: (props: ToasterToast) => void;
 };

 declare type Toast_2 = Omit<ToasterToast, 'id'>;

 export declare const ToastAction: React_2.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare type ToastActionElement = React_2.ReactElement<typeof ToastAction>;

 export declare const ToastClose: React_2.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const ToastDescription: React_2.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare function Toaster({ position }: Readonly<{
     position?: ToastProps['position'];
 }>): JSX.Element;

 export declare type ToasterToast = ToastProps & {
     id: string;
     title?: React_2.ReactNode;
     description?: React_2.ReactNode;
     action?: ToastActionElement;
 };

 export declare const ToastIcon: {
     ({ icon }: {
         icon?: React_2.ReactNode;
     }): JSX.Element;
     displayName: string;
 };

 export declare type ToastProps = React_2.ComponentPropsWithoutRef<typeof Toast>;

 export declare const ToastProvider: React_2.FC<ToastPrimitives.ToastProviderProps>;

 export declare const ToastTitle: React_2.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const ToastViewport: React_2.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React_2.RefAttributes<HTMLOListElement>, "ref"> & VariantProps<(props?: ({
     position?: "top" | "bottom" | "top-right" | "top-left" | "bottom-right" | "bottom-left" | null | undefined;
 } & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLOListElement>>;

 export declare const Toggle: React_2.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
     variant?: "default" | "outline" | null | undefined;
     size?: "default" | "sm" | "xs" | "icon" | "icon-sm" | "icon-xs" | "fit" | null | undefined;
     rounded?: "full" | "default" | null | undefined;
     colors?: "default" | "oncolor" | "gray" | null | undefined;
 } & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const ToggleGroup: React_2.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React_2.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React_2.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
     variant?: "default" | "outline" | null | undefined;
     size?: "default" | "sm" | "xs" | "icon" | "icon-sm" | "icon-xs" | "fit" | null | undefined;
     rounded?: "full" | "default" | null | undefined;
     colors?: "default" | "oncolor" | "gray" | null | undefined;
 } & ClassProp) | undefined) => string>) & React_2.RefAttributes<HTMLDivElement>>;

 export declare const ToggleGroupItem: React_2.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
     variant?: "default" | "outline" | null | undefined;
     size?: "default" | "sm" | "xs" | "icon" | "icon-sm" | "icon-xs" | "fit" | null | undefined;
     rounded?: "full" | "default" | null | undefined;
     colors?: "default" | "oncolor" | "gray" | null | undefined;
 } & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const toggleVariants: (props?: ({
     variant?: "default" | "outline" | null | undefined;
     size?: "default" | "sm" | "xs" | "icon" | "icon-sm" | "icon-xs" | "fit" | null | undefined;
     rounded?: "full" | "default" | null | undefined;
     colors?: "default" | "oncolor" | "gray" | null | undefined;
 } & ClassProp) | undefined) => string;

 export declare const Tooltip: React_2.FC<TooltipPrimitive.TooltipProps>;

 export declare const TooltipContent: React_2.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const TooltipProvider: React_2.FC<TooltipPrimitive.TooltipProviderProps>;

 export declare const TooltipTrigger: React_2.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

 export declare const TrialVersion: ({ variant, colors, size, ...props }: BadgeProps) => JSX.Element;

 export declare const tw: (...classes: string[]) => string;

 export declare const twMerge: (...classLists: ClassNameValue[]) => string;

 /************************************
  Constants
  ************************************/
 export declare const ummalqura: {
     ummalquraData: number[];
     months: {
         ar: string[];
         en: string[];
     };
 };

 /**
  * A function that updates cached data based on the old data.
  *
  * @template T - The type of the cached data.
  * @param {QueryClient} queryClient - The queryClient instance.
  * @param {T | undefined} oldData - The current cached data or undefined if no data exists.
  * @returns {T} - The updated data.
  */
 declare type UpdaterFunction<T> = (draft: Draft<NoInfer<T>> | undefined) => T;

 export declare const useAuth: () => {
     isAuthenticated: boolean | undefined;
     user: import("..").Local_DTO.User;
     nationalId: string | null | undefined;
 };

 /**
  * Custom hook to retrieve cached data and its associated state.
  *
  * @template T - The type of data being queried.
  * @param {QueryClient} queryClient - The queryClient instance.
  * @param {QueryKey} queryKey - The key used to identify the query in the cache.
  * @param {(data: T | undefined) => T | undefined} [transform] - Optional transformation function to apply to the cached data.
  * @returns {QueryState<T>} The state of the query, including the data, status, and any errors.
  */
 export declare function useCachedData<T>(queryKey: QueryKey, queryClient: QueryClient, transform?: (data: T | undefined) => T | undefined): QueryState<T>;

 declare type UseCarouselParameters = Parameters<typeof default_3>;

 export { useCommandState }

 export { useController }

 export declare function useCopyToClipboard({ timeout, onCopy, }?: {
     timeout?: number;
     onCopy?: () => void;
 }): {
     isCopied: boolean;
     copyToClipboard: (value: string) => void;
 };

 export { useFieldArray }

 export { useForm }

 export { useFormContext }

 export declare const useFormField: () => {
     invalid: boolean;
     isDirty: boolean;
     isTouched: boolean;
     isValidating: boolean;
     error?: FieldError;
     newId: string;
     name: string;
     formItemId: string;
     formDescriptionId: string;
     formMessageId: string;
 };

 export { UseFormProps }

 export { UseFormReturn }

 export { useFormState }

 export declare function useGeoLocation(): {
     geolocation: {
         latitude: number;
         longitude: number;
     } | null;
     geoLocationError: string | null;
 };

 export declare const useIconConfig: () => IconConfig;

 export declare const useLanguage: UseBoundStore<Omit<Omit<StoreApi<Local_DTO.useLanguageStore>, "setState" | "devtools"> & {
 setState(partial: Local_DTO.useLanguageStore | Partial<Local_DTO.useLanguageStore> | ((state: Local_DTO.useLanguageStore) => Local_DTO.useLanguageStore | Partial<Local_DTO.useLanguageStore>), replace?: false | undefined, action?: (string | {
 [x: string]: unknown;
 [x: number]: unknown;
 [x: symbol]: unknown;
 type: string;
 }) | undefined): void;
 setState(state: Local_DTO.useLanguageStore | ((state: Local_DTO.useLanguageStore) => Local_DTO.useLanguageStore), replace: true, action?: (string | {
 [x: string]: unknown;
 [x: number]: unknown;
 [x: symbol]: unknown;
 type: string;
 }) | undefined): void;
 devtools: {
 cleanup: () => void;
 };
 }, "setState"> & {
 setState(nextStateOrUpdater: Local_DTO.useLanguageStore | Partial<Local_DTO.useLanguageStore> | ((state: WritableDraft<Local_DTO.useLanguageStore>) => void), shouldReplace?: false, action?: (string | {
 [x: string]: unknown;
 [x: number]: unknown;
 [x: symbol]: unknown;
 type: string;
 }) | undefined): void;
 setState(nextStateOrUpdater: Local_DTO.useLanguageStore | ((state: WritableDraft<Local_DTO.useLanguageStore>) => void), shouldReplace: true, action?: (string | {
 [x: string]: unknown;
 [x: number]: unknown;
 [x: symbol]: unknown;
 type: string;
 }) | undefined): void;
 }>;

 /**
  * @public
  */
 export declare const useOIDCAuth: () => AuthContextProps;

 export declare enum UserTypes {
     None = "None",
     Employee = "Employee",
     Student = "K12Student",
     Parent = "ParentGuardian"
 }

 export declare const useShareLink: (text: string) => void;

 export declare function useSidebar(): SidebarContext;

 export declare const useSwitchData: () => (arValue?: string, enValue?: string) => string;

 export declare const useThemeStore: UseBoundStore<Omit<Omit<StoreApi<ThemeStore>, "setState" | "devtools"> & {
 setState(partial: ThemeStore | Partial<ThemeStore> | ((state: ThemeStore) => ThemeStore | Partial<ThemeStore>), replace?: false | undefined, action?: (string | {
 [x: string]: unknown;
 [x: number]: unknown;
 [x: symbol]: unknown;
 type: string;
 }) | undefined): void;
 setState(state: ThemeStore | ((state: ThemeStore) => ThemeStore), replace: true, action?: (string | {
 [x: string]: unknown;
 [x: number]: unknown;
 [x: symbol]: unknown;
 type: string;
 }) | undefined): void;
 devtools: {
 cleanup: () => void;
 };
 }, "setState"> & {
 setState(nextStateOrUpdater: ThemeStore | Partial<ThemeStore> | ((state: WritableDraft<ThemeStore>) => void), shouldReplace?: false, action?: (string | {
 [x: string]: unknown;
 [x: number]: unknown;
 [x: symbol]: unknown;
 type: string;
 }) | undefined): void;
 setState(nextStateOrUpdater: ThemeStore | ((state: WritableDraft<ThemeStore>) => void), shouldReplace: true, action?: (string | {
 [x: string]: unknown;
 [x: number]: unknown;
 [x: symbol]: unknown;
 type: string;
 }) | undefined): void;
 }>;

 export declare function useToast(): {
     toast: typeof toast;
     dismiss: (toastId?: string) => void;
     toasts: ToasterToast[];
 };

 /**
  * A custom hook to update cached data in React Query.
  *
  * @template T - The type of the data in the cache.
  * @returns {(key: QueryKey, updater: T | UpdaterFunction<T>) => void} - A function to update the cached data.
  */
 export declare const useUpdateCachedData: <T>(queryClient: QueryClient) => (key: QueryKey, updater: T | UpdaterFunction<T>) => void;

 export { useWatch }

 declare type ValueType = string | number;

 declare type ValueType_2 = string | number;

 export declare enum VerificationType {
     email = 1,
     mobile = 2
 }

 /**
  * The props for the VirtualScroller component.
  * @param items - The items to display in the virtual scroller.
  * @param renderItem - The function to render each item.
  * @param options - The options for the virtual scroller.
  * @param onAsyncLoad - The function to load more data when the end of the list is reached.
  * @param isLoading - The flag to indicate if the list is loading.
  * @param async - The flag to indicate if the list is infinite.
  * @param renderLoader - The function to render the loader.
  */
 export declare const VirtualScroller: <T>({ items, renderItem, options, className, async, onAsyncLoad, isLoading, renderLoader, ...rest }: VirtualScrollerProps<T>) => JSX.Element;

 declare interface VirtualScrollerProps<T> extends default_2.HTMLAttributes<HTMLDivElement> {
     items: T[];
     renderItem: (item: T, virtualItem?: VirtualItem) => default_2.ReactNode;
     options?: Partial<VirtualizerOptions<HTMLDivElement, HTMLDivElement>>;
     onAsyncLoad?: () => void;
     isLoading?: boolean;
     async?: boolean;
     renderLoader?: (isLoading?: boolean) => default_2.ReactNode;
 }

 export declare const Widget: React_2.ForwardRefExoticComponent<WidgetProps & React_2.RefAttributes<HTMLDivElement>>;

 export declare interface WidgetActionItem extends Partial<ButtonProps> {
     label: string;
     icon?: React_2.ReactNode;
     onClick: () => void;
     'data-testid'?: string;
 }

 export declare const WidgetActions: {
     ({ actions }: WidgetActionsProps): JSX.Element;
     displayName: string;
 };

 declare interface WidgetActionsProps extends React_2.HTMLAttributes<HTMLDivElement> {
     actions: WidgetActionItem[];
 }

 export declare type WidgetBaseProps = Pick<WidgetProps, 'config' | 'isEditMode' | 'onConfigChange' | 'isDragOverlay' | 'isOver' | 'isDragging'>;

 export declare interface WidgetConfig {
     alias: string;
     title: string;
     titleEn: string;
     description?: string;
     descriptionEn?: string;
     srcImage?: string;
     srcImageEn?: string;
     size: WidgetSize;
     isVisible: boolean;
     isEditable: boolean;
     isMandatory: boolean;
     isResizable: boolean;
     containerValue?: string;
 }

 export declare const WidgetContent: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
     direction?: "col" | "row" | null | undefined;
 } & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLDivElement>>;

 export declare const WidgetHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;

 export declare interface WidgetProps extends React.HTMLAttributes<HTMLDivElement> {
     config: WidgetConfig;
     isEditMode: boolean;
     onConfigChange?: (changes: Partial<WidgetConfig>) => void;
     isDragOverlay?: boolean;
     isOver?: boolean;
     isDragging?: boolean;
 }

 export declare type WidgetSize = 'half' | 'full';

 export declare const WidgetTitle: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLHeadingElement> & React_2.RefAttributes<HTMLDivElement>>;

 export { }


declare module '@tanstack/react-table' {
    interface ColumnMeta<TData extends RowData, TValue> {
        headerColSpan?: number;
        cellColSpan?: number;
    }
}