@selectwin/kit 0.1.2

package/dist/SelectDataTable.d.ts

@@ -0,0 +1,100 @@
+import { ReactNode } from 'react';
+/**
+ * Grid-track width for a date/time column — a FIXED width that fits a full pt-BR
+ * "dd/mm/aaaa, hh:mm" without clipping (the problem a bare `1fr` column had: it shared the
+ * slack equally with narrow status/badge columns and truncated the datetime).
+ *
+ * It MUST be a fixed length, NOT `max-content`/`min-content`/`auto`: the header and EACH row
+ * are SEPARATE grid containers (not one shared grid / subgrid), so a content-based track
+ * resolves independently per grid — the header sizes to the label ("Criação") while the rows
+ * size to the datetime — and the columns drift out of alignment. A fixed rem resolves to the
+ * same width in every grid, so head and cells stay locked. Pass as the `width` of any column
+ * that renders `formatDateTime`.
+ */
+export declare const SELECT_COL_DATETIME = "9.5rem";
+export interface SelectDataColumn<T> {
+    key: string;
+    title: ReactNode;
+    render: (item: T) => ReactNode;
+    align?: 'start' | 'end' | 'center';
+    width?: string;
+    /**
+     * Comparison value for client-side sorting — its presence makes the column sortable.
+     * Sorts only the LOADED page (the server page/order is the baseline; clearing the sort
+     * restores it). Return a number for money/quantity (coerce backend string amounts first)
+     * and an ISO string or epoch for dates; strings compare with pt-BR collation
+     * (numeric-aware, accent-insensitive). null/undefined/'' always sink to the end.
+     */
+    sortValue?: (item: T) => string | number | null | undefined;
+    /** Direction of the FIRST click on this column (default 'asc'; use 'desc' for dates/money
+     *  so the first click answers "newest/biggest first"). */
+    sortDefault?: 'asc' | 'desc';
+    /** Whether the column can be hidden from the `columnsKey` picker. Defaults to "has a
+     *  title" — untitled columns (actions) are never listed nor hideable. */
+    hideable?: boolean;
+}
+/**
+ * Page size the user picked for a given table (pair with `pagination.pageSizeOptions`/
+ * `onPageSizeChange`), persisted per table under the same key `columnsKey` uses. A stored
+ * value outside `options` (stale after a menu change) falls back to `fallback`. Storage
+ * guards mirror SelectMoney — storage unavailable = in-memory only.
+ */
+export declare function useSelectPageSize(key: string, fallback: number, options?: number[]): [number, (size: number) => void];
+export declare function SelectDataTable<T>({ columns, items, getId, loading, empty, pagination, onRowClick, title, action, columnsKey, }: {
+    columns: SelectDataColumn<T>[];
+    items: T[];
+    getId: (item: T) => string;
+    loading?: boolean;
+    empty?: {
+        icon?: ReactNode;
+        heading: ReactNode;
+        text?: ReactNode;
+        action?: ReactNode;
+    };
+    /**
+     * Footer pager. The cursor fields (hasPrevious/onPrevious/hasNext/onNext) are enough for a
+     * basic centered prev/next pager. Provide `total` + `pageSize` + `page` to show the count
+     * label, and additionally `onPage` (+ optional `pageCount`) to render numbered page buttons.
+     */
+    pagination?: {
+        hasPrevious: boolean;
+        onPrevious: () => void;
+        hasNext: boolean;
+        onNext: () => void;
+        /** Total item count across all pages (drives the "de N" label). */
+        total?: number;
+        /** Items per page — with `total` + `page` yields the "X–Y de N" range label. */
+        pageSize?: number;
+        /** Current page, 1-based. */
+        page?: number;
+        /** Total pages — enables numbered buttons when paired with `onPage`. */
+        pageCount?: number;
+        /** Jump to a 1-based page (enables numbered buttons). */
+        onPage?: (page: number) => void;
+        /** Noun for the count label, e.g. "produtos" (defaults to "resultados"). */
+        noun?: string;
+        /**
+         * Page-size menu ("N por página", bottom-left of the footer) — the user picks how many
+         * rows per page. Cap the options at 50% of the backend's zod max for the endpoint
+         * (e.g. max 100 → [10, 25, 50]). Requires `onPageSizeChange`; pair the state with
+         * `useSelectPageSize` so the choice persists per table.
+         */
+        pageSizeOptions?: number[];
+        /** Apply a new page size (also reset the offset to the first page in the caller). */
+        onPageSizeChange?: (size: number) => void;
+    };
+    onRowClick?: (item: T) => void;
+    /** Card title in the table's own header bar — renders a self-contained titled card
+     *  (don't wrap in SelectSection; the table is already a card). */
+    title?: ReactNode;
+    /** Right-aligned header action (e.g. an "Adicionar" button). */
+    action?: ReactNode;
+    /**
+     * Enables the column-visibility picker (a gear in the header bar) and persists the
+     * hidden set in localStorage under this key — use a stable per-table slug (e.g.
+     * "checkout-sessions"). Columns are hideable by default when they have a `title`
+     * (opt out per column with `hideable: false`); at least one hideable column always
+     * stays visible.
+     */
+    columnsKey?: string;
+}): import("react").JSX.Element;

