@selectwin/kit 0.1.2

package/dist/SelectSwitch.d.ts

@@ -0,0 +1,13 @@
+import { ComponentPropsWithoutRef } from 'react';
+/** SelectSwitch — an on/off toggle (the dashboard's primary control for enabling
+ *  features). On = brand fill + knob right. Accessible button[role=switch]. */
+type SelectSwitchOwnProps = {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    disabled?: boolean;
+    /** Accessible name when there's no visible label nearby. */
+    label?: string;
+};
+export type SelectSwitchProps = SelectSwitchOwnProps & Omit<ComponentPropsWithoutRef<'button'>, keyof SelectSwitchOwnProps>;
+export declare const SelectSwitch: import('react').ForwardRefExoticComponent<SelectSwitchOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, keyof SelectSwitchOwnProps> & import('react').RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/SelectSwitchField.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+export interface SelectSwitchFieldProps {
+    label: string;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    disabled?: boolean;
+    hint?: ReactNode;
+}
+export declare const SelectSwitchField: import('react').ForwardRefExoticComponent<SelectSwitchFieldProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectSwitchFieldProps> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/SelectTable.d.ts

@@ -0,0 +1,56 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+export interface SelectColumn {
+    label: ReactNode;
+    align?: 'start' | 'end' | 'center';
+    width?: string;
+    /** Render the header as a sort control with a caret. */
+    sortable?: boolean;
+    sortDir?: 'asc' | 'desc' | null;
+    onSort?: () => void;
+}
+type SelectTableOwnProps = {
+    columns: SelectColumn[];
+    children?: ReactNode;
+    empty?: ReactNode;
+    /** Borderless footer row below the rows box (e.g. "Updated · View all"). */
+    footer?: ReactNode;
+    /** Card title in the table's own header bar (e.g. "Variantes"). Renders the table as
+     *  a self-contained titled card — do NOT wrap it in a SelectSection (card-in-card). */
+    title?: ReactNode;
+    /** Right-aligned action in the header bar (e.g. an "Adicionar" button). */
+    action?: ReactNode;
+};
+export type SelectTableProps = SelectTableOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectTableOwnProps>;
+export declare const SelectTable: import('react').ForwardRefExoticComponent<SelectTableOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectTableOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+/** SelectUserCell — the recurring "avatar + name + secondary line" identity cell used
+ *  across user/sign-up tables. */
+type SelectUserCellOwnProps = {
+    name: ReactNode;
+    secondary?: ReactNode;
+    src?: string;
+};
+export type SelectUserCellProps = SelectUserCellOwnProps & Omit<ComponentPropsWithoutRef<'span'>, keyof SelectUserCellOwnProps>;
+export declare const SelectUserCell: import('react').ForwardRefExoticComponent<SelectUserCellOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref">, keyof SelectUserCellOwnProps> & import('react').RefAttributes<HTMLSpanElement>>;
+export declare function SelectTableRow({ children, onClick }: {
+    children: ReactNode;
+    onClick?: () => void;
+}): import("react").JSX.Element;
+type SelectTableCellOwnProps = {
+    children: ReactNode;
+    align?: 'start' | 'end' | 'center';
+    /** Accepted for API compatibility; column widths now come from the shared grid track set
+     *  (set on .select-table from the `columns`), so a per-cell width is no longer applied. */
+    width?: string;
+};
+export type SelectTableCellProps = SelectTableCellOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectTableCellOwnProps>;
+export declare const SelectTableCell: import('react').ForwardRefExoticComponent<SelectTableCellOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectTableCellOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+type SelectTableEmptyOwnProps = {
+    icon?: ReactNode;
+    title: ReactNode;
+    subtitle?: ReactNode;
+    /** Optional CTA below the text (e.g. "Enable Billing") — for standalone empty cards. */
+    action?: ReactNode;
+};
+export type SelectTableEmptyProps = SelectTableEmptyOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectTableEmptyOwnProps>;
+export declare const SelectTableEmpty: import('react').ForwardRefExoticComponent<SelectTableEmptyOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectTableEmptyOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectTabs.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+export interface SelectTab {
+    id: string;
+    label: ReactNode;
+    /** Status dot tone shown before the label. */
+    dot?: 'success' | 'neutral' | 'warning';
+}
+type SelectTabsOwnProps = {
+    tabs: SelectTab[];
+    value: string;
+    onChange: (id: string) => void;
+};
+export type SelectTabsProps = SelectTabsOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectTabsOwnProps>;
+export declare function SelectTabs({ tabs, value, onChange, className, ...rest }: SelectTabsProps): import("react").JSX.Element;
+export {};

