florixui 1.0.0

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

@@ -0,0 +1,278 @@
+import { default as MapLibreGL, PopupOptions, MarkerOptions } from 'maplibre-gl';
+import { ReactNode } from 'react';
+/** Selectable basemap tiles. The first is the default; the second is Voyager. */
+export type MapTile = {
+    label: string;
+    url: string;
+};
+type Theme = "light" | "dark";
+type MapContextValue = {
+    map: MapLibreGL.Map | null;
+    isLoaded: boolean;
+};
+declare function useMap(): MapContextValue;
+/** Map viewport state */
+type MapViewport = {
+    /** Center coordinates [longitude, latitude] */
+    center: [number, number];
+    /** Zoom level */
+    zoom: number;
+    /** Bearing (rotation) in degrees */
+    bearing: number;
+    /** Pitch (tilt) in degrees */
+    pitch: number;
+};
+type MapStyleOption = string | MapLibreGL.StyleSpecification;
+type MapRef = MapLibreGL.Map;
+declare const Map: import('react').ForwardRefExoticComponent<{
+    children?: ReactNode;
+    /** Additional CSS classes for the map container */
+    className?: string;
+    /**
+     * Theme for the map. If not provided, automatically detects system preference.
+     * Pass your theme value here.
+     */
+    theme?: Theme;
+    /** Custom map styles for light and dark themes. Overrides the default Carto styles. */
+    styles?: {
+        light?: MapStyleOption;
+        dark?: MapStyleOption;
+    };
+    /** Map projection type. Use `{ type: "globe" }` for 3D globe view. */
+    projection?: MapLibreGL.ProjectionSpecification;
+    /**
+     * Controlled viewport. When provided with onViewportChange,
+     * the map becomes controlled and viewport is driven by this prop.
+     */
+    viewport?: Partial<MapViewport>;
+    /**
+     * Callback fired continuously as the viewport changes (pan, zoom, rotate, pitch).
+     * Can be used standalone to observe changes, or with `viewport` prop
+     * to enable controlled mode where the map viewport is driven by your state.
+     */
+    onViewportChange?: (viewport: MapViewport) => void;
+    /** Show a loading indicator on the map */
+    loading?: boolean;
+    /**
+     * Render default zoom controls (bottom-right). Defaults to true.
+     * Set to false to omit them or to supply your own <MapControls />.
+     */
+    controls?: boolean;
+    /**
+     * Selectable basemap tiles, shown as a picker (top-left). Defaults to
+     * Light / Voyager / Dark. Set to false to hide the tile picker.
+     */
+    tiles?: MapTile[] | false;
+} & Omit<MapLibreGL.MapOptions, "style" | "container"> & import('react').RefAttributes<MapLibreGL.Map>>;
+type MapMarkerProps = {
+    /** Longitude coordinate for marker position */
+    longitude: number;
+    /** Latitude coordinate for marker position */
+    latitude: number;
+    /** Marker subcomponents (MarkerContent, MarkerPopup, MarkerTooltip, MarkerLabel) */
+    children: ReactNode;
+    /** Callback when marker is clicked */
+    onClick?: (e: MouseEvent) => void;
+    /** Callback when mouse enters marker */
+    onMouseEnter?: (e: MouseEvent) => void;
+    /** Callback when mouse leaves marker */
+    onMouseLeave?: (e: MouseEvent) => void;
+    /** Callback when marker drag starts (requires draggable: true) */
+    onDragStart?: (lngLat: {
+        lng: number;
+        lat: number;
+    }) => void;
+    /** Callback during marker drag (requires draggable: true) */
+    onDrag?: (lngLat: {
+        lng: number;
+        lat: number;
+    }) => void;
+    /** Callback when marker drag ends (requires draggable: true) */
+    onDragEnd?: (lngLat: {
+        lng: number;
+        lat: number;
+    }) => void;
+} & Omit<MarkerOptions, "element">;
+declare function MapMarker({ longitude, latitude, children, onClick, onMouseEnter, onMouseLeave, onDragStart, onDrag, onDragEnd, draggable, ...markerOptions }: MapMarkerProps): import("react/jsx-runtime").JSX.Element;
+type MarkerContentProps = {
+    /** Custom marker content. Defaults to a blue dot if not provided */
+    children?: ReactNode;
+    /** Additional CSS classes for the marker container */
+    className?: string;
+};
+declare function MarkerContent({ children, className }: MarkerContentProps): import('react').ReactPortal;
+type MarkerPopupProps = {
+    /** Popup content */
+    children: ReactNode;
+    /** Additional CSS classes for the popup container */
+    className?: string;
+    /** Show a close button in the popup (default: false) */
+    closeButton?: boolean;
+} & Omit<PopupOptions, "className" | "closeButton">;
+declare function MarkerPopup({ children, className, closeButton, ...popupOptions }: MarkerPopupProps): import('react').ReactPortal;
+type MarkerTooltipProps = {
+    /** Tooltip content */
+    children: ReactNode;
+    /** Additional CSS classes for the tooltip container */
+    className?: string;
+} & Omit<PopupOptions, "className" | "closeButton" | "closeOnClick">;
+declare function MarkerTooltip({ children, className, ...popupOptions }: MarkerTooltipProps): import('react').ReactPortal;
+type MarkerLabelProps = {
+    /** Label text content */
+    children: ReactNode;
+    /** Additional CSS classes for the label */
+    className?: string;
+    /** Position of the label relative to the marker (default: "top") */
+    position?: "top" | "bottom";
+};
+declare function MarkerLabel({ children, className, position, }: MarkerLabelProps): import("react/jsx-runtime").JSX.Element;
+type MapControlsProps = {
+    /** Position of the controls on the map (default: "bottom-right") */
+    position?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    /** Show zoom in/out buttons (default: true) */
+    showZoom?: boolean;
+    /** Show compass button to reset bearing (default: false) */
+    showCompass?: boolean;
+    /** Show locate button to find user's location (default: false) */
+    showLocate?: boolean;
+    /** Show fullscreen toggle button (default: false) */
+    showFullscreen?: boolean;
+    /** Additional CSS classes for the controls container */
+    className?: string;
+    /** Callback with user coordinates when located */
+    onLocate?: (coords: {
+        longitude: number;
+        latitude: number;
+    }) => void;
+    /** Basemap tiles for the tile-cycle button. Hidden when fewer than 2. */
+    tiles?: MapTile[];
+    /** Index of the active tile. */
+    tileIndex?: number;
+    /** Called with the next tile index when the tile button is clicked. */
+    onTileChange?: (index: number) => void;
+};
+declare function MapControls({ position, showZoom, showCompass, showLocate, showFullscreen, className, onLocate, tiles, tileIndex, onTileChange, }: MapControlsProps): import("react/jsx-runtime").JSX.Element;
+type MapPopupProps = {
+    /** Longitude coordinate for popup position */
+    longitude: number;
+    /** Latitude coordinate for popup position */
+    latitude: number;
+    /** Callback when popup is closed */
+    onClose?: () => void;
+    /** Popup content */
+    children: ReactNode;
+    /** Additional CSS classes for the popup container */
+    className?: string;
+    /** Show a close button in the popup (default: false) */
+    closeButton?: boolean;
+} & Omit<PopupOptions, "className" | "closeButton">;
+declare function MapPopup({ longitude, latitude, onClose, children, className, closeButton, ...popupOptions }: MapPopupProps): import('react').ReactPortal;
+type MapRouteProps = {
+    /** Optional unique identifier for the route layer */
+    id?: string;
+    /** Array of [longitude, latitude] coordinate pairs defining the route */
+    coordinates: [number, number][];
+    /** Line color as CSS color value (default: "#4285F4") */
+    color?: string;
+    /** Line width in pixels (default: 3) */
+    width?: number;
+    /** Line opacity from 0 to 1 (default: 0.8) */
+    opacity?: number;
+    /** Dash pattern [dash length, gap length] for dashed lines */
+    dashArray?: [number, number];
+    /** Callback when the route line is clicked */
+    onClick?: () => void;
+    /** Callback when mouse enters the route line */
+    onMouseEnter?: () => void;
+    /** Callback when mouse leaves the route line */
+    onMouseLeave?: () => void;
+    /** Whether the route is interactive - shows pointer cursor on hover (default: true) */
+    interactive?: boolean;
+};
+declare function MapRoute({ id: propId, coordinates, color, width, opacity, dashArray, onClick, onMouseEnter, onMouseLeave, interactive, }: MapRouteProps): null;
+/** A single arc to render inside <MapArc data={...}>. */
+type MapArcDatum = {
+    /** Unique identifier for this arc. Required for hover state tracking and event payloads. */
+    id: string | number;
+    /** Start coordinate as [longitude, latitude]. */
+    from: [number, number];
+    /** End coordinate as [longitude, latitude]. */
+    to: [number, number];
+};
+/** Event payload passed to MapArc interaction callbacks. */
+type MapArcEvent<T extends MapArcDatum = MapArcDatum> = {
+    /** The arc datum that was hovered or clicked. */
+    arc: T;
+    /** Longitude of the cursor at the time of the event. */
+    longitude: number;
+    /** Latitude of the cursor at the time of the event. */
+    latitude: number;
+    /** The underlying MapLibre mouse event for advanced use cases. */
+    originalEvent: MapLibreGL.MapMouseEvent;
+};
+type MapArcLinePaint = NonNullable<MapLibreGL.LineLayerSpecification["paint"]>;
+type MapArcLineLayout = NonNullable<MapLibreGL.LineLayerSpecification["layout"]>;
+type MapArcProps<T extends MapArcDatum = MapArcDatum> = {
+    /** Array of arcs to render. Each arc must have a unique `id`. */
+    data: T[];
+    /** Optional unique identifier prefix for the arc source/layers. Auto-generated if not provided. */
+    id?: string;
+    /**
+     * How far each arc bows away from a straight line. `0` renders straight
+     * lines; higher values bend further. Negative values bend to the opposite
+     * side. Arcs are computed as a quadratic Bézier in lng/lat space and do not
+     * account for the antimeridian. (default: 0.2)
+     */
+    curvature?: number;
+    /** Number of samples used to render each curve. Higher = smoother. (default: 64) */
+    samples?: number;
+    /**
+     * MapLibre paint properties for the arc layer. Merged on top of sensible
+     * defaults (`line-color: #4285F4`, `line-width: 2`, `line-opacity: 0.85`).
+     * Any value can be a MapLibre expression for per-feature styling, every
+     * field on each arc datum (besides `from`/`to`) is exposed via `["get", ...]`.
+     */
+    paint?: MapArcLinePaint;
+    /** MapLibre layout properties for the arc layer. Defaults to rounded joins/caps. */
+    layout?: MapArcLineLayout;
+    /**
+     * Paint properties applied to the arc currently under the cursor. Each key
+     * is merged into `paint` as a `case` expression keyed on per-feature hover
+     * state, so only the hovered arc changes appearance.
+     */
+    hoverPaint?: MapArcLinePaint;
+    /** Callback when an arc is clicked. */
+    onClick?: (e: MapArcEvent<T>) => void;
+    /**
+     * Callback fired when the hovered arc changes. Receives the cursor's
+     * lng/lat at the moment of entry, and `null` when the cursor leaves the
+     * last hovered arc.
+     */
+    onHover?: (e: MapArcEvent<T> | null) => void;
+    /** Whether arcs respond to mouse events (default: true). */
+    interactive?: boolean;
+    /** Optional MapLibre layer id to insert the arc layers before (z-order control). */
+    beforeId?: string;
+};
+declare function MapArc<T extends MapArcDatum = MapArcDatum>({ data, id: propId, curvature, samples, paint, layout, hoverPaint, onClick, onHover, interactive, beforeId, }: MapArcProps<T>): null;
+type MapClusterLayerProps<P extends GeoJSON.GeoJsonProperties = GeoJSON.GeoJsonProperties> = {
+    /** GeoJSON FeatureCollection data or URL to fetch GeoJSON from */
+    data: string | GeoJSON.FeatureCollection<GeoJSON.Point, P>;
+    /** Maximum zoom level to cluster points on (default: 14) */
+    clusterMaxZoom?: number;
+    /** Radius of each cluster when clustering points in pixels (default: 50) */
+    clusterRadius?: number;
+    /** Colors for cluster circles: [small, medium, large] based on point count (default: ["#22c55e", "#eab308", "#ef4444"]) */
+    clusterColors?: [string, string, string];
+    /** Point count thresholds for color/size steps: [medium, large] (default: [100, 750]) */
+    clusterThresholds?: [number, number];
+    /** Color for unclustered individual points (default: "#3b82f6") */
+    pointColor?: string;
+    /** Callback when an unclustered point is clicked */
+    onPointClick?: (feature: GeoJSON.Feature<GeoJSON.Point, P>, coordinates: [number, number]) => void;
+    /** Callback when a cluster is clicked. If not provided, zooms into the cluster */
+    onClusterClick?: (clusterId: number, coordinates: [number, number], pointCount: number) => void;
+};
+declare function MapClusterLayer<P extends GeoJSON.GeoJsonProperties = GeoJSON.GeoJsonProperties>({ data, clusterMaxZoom, clusterRadius, clusterColors, clusterThresholds, pointColor, onPointClick, onClusterClick, }: MapClusterLayerProps<P>): null;
+export { Map, useMap, MapMarker, MarkerContent, MarkerPopup, MarkerTooltip, MarkerLabel, MapPopup, MapControls, MapRoute, MapArc, MapClusterLayer, };
+export type { MapRef, MapViewport, MapArcDatum, MapArcEvent };

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