package/dist/SelectDateField.d.ts

@@ -0,0 +1,19 @@
+export interface SelectDateFieldProps {
+    label?: string;
+    value: string;
+    onChange: (value: string) => void;
+    /** Include a time picker and emit "YYYY-MM-DDTHH:mm" (default: date only). */
+    showTime?: boolean;
+    placeholder?: string;
+    required?: boolean;
+    disabled?: boolean;
+    error?: string;
+    hint?: string;
+    /** Earliest / latest selectable day (inclusive); days outside are blocked. */
+    minDate?: Date | null;
+    maxDate?: Date | null;
+    /** Offer a "Limpar" action that empties the field (default true). */
+    clearable?: boolean;
+    id?: string;
+}
+export declare const SelectDateField: import('react').ForwardRefExoticComponent<SelectDateFieldProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectDateFieldProps> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/SelectDatePicker.d.ts

@@ -0,0 +1,34 @@
+export interface SelectDateRange {
+    from: Date | null;
+    to: Date | null;
+}
+export interface SelectDatePreset {
+    id: string;
+    label: string;
+    disabled?: boolean;
+    /** Computed at click time (so "now" is current). Omit for a non-selectable label. */
+    range?: () => SelectDateRange;
+}
+export type SelectDateLocale = 'en-US' | 'pt-BR';
+export interface SelectDatePickerProps {
+    /** Initial range (the picker is uncontrolled; Apply commits via onApply). */
+    value?: SelectDateRange;
+    presets?: SelectDatePreset[];
+    onApply?: (range: SelectDateRange) => void;
+    onCancel?: () => void;
+    /** CSS custom property name to drive the accent (default --select-accent). */
+    accentVar?: string;
+    /** Calendar/labels language + date order (default 'en-US'). */
+    locale?: SelectDateLocale;
+    /** Show the From/To time pills (default true). Off for daily ranges. */
+    showTime?: boolean;
+    /** Latest selectable day — days after it are greyed out and blocked. */
+    maxDate?: Date | null;
+    /** Drop the card chrome (surface/border/shadow) so it sits flush in a popover. */
+    embedded?: boolean;
+}
+/** Mirrors the reference: minute/hour/day windows ending "now", plus All. */
+export declare const SELECT_DATE_PRESETS: SelectDatePreset[];
+/** PT-BR daily presets for dashboards/analytics (today / last N days, no time). */
+export declare const SELECT_DAILY_PRESETS: SelectDatePreset[];
+export declare const SelectDatePicker: import('react').ForwardRefExoticComponent<SelectDatePickerProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectDatePickerProps> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/SelectDateRangeField.d.ts