package/dist/SelectTagSelect.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+export interface SelectTagOption {
+    value: string;
+    label: string;
+    secondary?: string;
+}
+type SelectTagSelectOwnProps = {
+    label?: ReactNode;
+    options: SelectTagOption[];
+    selected: string[];
+    onChange: (next: string[]) => void;
+    placeholder?: string;
+    hint?: ReactNode;
+    /** Validation message below the control; also flips the control to its error style. */
+    error?: string;
+    /** Fires when focus leaves the control (closes the popover) — for validate-on-blur. */
+    onBlur?: () => void;
+    /** Control density. Default `md`; use `sm` in dense surfaces and modal/card forms. */
+    size?: 'sm' | 'md';
+};
+export type SelectTagSelectProps = SelectTagSelectOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectTagSelectOwnProps>;
+export declare const SelectTagSelect: import('react').ForwardRefExoticComponent<SelectTagSelectOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectTagSelectOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectText.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode, HTMLAttributes } from 'react';
+export type SelectTextVariant = 'heading3xl' | 'heading2xl' | 'headingXl' | 'headingLg' | 'headingMd' | 'headingSm' | 'headingXs' | 'bodyLg' | 'bodyMd' | 'bodySm' | 'bodyXs';
+export type SelectTextTone = 'base' | 'subdued' | 'success' | 'critical' | 'caution' | 'disabled';
+export type SelectFontWeight = 'regular' | 'medium' | 'semibold' | 'bold';
+/** Elements SelectText may render as (a subset of Polaris `as`). */
+type SelectTextEl = 'p' | 'span' | 'div' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'label' | 'legend' | 'dt' | 'dd' | 'strong' | 'em';
+type SelectTextOwnProps = {
+    children: ReactNode;
+    as?: SelectTextEl;
+    variant?: SelectTextVariant;
+    tone?: SelectTextTone;
+    fontWeight?: SelectFontWeight;
+    alignment?: 'start' | 'center' | 'end' | 'justify';
+    /** Truncate to a single line with an ellipsis. */
+    truncate?: boolean;
+    /** Tabular figures (align numbers in tables/amounts). */
+    numeric?: boolean;
+    className?: string;
+};
+export type SelectTextProps = SelectTextOwnProps & Omit<HTMLAttributes<HTMLElement>, keyof SelectTextOwnProps>;
+export declare function SelectText({ children, as, variant, tone, fontWeight, alignment, truncate, numeric, className, ...rest }: SelectTextProps): import("react").JSX.Element;
+export {};

package/dist/SelectTextarea.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+type SelectTextareaOwnProps = {
+    label?: string;
+    value: string;
+    onChange: (value: string) => void;
+    labelAction?: ReactNode;
+    info?: string;
+    /** Helper text shown under the label, above the textarea (Clerk pattern). */
+    description?: ReactNode;
+    hint?: string;
+    error?: string;
+    placeholder?: string;
+    rows?: number;
+    /** Monospace the content (scripts, JSON, codes). */
+    mono?: boolean;
+    name?: string;
+    required?: boolean;
+    disabled?: boolean;
+    maxLength?: number;
+    onBlur?: () => void;
+    /** Control density. Default `md`; use `sm` in dense surfaces and modal/card forms. */
+    size?: 'sm' | 'md';
+};
+export type SelectTextareaProps = SelectTextareaOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectTextareaOwnProps>;
+export declare const SelectTextarea: import('react').ForwardRefExoticComponent<SelectTextareaOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectTextareaOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectThemeSwitcher.d.ts

