forlogic-core 1.15.2 → 1.15.4

package/dist/components/ui/rich-text-editor.d.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+export interface RichTextEditorProps {
+    /** Current HTML value */
+    value: string;
+    /** Callback when value changes */
+    onChange: (value: string) => void;
+    /** Disable the editor */
+    disabled?: boolean;
+    /** Error message */
+    error?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Minimum height of the editor */
+    minHeight?: string;
+    /** Show mode toggle buttons */
+    showModeToggle?: boolean;
+    /** Show variable hint */
+    showVariableHint?: boolean;
+    /** Custom class for the container */
+    className?: string;
+}
+/**
+ * RichTextEditor Component
+ *
+ * A rich text editor built with Tiptap, supporting:
+ * - Visual editing with toolbar
+ * - HTML code editing
+ * - Preview mode
+ * - Headings (H1, H2, H3)
+ * - Text formatting (bold, italic, underline, strikethrough)
+ * - Lists (ordered and unordered)
+ * - Links
+ * - Highlights
+ * - Undo/Redo
+ *
+ * @example
+ * ```tsx
+ * <RichTextEditor
+ *   value={content}
+ *   onChange={setContent}
+ *   placeholder="Write something..."
+ * />
+ * ```
+ */
+export declare const RichTextEditor: React.FC<RichTextEditorProps>;

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

@@ -0,0 +1,37 @@
+import * as React from "react";
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+/**
+ * ScrollArea Component
+ *
+ * Área de rolagem customizada com scrollbars estilizadas.
+ *
+ * @example
+ * ```tsx
+ * <ScrollArea className="h-72 w-48 rounded-md border">
+ *   <div className="p-4">
+ *     {items.map((item) => (
+ *       <div key={item.id} className="mb-4">
+ *         {item.content}
+ *       </div>
+ *     ))}
+ *   </div>
+ * </ScrollArea>
+ * ```
+ *
+ * ## Características
+ * - Scrollbars customizadas
+ * - Suporte a rolagem vertical e horizontal
+ * - Mantém bordas arredondadas do container
+ * - Acessibilidade completa
+ *
+ * @see https://www.radix-ui.com/docs/primitives/components/scroll-area
+ */
+declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * ScrollBar
+ *
+ * Scrollbar customizada com orientação vertical ou horizontal.
+ * Geralmente usada internamente pelo ScrollArea.
+ */
+declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ScrollArea, ScrollBar };

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

@@ -0,0 +1,16 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    container?: HTMLElement;
+    collisionBoundary?: HTMLElement;
+} & 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, SelectScrollUpButton, SelectScrollDownButton, };

package/dist/components/ui/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/dist/components/ui/sheet.d.ts

@@ -0,0 +1,32 @@
+import * as SheetPrimitive from "@radix-ui/react-dialog";
+import { type VariantProps } from "class-variance-authority";
+import * as React from "react";
+declare const Sheet: React.FC<SheetPrimitive.DialogProps>;
+declare const SheetTrigger: React.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React.FC<SheetPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: {
+    side?: "left" | "right" | "bottom" | "top";
+} & import("class-variance-authority/types").ClassProp) => string;
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
+interface SheetHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    showSeparator?: boolean;
+}
+declare const SheetHeader: {
+    ({ className, showSeparator, children, ...props }: SheetHeaderProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const SheetBody: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, children, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Sheet, SheetBody, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger };

package/dist/components/ui/sidebar.d.ts

@@ -0,0 +1,66 @@
+import * as React from "react";
+import { VariantProps } from "class-variance-authority";
+import { TooltipContent } from "./tooltip";
+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.Context<SidebarContext>;
+declare function useSidebar(): SidebarContext;
+declare const SidebarProvider: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Sidebar: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarTrigger: React.ForwardRefExoticComponent<Omit<import("./button").ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarRail: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarInset: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarInput: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const SidebarHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarSeparator: React.ForwardRefExoticComponent<Omit<Omit<import("@radix-ui/react-separator").SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupLabel: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupAction: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarGroupContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenu: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const SidebarMenuButton: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & VariantProps<(props?: {
+    variant?: "outline" | "default";
+    size?: "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuAction: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuBadge: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSkeleton: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    showIcon?: boolean;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSub: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuSubItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const SidebarMenuSubButton: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    asChild?: boolean;
+    size?: "sm" | "md";
+    isActive?: boolean;
+}, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, useSidebar };

package/dist/components/ui/skeleton-variants.d.ts

@@ -0,0 +1,16 @@
+interface TableSkeletonProps {
+    rows?: number;
+    columns?: number;
+}
+interface CardSkeletonProps {
+    count?: number;
+}
+interface FormSkeletonProps {
+    fields?: number;
+}
+export declare function TableSkeleton({ rows, columns }: TableSkeletonProps): import("react/jsx-runtime").JSX.Element;
+export declare function CardSkeleton({ count }: CardSkeletonProps): import("react/jsx-runtime").JSX.Element;
+export declare function FormSkeleton({ fields }: FormSkeletonProps): import("react/jsx-runtime").JSX.Element;
+export declare function HeaderSkeleton(): import("react/jsx-runtime").JSX.Element;
+export declare function SidebarSkeleton(): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/components/ui/slider.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SliderPrimitive from "@radix-ui/react-slider";
+declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Slider };