@@ -0,0 +1,20 @@
+import { SelectPlacement } from './SelectPopover';
+import { SelectDatePreset } from './SelectDatePicker';
+export interface SelectDateRangeValue {
+    start: Date;
+    end: Date;
+}
+export interface SelectDateRangeFieldProps {
+    value: SelectDateRangeValue;
+    onChange: (range: SelectDateRangeValue) => void;
+    /** Quick presets in the rail (default: Hoje / 7 / 30 / 90 dias). */
+    presets?: SelectDatePreset[];
+    /** Latest selectable day. `null` allows future days; defaults to today. */
+    maxDate?: Date | null;
+    placement?: SelectPlacement;
+    size?: 'sm' | 'md';
+    disabled?: boolean;
+    /** Fill the available width (filter grids) instead of sizing to the range label. */
+    block?: boolean;
+}
+export declare function SelectDateRangeField({ value, onChange, presets, maxDate, placement, size, disabled, block, }: SelectDateRangeFieldProps): import("react").JSX.Element;

package/dist/SelectDetail.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+export declare function SelectDetailList({ children, stacked, loading, }: {
+    children: ReactNode;
+    stacked?: boolean;
+    /** Shimmer every row's value. The labels stay — only the values are unknown. */
+    loading?: boolean;
+}): import("react").JSX.Element;
+type SelectDetailRowOwnProps = {
+    label: ReactNode;
+    children: ReactNode;
+    /** Right-aligned action (e.g. an "Update" link). */
+    action?: ReactNode;
+    align?: 'center' | 'start';
+    /** Overrides the list's `loading` for this row alone. */
+    loading?: boolean;
+};
+export type SelectDetailRowProps = SelectDetailRowOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectDetailRowOwnProps>;
+export declare const SelectDetailRow: import('react').ForwardRefExoticComponent<SelectDetailRowOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectDetailRowOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectDisclosureButton.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+export declare function SelectDisclosureButton({ open, onToggle, children, openLabel, disabled, size, variant, }: {
+    open: boolean;
+    onToggle: () => void;
+    /** Label shown when CLOSED (e.g. "Mostrar"). */
+    children: ReactNode;
+    /** Label shown when OPEN (e.g. "Ocultar"). Falls back to `children`. */
+    openLabel?: ReactNode;
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'primary' | 'secondary' | 'danger';
+}): import("react").JSX.Element;

package/dist/SelectDivider.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+type SelectDividerOwnProps = {
+    children?: ReactNode;
+};
+export type SelectDividerProps = SelectDividerOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectDividerOwnProps>;
+export declare const SelectDivider: import('react').ForwardRefExoticComponent<SelectDividerOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectDocumentField.d.ts

@@ -0,0 +1,11 @@
+export declare function SelectDocumentField({ label, value, onChange, hint, error, onBlur, required, name, }: {
+    label?: string;
+    /** Clean digits (no mask). */
+    value: string;
+    onChange: (clean: string) => void;
+    hint?: string;
+    error?: string;
+    onBlur?: () => void;
+    required?: boolean;
+    name?: string;
+}): import("react").JSX.Element;

package/dist/SelectDonut.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+import { SelectDonutSegment } from './chartUtils';
+type SelectDonutOwnProps = {
+    segments: SelectDonutSegment[];
+    size?: number;
+    thickness?: number;
+    format?: (n: number) => string;
+    centerLabel?: ReactNode;
+    legend?: boolean;
+    /** Angular gap between slices, in degrees. */
+    gap?: number;
+    /** Render a full pie (no center hole) instead of a ring. */
+    pie?: boolean;
+};
+export type SelectDonutProps = SelectDonutOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectDonutOwnProps>;
+export declare const SelectDonut: import('react').ForwardRefExoticComponent<SelectDonutOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectDonutOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectDotField.d.ts

@@ -0,0 +1,5 @@
+export declare function SelectDotField({ className, theme, glowTarget }: {
+    className?: string;
+    theme?: 'light' | 'dark';
+    glowTarget?: string;
+}): import("react").JSX.Element;

package/dist/SelectDumbbell.d.ts