@@ -0,0 +1,11 @@
+import { ComponentPropsWithoutRef } from 'react';
+export type SelectTheme = 'light' | 'dark' | 'system';
+/** Resolve a theme choice to the concrete 'light' | 'dark' to apply as data-theme. */
+export declare function resolveSelectTheme(theme: SelectTheme): 'light' | 'dark';
+type SelectThemeSwitcherOwnProps = {
+    value: SelectTheme;
+    onChange: (value: SelectTheme) => void;
+};
+export type SelectThemeSwitcherProps = SelectThemeSwitcherOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectThemeSwitcherOwnProps>;
+export declare function SelectThemeSwitcher({ value, onChange, className, ...rest }: SelectThemeSwitcherProps): import("react").JSX.Element;
+export {};

package/dist/SelectThumbnail.d.ts

@@ -0,0 +1,9 @@
+import { ComponentPropsWithoutRef } from 'react';
+type SelectThumbnailOwnProps = {
+    src?: string;
+    alt?: string;
+    size?: number;
+};
+export type SelectThumbnailProps = SelectThumbnailOwnProps & Omit<ComponentPropsWithoutRef<'span'>, keyof SelectThumbnailOwnProps>;
+export declare const SelectThumbnail: import('react').ForwardRefExoticComponent<SelectThumbnailOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref">, keyof SelectThumbnailOwnProps> & import('react').RefAttributes<HTMLSpanElement>>;
+export {};

package/dist/SelectTicker.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+type SelectTickerOwnProps = {
+    children: ReactNode;
+    /** Slide speed in px/second (only applies when the content overflows). Default 28. */
+    speed?: number;
+};
+export type SelectTickerProps = SelectTickerOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectTickerOwnProps>;
+export declare function SelectTicker({ children, speed, className, ...rest }: SelectTickerProps): import("react").JSX.Element;
+export {};

package/dist/SelectTile.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+type SelectAppTileOwnProps = {
+    media?: ReactNode;
+    sublabel?: ReactNode;
+    title: ReactNode;
+    badge?: ReactNode;
+    meta?: ReactNode;
+    /** Show the colored top strip. */
+    accent?: boolean;
+    onClick?: () => void;
+};
+export type SelectAppTileProps = SelectAppTileOwnProps & Omit<ComponentPropsWithoutRef<'button'>, keyof SelectAppTileOwnProps>;
+export declare const SelectAppTile: import('react').ForwardRefExoticComponent<SelectAppTileOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, keyof SelectAppTileOwnProps> & import('react').RefAttributes<HTMLButtonElement>>;
+type SelectCreateTileOwnProps = {
+    label: ReactNode;
+    onClick?: () => void;
+};
+export type SelectCreateTileProps = SelectCreateTileOwnProps & Omit<ComponentPropsWithoutRef<'button'>, keyof SelectCreateTileOwnProps>;
+export declare const SelectCreateTile: import('react').ForwardRefExoticComponent<SelectCreateTileOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, keyof SelectCreateTileOwnProps> & import('react').RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/SelectTimeline.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+export type SelectTimelineTone = 'default' | 'success' | 'critical' | 'warning' | 'info';
+export interface SelectTimelineItem {
+    title: ReactNode;
+    timestamp?: ReactNode;
+    description?: ReactNode;
+    content?: ReactNode;
+    tone?: SelectTimelineTone;
+}
+type SelectTimelineOwnProps = {
+    items: SelectTimelineItem[];
+};
+export type SelectTimelineProps = SelectTimelineOwnProps & Omit<ComponentPropsWithoutRef<'ul'>, keyof SelectTimelineOwnProps>;
+export declare const SelectTimeline: import('react').ForwardRefExoticComponent<SelectTimelineOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref">, "items"> & import('react').RefAttributes<HTMLUListElement>>;
+export {};

package/dist/SelectToast.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+export type SelectToastVariant = 'success' | 'error' | 'info' | 'neutral';
+export interface SelectToastApi {
+    show: (content: ReactNode, opts?: {
+        variant?: SelectToastVariant;
+        duration?: number;
+    }) => void;
+    success: (content: ReactNode, duration?: number) => void;
+    error: (content: ReactNode, duration?: number) => void;
+    info: (content: ReactNode, duration?: number) => void;
+}
+export declare function SelectToastProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useSelectToast(): SelectToastApi;