package/dist/components/ui/sonner.d.ts

@@ -0,0 +1,3 @@
+import { ToasterProps, toast } from "sonner";
+declare const Toaster: ({ ...props }: ToasterProps) => import("react/jsx-runtime").JSX.Element;
+export { Toaster, toast };

package/dist/components/ui/spinner.d.ts

@@ -0,0 +1,6 @@
+interface SpinnerProps {
+    size?: "sm" | "md" | "lg";
+    className?: string;
+}
+export declare function Spinner({ size, className }: SpinnerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/split-button.d.ts

@@ -0,0 +1,70 @@
+import { buttonVariants } from './button';
+import type { VariantProps } from 'class-variance-authority';
+import type { LucideIcon } from 'lucide-react';
+/**
+ * Representa uma ação secundária no menu do Split Button
+ */
+export interface SplitButtonAction {
+    /** Identificador único da ação */
+    id: string;
+    /** Texto exibido no menu */
+    label: string;
+    /** Ícone opcional (componente Lucide) */
+    icon?: LucideIcon;
+    /** Callback executado ao clicar */
+    onClick: () => void;
+    /** Se true, a ação fica desabilitada */
+    disabled?: boolean;
+    /** Variante visual da ação */
+    variant?: 'default' | 'destructive';
+}
+/**
+ * Props do componente SplitButton
+ */
+export interface SplitButtonProps extends Omit<VariantProps<typeof buttonVariants>, 'variant' | 'size'> {
+    /** Texto do botão principal */
+    label: string;
+    /** Callback executado ao clicar no botão principal */
+    onClick: () => void;
+    /** Ícone opcional do botão principal (componente Lucide) */
+    icon?: LucideIcon;
+    /** Lista de ações secundárias exibidas no menu dropdown */
+    actions?: SplitButtonAction[];
+    /** Variante visual do botão */
+    variant?: 'default' | 'secondary' | 'outline' | 'ghost';
+    /** Tamanho do botão */
+    size?: 'sm' | 'default' | 'lg';
+    /** Se true, desabilita todo o componente */
+    disabled?: boolean;
+    /** Se true, exibe estado de loading no botão principal */
+    loading?: boolean;
+    /** Alinhamento do menu dropdown */
+    menuAlign?: 'start' | 'end';
+    /** Classes CSS adicionais */
+    className?: string;
+}
+/**
+ * SplitButton - Componente que combina uma ação principal com ações secundárias em um menu dropdown.
+ *
+ * @description
+ * O Split Button é ideal para fluxos onde existe uma ação principal clara acompanhada de
+ * ações secundárias relacionadas. Ele destaca visualmente a ação prioritária enquanto
+ * mantém as alternativas acessíveis.
+ *
+ * @example
+ * ```tsx
+ * <SplitButton
+ *   label="Salvar"
+ *   onClick={() => handleSave()}
+ *   icon={Save}
+ *   actions={[
+ *     { id: 'save-draft', label: 'Salvar como Rascunho', onClick: handleSaveDraft },
+ *     { id: 'save-template', label: 'Salvar como Modelo', onClick: handleSaveTemplate },
+ *   ]}
+ * />
+ * ```
+ *
+ * @see {@link https://ui.shadcn.com/docs/components/button Button}
+ * @see {@link https://ui.shadcn.com/docs/components/dropdown-menu DropdownMenu}
+ */
+export declare function SplitButton({ label, onClick, icon: Icon, actions, variant, size, disabled, loading, menuAlign, className, }: SplitButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/stack.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from "react";
+interface StackProps {
+    children: ReactNode;
+    direction?: "row" | "column";
+    gap?: "xs" | "sm" | "md" | "lg" | "xl";
+    align?: "start" | "center" | "end" | "stretch";
+    justify?: "start" | "center" | "end" | "between" | "around" | "evenly";
+    wrap?: boolean;
+    className?: string;
+}
+export declare function Stack({ children, direction, gap, align, justify, wrap, className }: StackProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/step-selector.d.ts

@@ -0,0 +1,39 @@
+/**
+ * StepSelector - Componente de navegação para Wizards multi-etapas
+ *
+ * Combina um DropdownMenu para seleção de etapas com uma barra de Progress
+ * para indicação visual do progresso. Ideal para uso em DialogFooter.
+ *
+ * @example
+ * ```tsx
+ * <StepSelector
+ *   currentStep={step}
+ *   totalSteps={4}
+ *   onStepChange={setStep}
+ *   stepLabels={['Tipo', 'Dados', 'Config', 'Confirmar']}
+ *   canGoToStep={(target) => target <= maxValidStep}
+ * />
+ * ```
+ */
+export interface StepSelectorProps {
+    /** Etapa atual (1-indexed) */
+    currentStep: number;
+    /** Total de etapas */
+    totalSteps: number;
+    /** Callback chamado quando uma etapa é selecionada */
+    onStepChange: (step: number) => void;
+    /** Labels customizados para cada etapa (opcional) */
+    stepLabels?: string[];
+    /**
+     * Função que valida se pode navegar para uma etapa específica.
+     * Retornar etapas anteriores é sempre permitido.
+     * Se não fornecida, todas as etapas são acessíveis.
+     */
+    canGoToStep?: (targetStep: number) => boolean;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Largura da barra de progresso */
+    progressWidth?: string;
+}
+declare function StepSelector({ currentStep, totalSteps, onStepChange, stepLabels, canGoToStep, className, progressWidth, }: StepSelectorProps): import("react/jsx-runtime").JSX.Element;
+export { StepSelector };

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

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

package/dist/components/ui/tab-page-layout.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from "react";
+interface TabPageLayoutProps {
+    children: ReactNode;
+    className?: string;
+}
+interface TabPageHeaderProps {
+    title: string | ReactNode;
+    description?: string;
+    actions?: ReactNode;
+    className?: string;
+}
+interface TabPageContentProps {
+    children: ReactNode;
+    className?: string;
+}
+export declare function TabPageLayout({ children, className }: TabPageLayoutProps): import("react/jsx-runtime").JSX.Element;
+export declare function TabPageHeader({ title, description, actions, className }: TabPageHeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare function TabPageContent({ children, className }: TabPageContentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/table-resize-handle.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+interface TableResizeHandleProps {
+    direction: 'horizontal' | 'vertical';
+    onMouseDown: (e: React.MouseEvent) => void;
+    isDragging?: boolean;
+    className?: string;
+}
+/**
+ * TableResizeHandle
+ *
+ * Handle visual para resize de colunas (horizontal) ou linhas (vertical) em tabelas.
+ * Segue o padrão visual do ResizableHandle do Design System.
+ */
+export declare const TableResizeHandle: React.ForwardRefExoticComponent<TableResizeHandleProps & React.RefAttributes<HTMLDivElement>>;
+export { TableResizeHandle as default };

package/dist/components/ui/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/components/ui/tabs.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/components/ui/toggle-group.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+import { type VariantProps } from "class-variance-authority";
+declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: {
+    variant?: "outline" | "default";
+    size?: "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string>) & React.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: {
+    variant?: "outline" | "default";
+    size?: "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { ToggleGroup, ToggleGroupItem };

package/dist/components/ui/toggle.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import { type VariantProps } from "class-variance-authority";
+declare const toggleVariants: (props?: {
+    variant?: "outline" | "default";
+    size?: "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string;
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: {
+    variant?: "outline" | "default";
+    size?: "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, toggleVariants };

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare const TooltipProvider: ({ delayDuration, ...props }: React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Provider>) => import("react/jsx-runtime").JSX.Element;
+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"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/components/ui/truncated-cell.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+interface TruncatedCellProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function TruncatedCell({ children, className }: TruncatedCellProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/typography.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+export interface TypographyProps extends React.HTMLAttributes<HTMLElement> {
+}
+declare const H1: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const H2: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const H3: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const H4: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const P: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const Lead: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const Large: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLDivElement>>;
+declare const Small: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLElement>>;
+declare const Muted: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const InlineCode: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLElement>>;
+declare const Blockquote: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLQuoteElement>>;
+declare const List: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLUListElement>>;
+export { H1, H2, H3, H4, P, Lead, Large, Small, Muted, InlineCode, Blockquote, List, };

package/dist/config/index.d.ts

@@ -0,0 +1,53 @@
+export declare const AUTH_CONFIG: {
+    readonly oauth: {
+        readonly authUrl: any;
+        readonly clientId: any;
+        readonly responseType: "id_token token";
+        readonly scope: "openid profile email";
+    };
+};
+export declare const CRUD_CONFIG: {
+    readonly pagination: {
+        readonly defaultPageSize: 25;
+        readonly pageSizeOptions: readonly [10, 25, 50, 100];
+    };
+    readonly sorting: {
+        readonly defaultField: "updated_at";
+        readonly defaultDirection: "desc";
+    };
+};
+export declare const SEARCH_CONFIG: {
+    readonly debounceDelay: 500;
+};
+export declare const isDevEnvironment: () => boolean;
+export declare const QUERY_KEYS: {
+    readonly crud: (entity: string) => readonly [string];
+    readonly list: (entity: string, filters?: Record<string, any>) => readonly [string, "list", Record<string, any>];
+    readonly detail: (entity: string, id: string) => readonly [string, "detail", string];
+};
+export declare const QUALIEX_CONFIG: {
+    readonly userNameFieldSuffix: "_name";
+    readonly userEmailFieldSuffix: "_email";
+    readonly userUsernameFieldSuffix: "_username";
+};
+export declare const getQualiexConfig: () => {
+    readonly userNameFieldSuffix: "_name";
+    readonly userEmailFieldSuffix: "_email";
+    readonly userUsernameFieldSuffix: "_username";
+};
+export declare const LOGO_CONFIG: {
+    readonly isQualiex: boolean;
+};
+export declare const MESSAGES: {
+    readonly success: {
+        readonly created: (entity: string) => string;
+        readonly updated: (entity: string) => string;
+        readonly deleted: (entity: string) => string;
+    };
+    readonly error: {
+        readonly create: (entity: string) => string;
+        readonly update: (entity: string) => string;
+        readonly delete: (entity: string) => string;
+        readonly load: (entity: string) => string;
+    };
+};

package/dist/contexts/LocaleContext.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+interface LocaleContextType {
+    locale: string;
+    timezone: string;
+    datetimeFormat: string;
+    setLocale: (locale: string) => Promise<void>;
+    setTimezone: (timezone: string) => Promise<void>;
+    setDatetimeFormat: (format: string) => Promise<void>;
+    isLoading: boolean;
+}
+export declare const LocaleProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useLocale: () => LocaleContextType;
+export {};