@@ -0,0 +1,17 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectDumbbellDatum {
+    label: string;
+    from: number;
+    to: number;
+}
+type SelectDumbbellOwnProps = {
+    data: SelectDumbbellDatum[];
+    height?: number;
+    format?: (n: number) => string;
+    fromLabel?: string;
+    toLabel?: string;
+    labelWidth?: number;
+};
+export type SelectDumbbellProps = SelectDumbbellOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectDumbbellOwnProps>;
+export declare function SelectDumbbell({ data, height, format, fromLabel, toLabel, labelWidth, className, ...rest }: SelectDumbbellProps): import("react").JSX.Element;
+export {};

package/dist/SelectFeeBreakdown.d.ts

@@ -0,0 +1,14 @@
+export interface SelectFeeLine {
+    label: string;
+    /** Deduction in CENTS (positive number = subtracted from gross). */
+    cents: number;
+}
+export interface SelectFeeBreakdownProps {
+    grossCents: number;
+    fees: SelectFeeLine[];
+    /** Net in CENTS. Defaults to gross − Σfees. */
+    netCents?: number;
+    grossLabel?: string;
+    netLabel?: string;
+}
+export declare const SelectFeeBreakdown: import('react').ForwardRefExoticComponent<SelectFeeBreakdownProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectFeeBreakdownProps> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/SelectField.d.ts

@@ -0,0 +1,66 @@
+import { KeyboardEvent, ReactNode, ComponentPropsWithoutRef } from 'react';
+/** Shared label row: label text, an optional ⓘ info affordance, and a right action. */
+type SelectLabelRowOwnProps = {
+    htmlFor: string;
+    label: ReactNode;
+    info?: string;
+    action?: ReactNode;
+};
+export type SelectLabelRowProps = SelectLabelRowOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectLabelRowOwnProps>;
+export declare const SelectLabelRow: import('react').ForwardRefExoticComponent<SelectLabelRowOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectLabelRowOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export interface SelectFieldProps {
+    /** Field label. Omit when an outer row already labels the field. */
+    label?: string;
+    value: string;
+    onChange: (value: string) => void;
+    type?: 'text' | 'email' | 'password' | 'url' | 'tel' | 'date' | 'datetime-local' | 'number';
+    /** Right-aligned action next to the label (e.g. a recovery link). */
+    labelAction?: ReactNode;
+    /** Small ⓘ affordance after the label, with this text as a tooltip. */
+    info?: string;
+    /** Helper text shown under the label, ABOVE the input (Clerk "Key" pattern). */
+    description?: ReactNode;
+    /** Helper text below the field (hidden when `error` is set). */
+    hint?: string;
+    /** Validation message below the field; also flips the input to its error style. */
+    error?: string;
+    /** Static text/icon inside the field, left of the value (e.g. "R$", "https://"). */
+    prefix?: ReactNode;
+    /** Static text/icon inside the field, right of the value (e.g. "%", "un."). */
+    suffix?: ReactNode;
+    /** Monospace the value (codes, keys, scripts). */
+    mono?: boolean;
+    autoComplete?: string;
+    placeholder?: string;
+    required?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    name?: string;
+    id?: string;
+    minLength?: number;
+    maxLength?: number;
+    /** Numeric bounds (type="number"). */
+    min?: number | string;
+    max?: number | string;
+    step?: number | string;
+    inputMode?: 'text' | 'email' | 'numeric' | 'tel' | 'url' | 'decimal';
+    autoFocus?: boolean;
+    onBlur?: () => void;
+    /** Key handler on the input (e.g. Enter-to-add in chip lists). */
+    onKeyDown?: (e: KeyboardEvent<HTMLInputElement>) => void;
+    /** Control density. Default `md`; use `sm` in dense surfaces (filters/toolbars/row
+     *  actions) and in modal/card forms. See the sizing policy in the /select showcase. */
+    size?: 'sm' | 'md';
+}
+export declare const SelectField: import('react').ForwardRefExoticComponent<SelectFieldProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectFieldProps> & import('react').RefAttributes<HTMLDivElement>>;
+type SelectCheckboxOwnProps = {
+    label: ReactNode;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    disabled?: boolean;
+    hint?: ReactNode;
+    name?: string;
+};
+export type SelectCheckboxProps = SelectCheckboxOwnProps & Omit<ComponentPropsWithoutRef<'span'>, keyof SelectCheckboxOwnProps>;
+export declare const SelectCheckbox: import('react').ForwardRefExoticComponent<SelectCheckboxOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref">, keyof SelectCheckboxOwnProps> & import('react').RefAttributes<HTMLSpanElement>>;
+export {};

