@vertesia/ui 0.56.0 → 0.58.0

package/lib/types/core/components/popup/PopupController.d.ts

@@ -0,0 +1,40 @@
+import { Constraints, Position } from "./position";
+export interface PopupControllerOptions {
+    /**
+     * The element to use as the anchor for the popup.
+     */
+    anchor: HTMLElement;
+    closeOnClick?: boolean;
+    closeOnEsc?: boolean;
+    blockPageScroll?: boolean;
+    onClose?: (ctrl: PopupController) => void;
+    onOpen?: (ctrl: PopupController) => void;
+    root?: HTMLElement;
+}
+interface PopupControllerContext {
+    element: HTMLElement;
+    constraints: Constraints;
+    /**
+     * The computed position details
+     */
+    position?: Position;
+    cleanup: () => void;
+}
+export declare class PopupController {
+    options: PopupControllerOptions;
+    root: HTMLElement;
+    scrollableParents: HTMLElement[];
+    visibleClientRect: DOMRect | null;
+    context?: PopupControllerContext;
+    constructor(options: PopupControllerOptions);
+    get anchor(): HTMLElement;
+    private registerListeners;
+    open(element: HTMLElement, constraints: Constraints): void;
+    tryOpen(element: HTMLElement, constraints: Constraints): void;
+    close(): void;
+    tryClose(): void;
+    get isOpen(): boolean;
+    update(): void;
+    createPopupElement(): HTMLDivElement;
+}
+export {};

package/lib/types/core/components/popup/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Popup";
+export * from "./PopupController";
+export * from "./position";

package/lib/types/core/components/popup/position.d.ts

@@ -0,0 +1,58 @@
+export type PositionType = 'top' | 'right' | 'bottom' | 'left' | 'nw' | 'sw' | 'ne' | 'se';
+export type AlignType = 'start' | 'center' | 'end' | 'fill';
+export interface Constraints {
+    position: PositionType;
+    /**
+     * The alignment of the target element relative to the anchor element and the position constraint.
+     * The nw, ne, se, sw positions do not support any alignment. If any is given it will be ignored.
+     */
+    align?: AlignType;
+    /**
+     * A gap size between the anchor element and the target element.
+     */
+    gap?: number;
+    /**
+     * Whether the element should be displayed in a way that it covers the anchor element.
+     * This modifier change the interpretation of the position and alignment
+     */
+    cover?: boolean;
+    /**
+     * the minimum width in pixels accepted to display the target element.
+     * if the width contraint is not satisfied the element will be displayed in the opposite direction.
+     */
+    minWidth?: number;
+    /**
+     * the minimum height in pixels accepted to display the target element.
+     * if the height contraint is not satisfied the element will be displayed in the opposite direction
+     */
+    minHeight?: number;
+}
+export interface Position {
+    rect: DOMRect;
+    /**
+     * If true then the element must use the computed width, otherwise it should preserve his current width
+     */
+    constrainWidth: boolean;
+    /**
+     * If true then the element must use the computed height, otherwise it should preserve his current height
+     */
+    constrainHeight: boolean;
+    /**
+     * The position constraints used to compute the position
+     */
+    position: PositionType;
+    /**
+     * The alignment constraints used to compute the position
+     */
+    align?: AlignType;
+}
+/**
+ * Compute the position by trying to adjust the constraints until the computed position fits into the client area.
+ * Returns the best position that fits the constraints.
+ * @param constraints
+ * @param elemRect
+ * @param anchorRect
+ * @param clientRect
+ * @returns null if the element cannot be positioned otherwise returns a position object
+ */
+export declare function computePosition(constraints: Constraints, elemRect: DOMRect, anchorRect: DOMRect, clientRect: DOMRect): Position | null;

package/lib/types/core/components/popup/utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Compute the intersection of the two given rects.
+ * @param rect1
+ * @param rect2
+ * @returns
+ */
+export declare function intersectRects(rect1: DOMRect, rect2: DOMRect): DOMRect | null;
+/**
+ * Compute the visible rectangle of the scrollable parents.
+ * @param scrollableParents
+ * @returns
+ */
+export declare function computeVisibleClientRect(scrollableParents: HTMLElement[]): DOMRect | null;
+/**
+ * Tests whether the given element is scrollable in any direction.
+ * @param element
+ * @returns
+ */
+export declare function isScrollable(element: HTMLElement): boolean;
+/**
+ * Get the list of scrollable parents of the given element. The list always include the root parent at the end.
+ * The root parent is either the document.documentElement or the given root element.
+ * To iterate the list from top to down you need to iterate from the end to the start of the list,
+ * since the root parent is always the last element and the nearest scrollable parent is the first element.
+ * @param element
+ * @param root
+ * @returns
+ */
+export declare function getScrollableParents(element: HTMLElement, root?: HTMLElement): HTMLElement[];