package/dist/SelectToggle.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+type SelectToggleListOwnProps = {
+    children: ReactNode;
+    scroll?: boolean;
+};
+export type SelectToggleListProps = SelectToggleListOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectToggleListOwnProps>;
+export declare const SelectToggleList: import('react').ForwardRefExoticComponent<SelectToggleListOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectToggleListOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+type SelectToggleRowOwnProps = {
+    icon?: ReactNode;
+    label: ReactNode;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    disabled?: boolean;
+};
+export type SelectToggleRowProps = SelectToggleRowOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectToggleRowOwnProps>;
+export declare const SelectToggleRow: import('react').ForwardRefExoticComponent<SelectToggleRowOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectToggleRowOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectTogglePanel.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+type SelectTogglePanelOwnProps = {
+    icon?: ReactNode;
+    title: ReactNode;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    /** Body shown when enabled. */
+    children?: ReactNode;
+    disabled?: boolean;
+};
+export type SelectTogglePanelProps = SelectTogglePanelOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectTogglePanelOwnProps>;
+export declare const SelectTogglePanel: import('react').ForwardRefExoticComponent<SelectTogglePanelOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectTogglePanelOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectTooltip.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+import { SelectPlacement } from './positioning';
+export declare function SelectTooltip({ content, children, placement, delay, }: {
+    content: ReactNode;
+    children: ReactNode;
+    placement?: SelectPlacement;
+    delay?: number;
+}): import("react").JSX.Element;

package/dist/SelectTree.d.ts

@@ -0,0 +1,13 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectTreeNode {
+    label: string;
+    color?: string;
+    children?: SelectTreeNode[];
+}
+type SelectTreeOwnProps = {
+    data: SelectTreeNode;
+    height?: number;
+};
+export type SelectTreeProps = SelectTreeOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectTreeOwnProps>;
+export declare function SelectTree({ data, height, className, ...rest }: SelectTreeProps): import("react").JSX.Element;
+export {};

package/dist/SelectTreemap.d.ts

@@ -0,0 +1,14 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectTreemapDatum {
+    label: string;
+    value: number;
+    color?: string;
+}
+type SelectTreemapOwnProps = {
+    data: SelectTreemapDatum[];
+    height?: number;
+    format?: (n: number) => string;
+};
+export type SelectTreemapProps = SelectTreemapOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectTreemapOwnProps>;
+export declare function SelectTreemap({ data, height, format, className, ...rest }: SelectTreemapProps): import("react").JSX.Element;
+export {};

package/dist/SelectUnitInput.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+type SelectUnitInputOwnProps = {
+    label?: string;
+    value: string;
+    onChange: (value: string) => void;
+    unit: ReactNode;
+    info?: string;
+    hint?: string;
+    error?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    min?: number;
+    max?: number;
+};
+export type SelectUnitInputProps = SelectUnitInputOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectUnitInputOwnProps>;
+export declare const SelectUnitInput: import('react').ForwardRefExoticComponent<SelectUnitInputOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectUnitInputOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectVenn.d.ts

@@ -0,0 +1,13 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectVennSet {
+    label: string;
+    size: number;
+    color?: string;
+}
+type SelectVennOwnProps = {
+    sets: SelectVennSet[];
+    size?: number;
+};
+export type SelectVennProps = SelectVennOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectVennOwnProps>;
+export declare const SelectVenn: import('react').ForwardRefExoticComponent<SelectVennOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectVennOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectViolin.d.ts

@@ -0,0 +1,18 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectViolinDatum {
+    label: string;
+    /** Density samples low→high (e.g. a histogram/KDE). */
+    bins: number[];
+    min: number;
+    max: number;
+    median?: number;
+    color?: string;
+}
+type SelectViolinOwnProps = {
+    data: SelectViolinDatum[];
+    height?: number;
+    format?: (n: number) => string;
+};
+export type SelectViolinProps = SelectViolinOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectViolinOwnProps>;
+export declare function SelectViolin({ data, height, format, className, ...rest }: SelectViolinProps): import("react").JSX.Element;
+export {};