package/dist/SelectFieldGrid.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+type SelectFieldGridOwnProps = {
+    children: ReactNode;
+    columns?: 2 | 3;
+};
+export type SelectFieldGridProps = SelectFieldGridOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectFieldGridOwnProps>;
+export declare const SelectFieldGrid: import('react').ForwardRefExoticComponent<SelectFieldGridOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectFieldGridOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectFileDropzone.d.ts

@@ -0,0 +1,13 @@
+export interface SelectFileDropzoneProps {
+    files: File[];
+    onChange: (files: File[]) => void;
+    /** Allowed extensions/MIME, e.g. '.pdf,.jpg,.jpeg,.png' or 'image/*,application/pdf'. */
+    accept?: string;
+    /** Per-file size cap in MB. Default 10. */
+    maxSizeMB?: number;
+    allowMultiple?: boolean;
+    /** Optional cap on the number of files; hides the add tile once reached. */
+    maxFiles?: number;
+    hint?: string;
+}
+export declare const SelectFileDropzone: import('react').ForwardRefExoticComponent<SelectFileDropzoneProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectFileDropzoneProps> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/SelectFileTile.d.ts

@@ -0,0 +1,15 @@
+export interface SelectFileTileProps {
+    /** Image URL (object URL for a File, or an https URL). Omit for a non-image doc tile. */
+    src?: string;
+    /** Extension shown on the doc tile when there's no image, e.g. "PDF". */
+    docExt?: string;
+    /** Primary label under the tile (filename or hostname). */
+    name: string;
+    /** Optional secondary line (e.g. file size). */
+    sub?: string;
+    /** Optional badge shown over the tile (e.g. "atual" for an existing image). */
+    badge?: string;
+    /** Remove handler; when omitted the tile is read-only (no remove button). */
+    onRemove?: () => void;
+}
+export declare const SelectFileTile: import('react').ForwardRefExoticComponent<SelectFileTileProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectFileTileProps> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/SelectFilterBar.d.ts