@@ -0,0 +1,10 @@
+import { Popover as PopoverPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function PopoverTitle({ className, ...props }: React.ComponentProps<"h2">): import("react/jsx-runtime").JSX.Element;
+declare function PopoverDescription({ className, ...props }: React.ComponentProps<"p">): import("react/jsx-runtime").JSX.Element;
+export { Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, };

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

@@ -0,0 +1,4 @@
+import { Progress as ProgressPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function Progress({ className, value, ...props }: React.ComponentProps<typeof ProgressPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Progress };

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

@@ -0,0 +1,5 @@
+import { RadioGroup as RadioGroupPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function RadioGroup({ className, ...props }: React.ComponentProps<typeof RadioGroupPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function RadioGroupItem({ className, ...props }: React.ComponentProps<typeof RadioGroupPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+export { RadioGroup, RadioGroupItem };

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

@@ -0,0 +1,15 @@
+import { Select as SelectPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function SelectGroup({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+    size?: "sm" | "default";
+}): import("react/jsx-runtime").JSX.Element;
+declare function SelectContent({ className, children, position, align, ...props }: React.ComponentProps<typeof SelectPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
+declare function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): import("react/jsx-runtime").JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

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

@@ -0,0 +1,4 @@
+import { Separator as SeparatorPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function Separator({ className, orientation, decorative, ...props }: React.ComponentProps<typeof SeparatorPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Separator };

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

@@ -0,0 +1,14 @@
+import { Dialog as SheetPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function Sheet({ ...props }: React.ComponentProps<typeof SheetPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function SheetTrigger({ ...props }: React.ComponentProps<typeof SheetPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function SheetClose({ ...props }: React.ComponentProps<typeof SheetPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
+declare function SheetContent({ className, children, side, showCloseButton, ...props }: React.ComponentProps<typeof SheetPrimitive.Content> & {
+    side?: "top" | "right" | "bottom" | "left";
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SheetHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SheetFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SheetTitle({ className, ...props }: React.ComponentProps<typeof SheetPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function SheetDescription({ className, ...props }: React.ComponentProps<typeof SheetPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+export { Sheet, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

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

@@ -0,0 +1,4 @@
+import { Slider as SliderPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function Slider({ className, defaultValue, value, min, max, ...props }: React.ComponentProps<typeof SliderPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Slider };

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

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

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

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

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

@@ -0,0 +1,27 @@
+import * as React from "react";
+interface StepperProps extends React.HTMLAttributes<HTMLDivElement> {
+    defaultValue?: number;
+    value?: number;
+    onValueChange?: (value: number) => void;
+    orientation?: "horizontal" | "vertical";
+}
+declare function Stepper({ defaultValue, value, onValueChange, orientation, className, ...props }: StepperProps): import("react/jsx-runtime").JSX.Element;
+interface StepperItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    step: number;
+    completed?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+}
+declare function StepperItem({ step, completed, disabled, loading, className, children, ...props }: StepperItemProps): import("react/jsx-runtime").JSX.Element;
+interface StepperTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare function StepperTrigger({ asChild, className, children, ...props }: StepperTriggerProps): import("react/jsx-runtime").JSX.Element;
+interface StepperIndicatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    asChild?: boolean;
+}
+declare function StepperIndicator({ asChild, className, children, ...props }: StepperIndicatorProps): import("react/jsx-runtime").JSX.Element;
+declare function StepperTitle({ className, ...props }: React.HTMLAttributes<HTMLHeadingElement>): import("react/jsx-runtime").JSX.Element;
+declare function StepperDescription({ className, ...props }: React.HTMLAttributes<HTMLParagraphElement>): import("react/jsx-runtime").JSX.Element;
+declare function StepperSeparator({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+export { Stepper, StepperDescription, StepperIndicator, StepperItem, StepperSeparator, StepperTitle, StepperTrigger, };

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

@@ -0,0 +1,6 @@
+import { Switch as SwitchPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function Switch({ className, size, ...props }: React.ComponentProps<typeof SwitchPrimitive.Root> & {
+    size?: "sm" | "default";
+}): import("react/jsx-runtime").JSX.Element;
+export { Switch };

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

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare function Table({ className, ...props }: React.ComponentProps<"table">): import("react/jsx-runtime").JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<"thead">): import("react/jsx-runtime").JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<"tbody">): import("react/jsx-runtime").JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">): import("react/jsx-runtime").JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<"tr">): import("react/jsx-runtime").JSX.Element;
+declare function TableHead({ className, ...props }: React.ComponentProps<"th">): import("react/jsx-runtime").JSX.Element;
+declare function TableCell({ className, ...props }: React.ComponentProps<"td">): import("react/jsx-runtime").JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<"caption">): import("react/jsx-runtime").JSX.Element;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

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

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import { Tabs as TabsPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function Tabs({ className, orientation, ...props }: React.ComponentProps<typeof TabsPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare const tabsListVariants: (props?: ({
+    variant?: "default" | "line" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function TabsList({ className, variant, ...props }: React.ComponentProps<typeof TabsPrimitive.List> & VariantProps<typeof tabsListVariants>): import("react/jsx-runtime").JSX.Element;
+declare function TabsTrigger({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };

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

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Textarea({ className, ...props }: React.ComponentProps<"textarea">): import("react/jsx-runtime").JSX.Element;
+export { Textarea };

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

@@ -0,0 +1,25 @@
+import * as React from "react";
+interface TimelineProps extends React.HTMLAttributes<HTMLDivElement> {
+    defaultValue?: number;
+    value?: number;
+    onValueChange?: (value: number) => void;
+    orientation?: "horizontal" | "vertical";
+}
+declare function Timeline({ defaultValue, value, onValueChange, orientation, className, ...props }: TimelineProps): import("react/jsx-runtime").JSX.Element;
+declare function TimelineContent({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+interface TimelineDateProps extends React.HTMLAttributes<HTMLTimeElement> {
+    asChild?: boolean;
+}
+declare function TimelineDate({ asChild, className, ...props }: TimelineDateProps): import("react/jsx-runtime").JSX.Element;
+declare function TimelineHeader({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+interface TimelineIndicatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    asChild?: boolean;
+}
+declare function TimelineIndicator({ className, children, ...props }: TimelineIndicatorProps): import("react/jsx-runtime").JSX.Element;
+interface TimelineItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    step: number;
+}
+declare function TimelineItem({ step, className, ...props }: TimelineItemProps): import("react/jsx-runtime").JSX.Element;
+declare function TimelineSeparator({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+declare function TimelineTitle({ className, ...props }: React.HTMLAttributes<HTMLHeadingElement>): import("react/jsx-runtime").JSX.Element;
+export { Timeline, TimelineContent, TimelineDate, TimelineHeader, TimelineIndicator, TimelineItem, TimelineSeparator, TimelineTitle, };

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

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import { ToggleGroup as ToggleGroupPrimitive } from 'radix-ui';
+import { toggleVariants } from './toggle';
+import * as React from "react";
+declare function ToggleGroup({ className, variant, size, spacing, orientation, children, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants> & {
+    spacing?: number;
+    orientation?: "horizontal" | "vertical";
+}): import("react/jsx-runtime").JSX.Element;
+declare function ToggleGroupItem({ className, children, variant, size, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+export { ToggleGroup, ToggleGroupItem };

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

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import { Toggle as TogglePrimitive } from 'radix-ui';
+import * as React from "react";
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Toggle({ className, variant, size, ...props }: React.ComponentProps<typeof TogglePrimitive.Root> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+export { Toggle, toggleVariants };

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

@@ -0,0 +1,7 @@
+import { Tooltip as TooltipPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+export { cn } from './lib/utils';
+export * from './components/custom/actions-menu';
+export * from './components/custom/advanced-input';
+export * from './components/custom/advanced-select';
+export * from './components/custom/data-table';
+export * from './components/custom/date-time-range-picker';
+export { presetToRange, navigateRange, } from './components/custom/date-time-range-picker-utils';
+export * from './components/ui/alert';
+export * from './components/ui/alert-dialog';
+export * from './components/ui/badge';
+export * from './components/ui/button';
+export * from './components/ui/button-group';
+export * from './components/ui/calendar';
+export * from './components/ui/card';
+export * from './components/ui/chart';
+export * from './components/ui/checkbox';
+export * from './components/ui/command';
+export * from './components/ui/dialog';
+export * from './components/ui/dropdown-menu';
+export * from './components/ui/field';
+export * from './components/ui/hover-card';
+export * from './components/ui/input';
+export * from './components/ui/input-group';
+export * from './components/ui/item';
+export * from './components/ui/label';
+export * from './components/ui/map';
+export * from './components/ui/popover';
+export * from './components/ui/progress';
+export * from './components/ui/radio-group';
+export * from './components/ui/select';
+export * from './components/ui/separator';
+export * from './components/ui/sheet';
+export * from './components/ui/slider';
+export * from './components/ui/sonner';
+export * from './components/ui/spinner';
+export * from './components/ui/stepper';
+export * from './components/ui/switch';
+export * from './components/ui/table';
+export * from './components/ui/tabs';
+export * from './components/ui/textarea';
+export * from './components/ui/timeline';
+export * from './components/ui/toggle';
+export * from './components/ui/toggle-group';
+export * from './components/ui/tooltip';