@gbmtech/aurora-ui 0.0.1

package/dist/types/components/command.d.ts

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

package/dist/types/components/date-picker-with-range.d.ts

@@ -0,0 +1,11 @@
+import { DateRange } from 'react-day-picker';
+interface DatePickerWithRangeProps {
+    startDate?: Date;
+    endDate?: Date;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    onChange?: (date: DateRange | undefined) => void;
+}
+export declare function DatePickerWithRange({ startDate, endDate, onChange, placeholder, className, disabled, }: DatePickerWithRangeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/date-picker-with-time.d.ts

@@ -0,0 +1,10 @@
+interface DatePickerProps {
+    date?: Date;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    onChange?: (date: Date | undefined) => void;
+    onClear?: () => void;
+}
+export declare function DateTimePicker({ date, placeholder, className, disabled, onChange, onClear, }: DatePickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/date-picker.d.ts

@@ -0,0 +1,10 @@
+interface DatePickerProps {
+    date?: Date;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    hasTimePicker?: boolean;
+    onChange?: (date: Date | undefined) => void;
+}
+export declare function DatePicker({ date, placeholder, className, disabled, hasTimePicker, onChange, }: DatePickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/date-time-picker-with-range.d.ts

@@ -0,0 +1,11 @@
+import { DateRange } from 'react-day-picker';
+interface DateTimePickerWithRangeProps {
+    startDate?: Date;
+    endDate?: Date;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    onChange?: (date: DateRange | undefined) => void;
+}
+export declare function DateTimePickerWithRange({ startDate, endDate, onChange, placeholder, className, disabled, }: DateTimePickerWithRangeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/dialog.d.ts

@@ -0,0 +1,19 @@
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { HTMLAttributes } from 'react';
+declare const Dialog: import("react").FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: import("react").ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: import("react").FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: import("react").ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & import("react").RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: import("react").ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const DialogContent: import("react").ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: import("react").ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & import("react").RefAttributes<HTMLHeadingElement>, "ref"> & import("react").RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: import("react").ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & import("react").RefAttributes<HTMLParagraphElement>, "ref"> & import("react").RefAttributes<HTMLParagraphElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

package/dist/types/components/dropdown-menu.d.ts

@@ -0,0 +1,27 @@
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import { HTMLAttributes } from 'react';
+declare const DropdownMenu: import("react").FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: import("react").ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: import("react").ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: import("react").FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: import("react").FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: import("react").ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: import("react").ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & import("react").RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: import("react").ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: import("react").ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: import("react").ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & import("react").RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: import("react").ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: import("react").ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: import("react").ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & import("react").RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: import("react").ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/dist/types/components/form.d.ts

@@ -0,0 +1,23 @@
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as React from 'react';
+import { ControllerProps, FieldPath, FieldValues } from 'react-hook-form';
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>(props: import("react-hook-form").FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;
+declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => import("react/jsx-runtime").JSX.Element;
+declare const useFormField: () => {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: import("react-hook-form").FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+declare const FormItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const FormLabel: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & React.RefAttributes<HTMLLabelElement>>;
+declare const FormControl: React.ForwardRefExoticComponent<Omit<import("@radix-ui/react-slot").SlotProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const FormDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { useFormField, Form, FormItem, FormLabel, FormControl, FormDescription, FormMessage, FormField, };

package/dist/types/components/icons/rumo.d.ts

@@ -0,0 +1 @@
+export declare function Rumo(): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/icons/vli.d.ts

@@ -0,0 +1 @@
+export declare function VLI(): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/input-otp.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+declare const InputOTP: React.ForwardRefExoticComponent<(Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "onChange" | "maxLength" | "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: import("input-otp").RenderProps) => React.ReactNode;
+    children?: never;
+} & React.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "onChange" | "maxLength" | "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.ReactNode;
+} & React.RefAttributes<HTMLInputElement>, "ref">) & React.RefAttributes<HTMLInputElement>>;
+declare const InputOTPGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSlot: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    index: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSeparator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator };

package/dist/types/components/input-password.d.ts

@@ -0,0 +1,3 @@
+export type InputPasswordProps = React.InputHTMLAttributes<HTMLInputElement>;
+declare const InputPassword: import("react").ForwardRefExoticComponent<InputPasswordProps & import("react").RefAttributes<HTMLInputElement>>;
+export { InputPassword };

package/dist/types/components/input.d.ts

@@ -0,0 +1,12 @@
+import { InputHTMLAttributes, ReactNode } from 'react';
+export type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'prefix'> & {
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    inputClassName?: string;
+};
+declare const Input: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "prefix"> & {
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    inputClassName?: string;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export { Input };

package/dist/types/components/label.d.ts

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

package/dist/types/components/mask-input.d.ts

@@ -0,0 +1,8 @@
+import { InputHTMLAttributes } from 'react';
+interface MaskInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange'> {
+    value: number | undefined;
+    onChange: (value: number) => void;
+    decimals?: number;
+}
+declare function MaskInput({ value, onChange, decimals, className, ...rest }: MaskInputProps): import("react/jsx-runtime").JSX.Element;
+export { MaskInput };

package/dist/types/components/multi-select.d.ts

@@ -0,0 +1,23 @@
+import { type VariantProps } from 'class-variance-authority';
+import { ButtonHTMLAttributes, ComponentType } from 'react';
+declare const multiSelectVariants: (props?: ({
+    variant?: "default" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface MultiSelectProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof multiSelectVariants> {
+    options: {
+        label: string;
+        value: string;
+        icon?: ComponentType<{
+            className?: string;
+        }>;
+    }[];
+    defaultValue?: string[];
+    placeholder?: string;
+    maxCount?: number;
+    modalPopover?: boolean;
+    asChild?: boolean;
+    className?: string;
+    onValueChange?: (value: string[]) => void;
+}
+export declare const MultiSelect: import("react").ForwardRefExoticComponent<MultiSelectProps & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/types/components/page-layout/index.d.ts

@@ -0,0 +1,9 @@
+import { PageLayoutBreadcrumb } from './page-layout-breadcrumb';
+import { PageLayoutTitle } from './page-layout-title';
+export declare const PageLayout: {
+    Root: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Breadcrumb: typeof PageLayoutBreadcrumb;
+    Title: typeof PageLayoutTitle;
+    Header: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Content: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+};

package/dist/types/components/page-layout/page-layout-breadcrumb.d.ts

@@ -0,0 +1,16 @@
+import { ElementType } from 'react';
+interface PageLayoutBreadcrumbProps {
+    items: {
+        title: string;
+        href?: string;
+    }[];
+    module: {
+        title: string;
+        icon: ElementType;
+    };
+}
+declare function PageLayoutBreadcrumb({ module, items }: PageLayoutBreadcrumbProps): import("react/jsx-runtime").JSX.Element;
+declare namespace PageLayoutBreadcrumb {
+    var displayName: string;
+}
+export { PageLayoutBreadcrumb };

package/dist/types/components/page-layout/page-layout-content.d.ts

@@ -0,0 +1,2 @@
+declare const PageLayoutContent: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export { PageLayoutContent };

package/dist/types/components/page-layout/page-layout-header.d.ts

@@ -0,0 +1,2 @@
+declare const PageLayoutHeader: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export { PageLayoutHeader };

package/dist/types/components/page-layout/page-layout-root.d.ts

@@ -0,0 +1,2 @@
+declare const PageLayoutRoot: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export { PageLayoutRoot };

package/dist/types/components/page-layout/page-layout-title.d.ts

@@ -0,0 +1,7 @@
+import { ComponentProps } from 'react';
+import { Title } from '../title';
+declare function PageLayoutTitle(props: ComponentProps<typeof Title>): import("react/jsx-runtime").JSX.Element;
+declare namespace PageLayoutTitle {
+    var displayName: string;
+}
+export { PageLayoutTitle };

package/dist/types/components/pagination.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { ButtonProps } from './button';
+declare const Pagination: {
+    ({ className, ...props }: React.ComponentProps<"nav">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<ButtonProps, 'size'> & React.ComponentProps<'a'>;
+declare const PaginationLink: {
+    ({ className, isActive, size, ...props }: PaginationLinkProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationPrevious: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationNext: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Pagination, PaginationContent, PaginationLink, PaginationItem, PaginationPrevious, PaginationNext, PaginationEllipsis, };

package/dist/types/components/popover.d.ts

@@ -0,0 +1,5 @@
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+declare const Popover: import("react").FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: import("react").ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: import("react").ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export { Popover, PopoverTrigger, PopoverContent };

package/dist/types/components/scroll-area.d.ts

@@ -0,0 +1,4 @@
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+declare const ScrollBar: import("react").ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ScrollArea: import("react").ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export { ScrollArea, ScrollBar };

package/dist/types/components/select.d.ts

@@ -0,0 +1,11 @@
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as React from 'react';
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, };

package/dist/types/components/separator.d.ts

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

package/dist/types/components/skeleton.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+declare namespace Skeleton {
+    var displayName: string;
+}
+export { Skeleton };

package/dist/types/components/switch.d.ts

@@ -0,0 +1,3 @@
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+declare const Switch: import("react").ForwardRefExoticComponent<Omit<SwitchPrimitive.SwitchProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/dist/types/components/table-expandable.d.ts

@@ -0,0 +1,40 @@
+import React from 'react';
+type ExpandableTableRowWrapperProps = React.HTMLAttributes<HTMLDivElement> & {
+    children: [React.ReactNode, React.ReactNode];
+    /**
+     * Number of columns the content will occupy when expanded
+     * Not counting the icon column that comes by default
+     */
+    contentColSpan: number;
+    isExpanded?: boolean;
+    onToggleExpand?: VoidFunction;
+};
+/**
+ * A wrapper for expandable table rows.
+ *
+ * @param children - The first must be of type ExpandableTableRow and the second any component, such as a div.
+ * @param contentColSpan - Number of columns the content will occupy when expanded (excluding the default icon column).
+ */
+declare const ExpandableTableRowWrapper: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    children: [React.ReactNode, React.ReactNode];
+    /**
+     * Number of columns the content will occupy when expanded
+     * Not counting the icon column that comes by default
+     */
+    contentColSpan: number;
+    isExpanded?: boolean;
+    onToggleExpand?: VoidFunction;
+} & React.RefAttributes<HTMLDivElement>>;
+type ExpandableTableRowProps = React.HTMLAttributes<HTMLTableRowElement> & {
+    showIcon?: boolean;
+    'data-expanded'?: boolean;
+};
+declare const ExpandableTableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & {
+    showIcon?: boolean;
+    'data-expanded'?: boolean;
+} & React.RefAttributes<HTMLTableRowElement>>;
+type ExpandableTableRowContentProps = React.TdHTMLAttributes<HTMLTableCellElement> & {
+    isExpanded: boolean;
+};
+export type { ExpandableTableRowWrapperProps, ExpandableTableRowProps, ExpandableTableRowContentProps, };
+export { ExpandableTableRowWrapper, ExpandableTableRow };

package/dist/types/components/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/types/components/tabs/index.d.ts

@@ -0,0 +1,8 @@
+export declare const Tabs: {
+    Root: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-tabs").TabsProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
+        variant?: "primary" | "secondary";
+    } & import("react").RefAttributes<HTMLDivElement>>;
+    Trigger: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-tabs").TabsTriggerProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+    List: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-tabs").TabsListProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Content: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-tabs").TabsContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+};

package/dist/types/components/tabs/tabs-content.d.ts

@@ -0,0 +1,4 @@
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as React from 'react';
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { TabsContent };

package/dist/types/components/tabs/tabs-list.d.ts

@@ -0,0 +1,4 @@
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import React from 'react';
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { TabsList };

package/dist/types/components/tabs/tabs-root.d.ts

@@ -0,0 +1,12 @@
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import React from 'react';
+type tabsVariant = 'primary' | 'secondary';
+type TabsContext = {
+    variant?: tabsVariant;
+};
+declare const TabsContext: React.Context<TabsContext>;
+declare const useTabsContext: () => TabsContext;
+declare const TabsRoot: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    variant?: tabsVariant;
+} & React.RefAttributes<HTMLDivElement>>;
+export { TabsRoot, useTabsContext };

package/dist/types/components/tabs/tabs-trigger.d.ts

@@ -0,0 +1,4 @@
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as React from 'react';
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { TabsTrigger };

package/dist/types/components/textarea.d.ts

@@ -0,0 +1,4 @@
+import { TextareaHTMLAttributes } from 'react';
+export type TextareaProps = TextareaHTMLAttributes<HTMLTextAreaElement>;
+declare const Textarea: import("react").ForwardRefExoticComponent<TextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/types/components/time-picker-input.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { TimePickerType } from '../utils/time-picker';
+export interface TimePickerInputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    picker: TimePickerType;
+    date: Date | undefined;
+    setDate: (date: Date | undefined) => void;
+    onRightFocus?: () => void;
+    onLeftFocus?: () => void;
+}
+declare const TimePickerInput: React.ForwardRefExoticComponent<TimePickerInputProps & React.RefAttributes<HTMLInputElement>>;
+export { TimePickerInput };

package/dist/types/components/time-picker.d.ts

@@ -0,0 +1,6 @@
+interface TimePickerProps {
+    date: Date | undefined;
+    setDate: (date: Date | undefined) => void;
+}
+export declare function TimePicker({ date, setDate }: TimePickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/title.d.ts

@@ -0,0 +1,4 @@
+declare const Title: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & {
+    asChild?: boolean;
+} & import("react").RefAttributes<HTMLHeadingElement>>;
+export { Title };

package/dist/types/components/tokens-grid.d.ts

@@ -0,0 +1,6 @@
+interface TokensGridProps {
+    tokens: Record<string, string>;
+    hasRemValue?: boolean;
+}
+export declare function TokensGrid({ tokens, hasRemValue }: TokensGridProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/tooltip.d.ts

@@ -0,0 +1,9 @@
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as React 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"> & {
+    variant?: "primary" | "secondary";
+} & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/types/components/ui/time-picker-input.d.ts

@@ -0,0 +1,11 @@
+import { type InputHTMLAttributes } from 'react';
+import { type TimePickerType } from '../../utils/time-picker';
+export interface TimePickerInputProps extends InputHTMLAttributes<HTMLInputElement> {
+    picker: TimePickerType;
+    date: Date | undefined;
+    setDate: (date: Date | undefined) => void;
+    onRightFocus?: () => void;
+    onLeftFocus?: () => void;
+}
+declare const TimePickerInput: import("react").ForwardRefExoticComponent<TimePickerInputProps & import("react").RefAttributes<HTMLInputElement>>;
+export { TimePickerInput };

package/dist/types/components/ui/time-picker.d.ts

@@ -0,0 +1,6 @@
+interface TimePickerProps {
+    date: Date | undefined;
+    setDate: (date: Date | undefined) => void;
+}
+export declare function TimePicker({ date, setDate }: TimePickerProps): import("react/jsx-runtime").JSX.Element;
+export {};