@@ -0,0 +1,28 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectFilterDef {
+    key: string;
+    label: string;
+    type: 'text' | 'select' | 'date';
+    placeholder?: string;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    pinned?: boolean;
+}
+type SelectFilterBarOwnProps = {
+    filters: SelectFilterDef[];
+    values: Record<string, string>;
+    onChange: (key: string, value: string) => void;
+    onClearAll: () => void;
+    /** Dedicated free-text query field (the Polaris query). Omit to hide it. */
+    search?: {
+        value: string;
+        onChange: (value: string) => void;
+        placeholder?: string;
+    };
+    disabled?: boolean;
+};
+export type SelectFilterBarProps = SelectFilterBarOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectFilterBarOwnProps>;
+export declare const SelectFilterBar: import('react').ForwardRefExoticComponent<SelectFilterBarOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectFilterBarOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectFilterChip.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode, ComponentPropsWithoutRef } from 'react';
+type SelectFilterChipOwnProps = {
+    children: ReactNode;
+    onClick?: () => void;
+    active?: boolean;
+};
+export type SelectFilterChipProps = SelectFilterChipOwnProps & Omit<ComponentPropsWithoutRef<'button'>, keyof SelectFilterChipOwnProps>;
+export declare const SelectFilterChip: import('react').ForwardRefExoticComponent<SelectFilterChipOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, keyof SelectFilterChipOwnProps> & import('react').RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/SelectFormLayout.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+declare function SelectFormLayoutRoot({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+declare function SelectFormLayoutGroup({ children, columns }: {
+    children: ReactNode;
+    columns?: number;
+}): import("react").JSX.Element;
+export declare const SelectFormLayout: typeof SelectFormLayoutRoot & {
+    Group: typeof SelectFormLayoutGroup;
+};
+export {};

package/dist/SelectFormModal.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+export declare function SelectFormModal({ open, onClose, onSubmit, title, subtitle, children, submitLabel, cancelLabel, submitting, submitDisabled, submitVariant, error, size, theme, }: {
+    open: boolean;
+    onClose: () => void;
+    onSubmit: () => void;
+    title: ReactNode;
+    subtitle?: ReactNode;
+    children: ReactNode;
+    submitLabel?: string;
+    cancelLabel?: string;
+    submitting?: boolean;
+    submitDisabled?: boolean;
+    /** `danger` paints the submit button red for irreversible actions (e.g. estorno). */
+    submitVariant?: 'primary' | 'danger';
+    error?: ReactNode;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    theme?: 'light' | 'dark';
+}): import("react").JSX.Element;

package/dist/SelectFunnel.d.ts

@@ -0,0 +1,9 @@
+import { ComponentPropsWithoutRef } from 'react';
+import { SelectFunnelStage } from './chartUtils';
+type SelectFunnelOwnProps = {
+    stages: SelectFunnelStage[];
+    format?: (n: number) => string;
+};
+export type SelectFunnelProps = SelectFunnelOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectFunnelOwnProps>;
+export declare const SelectFunnel: import('react').ForwardRefExoticComponent<SelectFunnelOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectFunnelOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectGauge.d.ts

@@ -0,0 +1,18 @@
+import { ComponentPropsWithoutRef } from 'react';
+type SelectGaugeOwnProps = {
+    /** Percentage 0–100 (drives the arc sweep). */
+    value: number;
+    label?: string;
+    caption?: string;
+    /** Outer width in px at the base 16px root; rendered in rem so it scales with the fluid
+     *  root font-size (the viewBox keeps the geometry crisp). Default 220. */
+    size?: number;
+    thickness?: number;
+    /** Override the progress arc colour (default brand gradient). */
+    color?: string;
+    /** Format the center number (default "NN%"). */
+    format?: (n: number) => string;
+};
+export type SelectGaugeProps = SelectGaugeOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectGaugeOwnProps>;
+export declare const SelectGauge: import('react').ForwardRefExoticComponent<SelectGaugeOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectGaugeOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectGaugeBands.d.ts

@@ -0,0 +1,18 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectGaugeBand {
+    /** Upper bound of this band (in value units). */
+    upTo: number;
+    color: string;
+}
+type SelectGaugeBandsOwnProps = {
+    value: number;
+    max?: number;
+    bands: SelectGaugeBand[];
+    size?: number;
+    thickness?: number;
+    label?: string;
+    format?: (n: number) => string;
+};
+export type SelectGaugeBandsProps = SelectGaugeBandsOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectGaugeBandsOwnProps>;
+export declare const SelectGaugeBands: import('react').ForwardRefExoticComponent<SelectGaugeBandsOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectGaugeBandsOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectGlobe.d.ts

@@ -0,0 +1,47 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectGlobePoint {
+    lat: number;
+    lng: number;
+    label: string;
+    value?: number;
+    color?: string;
+}
+export interface SelectGlobeArc {
+    from: {
+        lat: number;
+        lng: number;
+    };
+    to: {
+        lat: number;
+        lng: number;
+    };
+    color?: string;
+}
+type SelectGlobeOwnProps = {
+    points?: SelectGlobePoint[];
+    arcs?: SelectGlobeArc[];
+    /** Outer width/height in px at the base 16px root (square). The box renders in rem so it
+     *  scales with the app's fluid root font-size; the SVG tracks the real px. Default 320.
+     *  Ignored when fluid=true. */
+    size?: number;
+    /** Fill the parent's full width instead of a fixed rem size — use with a negative-margin
+     *  wrapper to let the sphere bleed beyond the card boundary. */
+    fluid?: boolean;
+    /** Initial latitude tilt of the globe, degrees (negative leans the north pole away). */
+    tilt?: number;
+    /** Auto-rotate when idle. */
+    spin?: boolean;
+    /** Idle auto-rotation speed, degrees/second. */
+    speed?: number;
+    color?: string;
+    format?: (n: number) => string;
+    legend?: boolean;
+    /** Draw the real continents (Natural Earth land). */
+    map?: boolean;
+    /** Notified after each scroll-zoom step with the new scale (clamped 0.8–1.8). Lets the
+     *  host derive granularity from zoom, maps-style (e.g. country → state → city). */
+    onZoomChange?: (scale: number) => void;
+};
+export type SelectGlobeProps = SelectGlobeOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectGlobeOwnProps>;
+export declare const SelectGlobe: import('react').ForwardRefExoticComponent<SelectGlobeOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectGlobeOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectHeatmap.d.ts

@@ -0,0 +1,26 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectHeatmapRow {
+    label: string;
+    /** Values aligned to `columns`; null = empty cell. */
+    values: (number | null)[];
+}
+type SelectHeatmapOwnProps = {
+    columns: string[];
+    rows: SelectHeatmapRow[];
+    /** Value printed INSIDE the cell — kept compact, the cell is narrow. */
+    format?: (n: number) => string;
+    /** Value in the TOOLTIP. Defaults to `format`; pass the exact formatter for money. */
+    formatValue?: (n: number) => string;
+    /** Base colour the cells are tinted from. */
+    color?: string;
+    /** Print the value inside each cell. Default true (turn off for dense grids). */
+    showValues?: boolean;
+    /** Colour-scale bounds; derived from the data when omitted. */
+    min?: number;
+    max?: number;
+    /** Minimum cell width in px. Default 40. */
+    cellSize?: number;
+};
+export type SelectHeatmapProps = SelectHeatmapOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectHeatmapOwnProps>;
+export declare const SelectHeatmap: import('react').ForwardRefExoticComponent<SelectHeatmapOwnProps & Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, keyof SelectHeatmapOwnProps> & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/SelectHexbin.d.ts

@@ -0,0 +1,18 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface SelectHexPoint {
+    x: number;
+    y: number;
+}
+type SelectHexbinOwnProps = {
+    points: SelectHexPoint[];
+    height?: number;
+    /** Hex radius in px. */
+    radius?: number;
+    color?: string;
+    xMax?: number;
+    yMax?: number;
+    format?: (n: number) => string;
+};
+export type SelectHexbinProps = SelectHexbinOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectHexbinOwnProps>;
+export declare function SelectHexbin({ points, height, radius, color, xMax: xMaxProp, yMax: yMaxProp, format, className, ...rest }: SelectHexbinProps): import("react").JSX.Element;
+export {};

package/dist/SelectHorizontalBar.d.ts

@@ -0,0 +1,23 @@
+import { ComponentPropsWithoutRef } from 'react';
+import { SelectBarDatum } from './chartUtils';
+type SelectHorizontalBarOwnProps = {
+    data: SelectBarDatum[];
+    height?: number;
+    /** Single colour for all bars (when `distributed` is false). */
+    color?: string;
+    /** Axis ticks. Compact by design — the axis has no room for exact amounts. */
+    format?: (n: number) => string;
+    /**
+     * The TOOLTIP value. Defaults to `format`, but pass the exact formatter for money: a tooltip is
+     * where the user goes to read the precise number, and a compact axis formatter turns R$ 3.000,00
+     * into "R$ 3 mil" — the one place rounding is not acceptable.
+     */
+    formatValue?: (n: number) => string;
+    /** One hue per row (default). Set false to use a single `color`. */
+    distributed?: boolean;
+    /** Width reserved for the category labels. Omit to size it from the longest label (recommended). */
+    labelWidth?: number;
+};
+export type SelectHorizontalBarProps = SelectHorizontalBarOwnProps & Omit<ComponentPropsWithoutRef<'div'>, keyof SelectHorizontalBarOwnProps>;
+export declare function SelectHorizontalBar({ data, height, color, format, formatValue, distributed, labelWidth, className, ...rest }: SelectHorizontalBarProps): import("react").JSX.Element;
+export {};