package/lib/types/core/components/shadcn/breadcrumb.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+interface BreadcrumbProps {
+    label: string;
+    href?: string;
+}
+interface BreadcrumbItemProps {
+    children: BreadcrumbProps[];
+    className?: string;
+    maxItems?: number;
+    separator?: React.ReactNode;
+}
+export declare function Breadcrumbs({ children, maxItems, className, separator }: BreadcrumbItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/shadcn/button.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "secondary" | "destructive" | "outline" | "ghost" | "primary" | "soft" | "unstyled" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    alt?: string;
+    title?: string;
+    isDisabled?: boolean;
+    isLoading?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/lib/types/core/components/shadcn/calendar.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { DayPicker } from "react-day-picker";
+export type CalendarProps = React.ComponentProps<typeof DayPicker> & {
+    size?: "sm" | "md" | "lg";
+};
+declare function Calendar({ className, classNames, showOutsideDays, size, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar };

package/lib/types/core/components/shadcn/card.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

package/lib/types/core/components/shadcn/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };

package/lib/types/core/components/shadcn/command.d.ts

@@ -0,0 +1,80 @@
+import * as React from "react";
+import { type DialogProps } from "@radix-ui/react-dialog";
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    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.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandDialog: ({ children, ...props }: DialogProps) => import("react/jsx-runtime").JSX.Element;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "value" | "onChange" | "type"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "heading"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "onSelect" | "disabled"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/lib/types/core/components/shadcn/dialog.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+interface ModalProps {
+    children: React.ReactNode | React.ReactNode[];
+    isOpen: boolean;
+    onClose: () => void;
+    description?: string;
+    noCloseButton?: boolean;
+    className?: string;
+    allowOverflow?: boolean;
+    disableCloseOnClickOutside?: boolean;
+}
+export declare function useIsInModal(): boolean;
+export declare function ModalContextProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function VModal({ className, children, isOpen, onClose, description, noCloseButton, allowOverflow, disableCloseOnClickOutside, }: ModalProps): import("react/jsx-runtime").JSX.Element;
+export declare const VModalTitle: ({ children, show, className, ...props }: React.HTMLAttributes<HTMLHeadingElement> & {
+    show?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const VModalBody: ({ children, className, ...props }: React.HTMLAttributes<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+interface ModalFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    align?: "left" | "right" | "center";
+}
+export declare const VModalFooter: ({ align, children, className, ...props }: ModalFooterProps) => import("react/jsx-runtime").JSX.Element;
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogTrigger, DialogContent, DialogTitle, DialogDescription, };

package/lib/types/core/components/shadcn/filters/animateChangeInHeight.d.ts

@@ -0,0 +1,6 @@
+interface AnimateChangeInHeightProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export declare const AnimateChangeInHeight: React.FC<AnimateChangeInHeightProps>;
+export {};

package/lib/types/core/components/shadcn/filters/comboBox.d.ts

@@ -0,0 +1,17 @@
+import { FilterOption } from "./types";
+export declare const SelectionCombobox: ({ filterType, filterValues, setFilterValues, options, }: {
+    filterType: string;
+    filterValues: FilterOption[];
+    setFilterValues: (filterValues: FilterOption[]) => void;
+    options: FilterOption[];
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const DateCombobox: ({ filterValues, setFilterValues, }: {
+    filterType: string;
+    filterValues: string[];
+    setFilterValues: (values: string[]) => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TextCombobox: ({ filterValue, setFilterValue, }: {
+    filterType: string;
+    filterValue: string;
+    setFilterValue: (value: string) => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/lib/types/core/components/shadcn/filters/dateFilter.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { DateRange } from "react-day-picker";
+import { Filter, FilterGroup } from "./types";
+interface DateFilterProps {
+    selectedView: string | null;
+    dateRange: DateRange | undefined;
+    setDateRange: React.Dispatch<React.SetStateAction<DateRange | undefined>>;
+    setFilters: React.Dispatch<React.SetStateAction<Filter[]>>;
+    filters: Filter[];
+    handleClose: () => void;
+    filterGroups: FilterGroup[];
+}
+export default function DateFilter({ selectedView, dateRange, setDateRange, setFilters, filters, handleClose, filterGroups, }: DateFilterProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/shadcn/filters/filterBar.d.ts

@@ -0,0 +1,9 @@
+import { Dispatch, SetStateAction } from "react";
+import { Filter, FilterGroup } from "./types";
+interface FilterBarProps {
+    filters: Filter[];
+    setFilters: Dispatch<SetStateAction<Filter[]>>;
+    filterGroups: FilterGroup[];
+}
+export declare function FilterBar({ filters, setFilters, filterGroups }: FilterBarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/shadcn/filters/filters.d.ts

@@ -0,0 +1,9 @@
+import { Dispatch, SetStateAction } from "react";
+import { Filter, FilterGroup } from "./types";
+interface FiltersProps {
+    filters: Filter[];
+    setFilters: Dispatch<SetStateAction<Filter[]>>;
+    filterGroups: FilterGroup[];
+}
+export default function Filters({ filters, setFilters, filterGroups, }: FiltersProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/shadcn/filters/index.d.ts

@@ -0,0 +1,5 @@
+export * from './animateChangeInHeight';
+export * from './comboBox';
+export * from './filterBar';
+export * from './filters';
+export * from './types';

package/lib/types/core/components/shadcn/filters/selectFilter.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { Filter, FilterGroup } from "./types";
+interface SelectFilterProps {
+    selectedView: string | null;
+    commandInput: string;
+    setFilters: React.Dispatch<React.SetStateAction<Filter[]>>;
+    handleClose: () => void;
+    filterGroups: FilterGroup[];
+}
+export default function SelectFilter({ selectedView, commandInput, setFilters, handleClose, filterGroups, }: SelectFilterProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/lib/types/core/components/shadcn/filters/textFilter.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { Filter, FilterGroup } from "./types";
+interface TextFilterProps {
+    selectedView: string | null;
+    textValue: string;
+    setTextValue: (value: string) => void;
+    setFilters: React.Dispatch<React.SetStateAction<Filter[]>>;
+    handleClose: () => void;
+    filterGroups: FilterGroup[];
+}
+export default function TextFilter({ selectedView, textValue, setTextValue, setFilters, handleClose, filterGroups, }: TextFilterProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/shadcn/filters/types.d.ts

@@ -0,0 +1,26 @@
+export interface FilterOption {
+    label?: React.ReactNode;
+    value?: string;
+}
+export interface FilterGroup {
+    name: string;
+    placeholder?: string;
+    type?: "select" | "date" | "text";
+    options?: FilterOption[];
+    allowCreate?: boolean;
+    filterBy?: (value: string, searchText: string) => boolean;
+}
+export interface Filter {
+    name: string;
+    placeholder?: string;
+    value: FilterOption[];
+    type?: "select" | "date" | "text";
+}
+export declare enum FilterOperator {
+    IS = "is",
+    IS_NOT = "is_not",
+    CONTAINS = "contains",
+    BEFORE = "before",
+    AFTER = "after",
+    IS_ANY_OF = "is_any_of"
+}

package/lib/types/core/components/shadcn/heading.d.ts

@@ -0,0 +1,5 @@
+import { type HTMLAttributes } from "react";
+export interface HeadingProps extends HTMLAttributes<HTMLHeadingElement> {
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+}
+export declare const Heading: import("react").ForwardRefExoticComponent<HeadingProps & import("react").RefAttributes<HTMLHeadingElement>>;

package/lib/types/core/components/shadcn/index.d.ts

@@ -0,0 +1,21 @@
+import ModeToggle from './theme/ThemeSwitcher';
+import { ThemeProvider } from './theme/ThemeProvider';
+export { ModeToggle, ThemeProvider };
+export * from './button';
+export * from './card';
+export * from './dialog';
+export * from './input';
+export * from './separator';
+export * from './selectBox';
+export * from './tabs';
+export * from './tooltip';
+export * from './label';
+export * from './breadcrumb';
+export * from './dialog';
+export * from './button';
+export * from './filters';
+export * from './popover';
+export * from './command';
+export * from './checkbox';
+export * from './heading';
+export * from './text';

package/lib/types/core/components/shadcn/input.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const variants: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    variant?: "default" | "legacy" | "unstyled" | "noPadding" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type InputVariant = "default" | "unstyled" | "noPadding" | "legacy";
+export interface VInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'onChange'> {
+    size?: VariantProps<typeof variants>["size"];
+    variant?: InputVariant;
+    clearable?: boolean;
+    value?: string;
+    onChange?: (value: string) => void;
+}
+declare const VInput: React.ForwardRefExoticComponent<VInputProps & React.RefAttributes<HTMLInputElement>>;
+export { VInput, };

package/lib/types/core/components/shadcn/label.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+import { type VariantProps } from "class-variance-authority";
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: import("class-variance-authority/types").ClassProp | undefined) => string> & {
+    required?: boolean;
+} & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/lib/types/core/components/shadcn/popover.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+import { JSX } from "react";
+interface PopoverProps {
+    _open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    hover?: boolean;
+    click?: boolean;
+    children?: React.ReactNode;
+}
+declare const Popover: ({ hover, click, children, _open, onOpenChange }: PopoverProps) => JSX.Element;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverClose: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor, PopoverClose };

package/lib/types/core/components/shadcn/selectBox.d.ts

@@ -0,0 +1,21 @@
+interface VSelectBoxProps<T> {
+    options: T[] | undefined;
+    value?: T;
+    optionLabel?: (option: T) => React.ReactNode;
+    onChange: (option: T) => void;
+    onBlur?: () => void;
+    onKeyDown?: (e: React.KeyboardEvent, isOpen: boolean) => void;
+    label?: string;
+    placeholder?: string;
+    addNew?: () => void;
+    addNewLabel?: string;
+    disabled?: boolean;
+    filterBy?: string | ((o: T) => string);
+    by?: (keyof T & string) | ((a: T, z: T) => boolean);
+    className?: string;
+    popupClass?: string;
+    isClearable?: boolean;
+    border?: boolean;
+}
+export declare function VSelectBox<T = any>({ options, optionLabel, value, onChange, addNew, addNewLabel, disabled, filterBy, label, placeholder, className, popupClass, isClearable, border }: Readonly<VSelectBoxProps<T>>): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/shadcn/separator.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

package/lib/types/core/components/shadcn/tabs.d.ts

@@ -0,0 +1,26 @@
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import { Tab } from '../tabs/TabsContext.js';
+interface TabsProps {
+    current?: string | (() => string);
+    tabs: Tab[];
+    defaultValue?: string;
+    className?: string;
+    fullWidth?: boolean;
+    children?: React.ReactNode;
+    onTabChange?: (tabName: string) => void;
+    responsive?: boolean;
+}
+declare const VTabs: ({ tabs, defaultValue, current, className, fullWidth, children, onTabChange, responsive }: TabsProps) => import("react/jsx-runtime").JSX.Element;
+declare const VTabsBar: ({ className }: {
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element | null;
+declare const VTabsPanel: () => import("react/jsx-runtime").JSX.Element | null;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    size?: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    href?: string;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { VTabs, VTabsBar, VTabsPanel, TabsList, TabsTrigger, TabsContent };

package/lib/types/core/components/shadcn/text.d.ts

@@ -0,0 +1,10 @@
+import { type VariantProps } from "class-variance-authority";
+import { type HTMLAttributes } from "react";
+declare const textVariants: (props?: ({
+    size?: "xs" | "sm" | "lg" | "xl" | "default" | null | undefined;
+    weight?: "medium" | "normal" | "semibold" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface TextProps extends HTMLAttributes<HTMLParagraphElement>, VariantProps<typeof textVariants> {
+}
+export declare const Text: import("react").ForwardRefExoticComponent<TextProps & import("react").RefAttributes<HTMLParagraphElement>>;
+export {};

package/lib/types/core/components/shadcn/theme/ThemeProvider.d.ts

@@ -0,0 +1,13 @@
+type Theme = "dark" | "light" | "system";
+type ThemeProviderProps = {
+    children: React.ReactNode;
+    defaultTheme?: Theme;
+    storageKey?: string;
+};
+type ThemeProviderState = {
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+};
+export declare function ThemeProvider({ children, defaultTheme, storageKey, ...props }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare const useTheme: () => ThemeProviderState;
+export {};

package/lib/types/core/components/shadcn/theme/ThemeSwitcher.d.ts

@@ -0,0 +1,9 @@
+interface ModeOptionProps {
+    current: string;
+    option: ("system" | "light" | "dark");
+    setTheme: (theme: "system" | "light" | "dark") => void;
+    icon: React.ReactNode;
+}
+export declare function ModeOption({ option, current, setTheme, icon }: ModeOptionProps): import("react/jsx-runtime").JSX.Element;
+export default function ModeToggle(): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/shadcn/tooltip.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { ReactNode } from "react";
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    side?: "top" | "right" | "bottom" | "left";
+} & React.RefAttributes<HTMLDivElement>>;
+interface TooltipPopoverProps {
+    description?: ReactNode;
+    children: ReactNode;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    placement?: 'top' | 'right' | 'bottom' | 'left';
+    className?: string;
+    asChild?: boolean;
+}
+export declare function VTooltip({ description, children, size, placement, className, asChild }: TooltipPopoverProps): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/lib/types/core/components/styles.d.ts

@@ -0,0 +1,6 @@
+declare const Styles: {
+    INPUT_UNSTYLED: string;
+    INPUT_NO_PADDING: string;
+    INPUT: string;
+};
+export { Styles };