package/dist/SelectWaffle.d.ts

@@ -0,0 +1,11 @@
+import { ComponentPropsWithoutRef } from 'react';
+import { SelectDonutSegment } from './chartUtils';
+type SelectWaffleOwnProps = {
+    segments: SelectDonutSegment[];
+    cols?: number;
+    rows?: number;
+    format?: (n: number) => string;
+};
+export type SelectWaffleProps = SelectWaffleOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectWaffleOwnProps>;
+export declare const SelectWaffle: import('react').ForwardRefExoticComponent<SelectWaffleOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectWaffleOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectWaterfall.d.ts

@@ -0,0 +1,16 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectWaterfallStep {
+    label: string;
+    /** Delta for a step, or the absolute amount when `total` is set. */
+    value: number;
+    /** Absolute bar from zero (e.g. an opening/closing total). */
+    total?: boolean;
+}
+type SelectWaterfallOwnProps = {
+    data: SelectWaterfallStep[];
+    height?: number;
+    format?: (n: number) => string;
+};
+export type SelectWaterfallProps = SelectWaterfallOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectWaterfallOwnProps>;
+export declare function SelectWaterfall({ data, height, format, className, ...rest }: SelectWaterfallProps): import("react").JSX.Element;
+export {};

package/dist/SelectWordCloud.d.ts

@@ -0,0 +1,14 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectWord {
+    text: string;
+    value: number;
+    color?: string;
+}
+type SelectWordCloudOwnProps = {
+    words: SelectWord[];
+    minSize?: number;
+    maxSize?: number;
+};
+export type SelectWordCloudProps = SelectWordCloudOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectWordCloudOwnProps>;
+export declare const SelectWordCloud: import('react').ForwardRefExoticComponent<SelectWordCloudOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectWordCloudOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectWorkspaceSwitcher.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+type SelectWorkspaceSwitcherOwnProps = {
+    avatar?: ReactNode;
+    name: ReactNode;
+    badge?: ReactNode;
+    onClick?: () => void;
+};
+export type SelectWorkspaceSwitcherProps = SelectWorkspaceSwitcherOwnProps & Omit<ComponentPropsWithoutRef<'button'>, keyof SelectWorkspaceSwitcherOwnProps>;
+export declare const SelectWorkspaceSwitcher: import('react').ForwardRefExoticComponent<SelectWorkspaceSwitcherOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, keyof SelectWorkspaceSwitcherOwnProps> & import('react').RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/SelectZoomThumbnail.d.ts

@@ -0,0 +1,7 @@
+export declare function SelectZoomThumbnail({ src, alt, size, title, }: {
+    src?: string;
+    alt?: string;
+    size?: number;
+    /** Heading on the zoom modal (defaults to `alt`). */
+    title?: string;
+}): import("react").JSX.Element;

package/dist/chartTip.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+export interface ChartTipRow {
+    label: ReactNode;
+    value: ReactNode;
+    color?: string;
+}
+export interface ChartTipState {
+    x: number;
+    y: number;
+    title?: ReactNode;
+    rows: ChartTipRow[];
+    /** Where the tip sits relative to (x,y). 'top' (default) floats it above the point;
+     *  'bottom' drops it below — use it near the top edge so it never clips the header. */
+    place?: 'top' | 'bottom';
+}
+export declare function useChartTooltip(): {
+    tip: ChartTipState | null;
+    show: (t: ChartTipState) => void;
+    hide: () => void;
+};
+type ChartTooltipOwnProps = {
+    tip: ChartTipState | null;
+};
+export type ChartTooltipProps = ChartTooltipOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof ChartTooltipOwnProps>;
+export declare function ChartTooltip({ tip, className, ...rest }: ChartTooltipProps): import("react").JSX.Element | null;
+export {};

package/dist/chartUtils.d.ts

@@ -0,0 +1,76 @@
+/** Measure the container width so the chart is responsive. Height is caller-fixed but scaled
+ *  by the fluid root (useRootScale) so chart height grows with the rest of the UI. */
+export declare function useChartSize(height: number): {
+    ref: import('react').RefObject<HTMLDivElement>;
+    width: number;
+    height: number;
+};
+/** Live pixel width of a ref'd element, for viewBox SVGs whose box is sized in rem (so it
+ *  scales with the fluid root): feeding the measured px back into the geometry keeps the
+ *  viewBox 1:1 with the rendered px, so px-positioned HTML overlays (tooltips) stay aligned.
+ *  `basePx` is the first-paint fallback before the observer fires. */
+export declare function useMeasuredWidth(ref: {
+    readonly current: HTMLElement | null;
+}, basePx: number): number;
+/** Round a max up to a "nice" axis value (1/2/5 × 10^n). */
+export declare function niceMax(value: number): number;
+/** count+1 evenly spaced tick values from 0..max. */
+export declare function ticks(max: number, count?: number): number[];
+/**
+ * d3-style "nice" ticks: pick a round STEP (1/2/5 × 10ⁿ) near max/target, then emit ticks
+ * from 0 up to the smallest multiple of that step ≥ the data. This gives clean axis labels
+ * (0, 1, 2 … not 1,3 / 2,5 / 3,8) AND a domain that hugs the data instead of overshooting
+ * to a round max÷4. Returns the rounded max + the tick values.
+ */
+export declare function niceTicks(maxData: number, target?: number): {
+    max: number;
+    values: number[];
+};
+export declare function linePath(pts: Array<[number, number]>): string;
+export declare function areaPath(pts: Array<[number, number]>, baseY: number): string;
+/**
+ * Monotone cubic interpolation (à la d3 curveMonotoneX): smooth curves that never
+ * overshoot the data — no phantom dips below zero between points. Assumes x increasing.
+ * This is what makes the lines read as a polished analytics chart instead of a polyline.
+ */
+export declare function smoothLinePath(pts: Array<[number, number]>): string;
+export declare function smoothAreaPath(pts: Array<[number, number]>, baseY: number): string;
+/**
+ * Smooth filled band between an upper and a lower boundary (true stacked-area bands, so
+ * each band is its own shape and can carry its own gradient without bleeding onto the
+ * one below). Both arrays share the same x positions, left→right.
+ */
+export declare function smoothBandPath(upper: Array<[number, number]>, lower: Array<[number, number]>): string;
+/** Donut/pie segment path (outer arc out, inner arc back). Angles in degrees, 0 = top. */
+export declare function donutSegment(cx: number, cy: number, rOut: number, rIn: number, startDeg: number, endDeg: number): string;
+export declare function chartColor(i: number): string;
+/** Compact number for axis labels (1.2k, 3.4M). */
+export declare function formatCompact(n: number): string;
+/** Standard plot insets — room for Y labels (left) and X labels (bottom), plus a small
+ *  top/right margin so lines/areas and the first/last X labels never touch the edges. */
+export declare const CHART_PAD: {
+    readonly top: 16;
+    readonly right: 22;
+    readonly bottom: 32;
+    readonly left: 48;
+};
+export interface SelectChartSeries {
+    name: string;
+    data: number[];
+    color?: string;
+}
+export interface SelectBarDatum {
+    label: string;
+    value: number;
+    /** Optional per-row bar colour (else the chart ramp / single `color`). */
+    color?: string;
+}
+export interface SelectDonutSegment {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface SelectFunnelStage {
+    label: string;
+    value: number;
+}

package/dist/detectSelectTheme.d.ts

@@ -0,0 +1,8 @@
+/**
+ * detectSelectTheme — best-effort current Select theme for PORTALED components (modals,
+ * popovers, tooltips), which render outside the app's `.select`/data-theme subtree. Reads
+ * the nearest `[data-theme]` ancestor of `anchor` (the trigger), or falls back to
+ * `<html data-theme>` (set by ThemeProvider). Lets those components theme themselves
+ * without every caller passing a `theme` prop.
+ */
+export declare function detectSelectTheme(anchor?: Element | null): 'light' | 'dark';