@sfperusacdev/sf-ui 0.1.11

package/dist/types/src/components/overlays/QRView.d.ts

@@ -0,0 +1,9 @@
+export type QRViewProps = {
+    open: boolean;
+    onClose: () => void;
+    value: string;
+    title?: string;
+    size?: number;
+    ariaLabel?: string;
+};
+export declare const QRView: ({ open, onClose, value, title, size, ariaLabel, }: QRViewProps) => import("react").JSX.Element;

package/dist/types/src/components/overlays/TabMenuOption.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { IconType } from 'react-icons';
+export type TabMenuOptionProps = {
+    label: string;
+    icon?: ReactNode | IconType | string;
+    selected?: boolean;
+    className?: string;
+};
+export declare const TabMenuOption: ({ label, icon, selected, className }: TabMenuOptionProps) => import("react").JSX.Element;

package/dist/types/src/components/overlays/Tooltip.d.ts

@@ -0,0 +1,10 @@
+import { ReactElement, ReactNode } from 'react';
+export type TooltipPlacement = "top" | "bottom" | "left" | "right";
+export type TooltipProps = {
+    content: ReactNode;
+    children: ReactElement;
+    placement?: TooltipPlacement;
+    className?: string;
+    contentClassName?: string;
+};
+export declare const Tooltip: ({ content, children, placement, className, contentClassName, }: TooltipProps) => import("react").JSX.Element;

package/dist/types/src/components/overlays/index.d.ts

@@ -0,0 +1,27 @@
+export { Modal, useModal } from './Modal';
+export type { ModalSize, OverlayHeaderVariant } from './Modal';
+export type { ModalProps } from './Modal';
+export { ConfirmDialog } from './ConfirmDialog';
+export { MessageDialog } from './MessageDialog';
+export type { MessageDialogProps, MessageDialogVariant } from './MessageDialog';
+export { DropdownMenu, DropdownMenuItem, useDropdownClose } from './DropdownMenu';
+export { OptionItem } from './OptionItem';
+export type { OptionItemProps } from './OptionItem';
+export { TabMenuOption } from './TabMenuOption';
+export type { TabMenuOptionProps } from './TabMenuOption';
+export { ContextMenuProvider, useContextMenu } from './ContextMenu';
+export type { ContextMenuItem, ContextMenuItemDef, ContextMenuProviderProps } from './ContextMenu';
+export { QRView } from './QRView';
+export type { QRViewProps } from './QRView';
+export { NotificationBell } from './NotificationBell';
+export type { NotificationBellProps, NotificationItem } from './NotificationBell';
+export { Tooltip } from './Tooltip';
+export type { TooltipPlacement, TooltipProps } from './Tooltip';
+export { Drawer, Sheet } from './Drawer';
+export type { DrawerProps, DrawerSide, SheetProps } from './Drawer';
+export { Popover } from './Popover';
+export type { PopoverAlign, PopoverProps, PopoverSide } from './Popover';
+export { CommandPalette } from './CommandPalette';
+export type { CommandPaletteItem, CommandPaletteProps } from './CommandPalette';
+export { ProductTour } from './ProductTour';
+export type { ProductTourProps, ProductTourStep } from './ProductTour';

package/dist/types/src/components/range-inputs/DateRangeInput.d.ts

@@ -0,0 +1,19 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+import { DateRange } from './types';
+export type DateRangeInputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    min?: string;
+    max?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    className?: string;
+    utc?: boolean;
+    onChange?: (value: DateRange) => void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const DateRangeInput: <TFormValues extends FieldValues>({ form, name, label, info, required, min, max, readOnly, disabled, small, className, utc, onChange, onRefresh, }: DateRangeInputProps<TFormValues>) => import("react").JSX.Element;

package/dist/types/src/components/range-inputs/DateRangeUtcInput.d.ts

@@ -0,0 +1,3 @@
+import { FieldValues } from 'react-hook-form';
+import { DateRangeInputProps } from './DateRangeInput';
+export declare const DateRangeUtcInput: <TFormValues extends FieldValues>(props: Omit<DateRangeInputProps<TFormValues>, "utc">) => import("react").JSX.Element;

package/dist/types/src/components/range-inputs/TimeRangeInput.d.ts

@@ -0,0 +1,18 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+import { TimeRange } from './types';
+type TimeRangeInputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    className?: string;
+    showDuration?: boolean;
+    onChange?: (value: TimeRange) => void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const TimeRangeInput: <TFormValues extends FieldValues>({ form, name, label, info, required, readOnly, disabled, small, className, showDuration, onChange, onRefresh, }: TimeRangeInputProps<TFormValues>) => import("react").JSX.Element;
+export type { TimeRangeInputProps };

package/dist/types/src/components/range-inputs/index.d.ts

@@ -0,0 +1,8 @@
+export { DateRangeInput } from './DateRangeInput';
+export type { DateRangeInputProps } from './DateRangeInput';
+export { DateRangeUtcInput } from './DateRangeUtcInput';
+export { TimeRangeInput } from './TimeRangeInput';
+export type { TimeRangeInputProps } from './TimeRangeInput';
+export { toLocalDateYMD, isValidDateString, toUtcDateIso, fromUtcDateIso, normalizeDateRange, normalizeTimeRange, calcTimeDuration, } from './rangeUtils';
+export { emptyDateRange, emptyTimeRange } from './types';
+export type { DateRange, TimeRange } from './types';

package/dist/types/src/components/range-inputs/rangeUtils.d.ts

@@ -0,0 +1,8 @@
+import { DateRange, TimeRange } from './types';
+export declare const toLocalDateYMD: (date?: Date) => string;
+export declare const isValidDateString: (value: string) => boolean;
+export declare const toUtcDateIso: (localDate: string) => string;
+export declare const fromUtcDateIso: (iso: string) => string;
+export declare const normalizeDateRange: (value: unknown) => DateRange;
+export declare const normalizeTimeRange: (value: unknown) => TimeRange;
+export declare const calcTimeDuration: (start: string, end: string) => string;

package/dist/types/src/components/range-inputs/types.d.ts

@@ -0,0 +1,10 @@
+export type DateRange = {
+    start: string;
+    end: string;
+};
+export type TimeRange = {
+    start: string;
+    end: string;
+};
+export declare const emptyDateRange: () => DateRange;
+export declare const emptyTimeRange: () => TimeRange;

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

@@ -0,0 +1,10 @@
+import { ActiveFilterChip } from './activeFilterUtils';
+export type ActiveFiltersBarProps = {
+    filters: ActiveFilterChip[];
+    onRemove: (id: string) => void;
+    onClearAll?: () => void;
+    label?: string;
+    emptyLabel?: string;
+    className?: string;
+};
+export declare const ActiveFiltersBar: ({ filters, onRemove, onClearAll, label, emptyLabel, className, }: ActiveFiltersBarProps) => import("react").JSX.Element;

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

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { QueryKey, UseQueryOptions } from '@tanstack/react-query';
+import { CustomTableProps } from './CustomTable';
+type AsyncCustomTableProps<TData extends Record<string, unknown>> = Omit<CustomTableProps<TData>, "data" | "emptyMessage" | "loading" | "loadingMessage" | "isFetching" | "error" | "onRetry" | "onRefresh"> & {
+    queryKey: QueryKey;
+    queryFn: () => Promise<TData[]>;
+    queryOptions?: Omit<UseQueryOptions<TData[], Error, TData[], QueryKey>, "queryKey" | "queryFn">;
+    loadingMessage?: string;
+    errorMessage?: (error: Error) => ReactNode;
+    emptyMessage?: string;
+};
+export declare function AsyncCustomTable<TData extends Record<string, unknown>>({ queryKey, queryFn, queryOptions, loadingMessage, errorMessage, emptyMessage, ...tableProps }: AsyncCustomTableProps<TData>): import("react").JSX.Element;
+export type { AsyncCustomTableProps };

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

@@ -0,0 +1,83 @@
+import { ReactNode } from 'react';
+import { IconType } from 'react-icons';
+import { AggregationFn } from '@tanstack/react-table';
+import { AsyncStateStore } from './asyncStateStore';
+import { CustomTableController } from './customTableController';
+export type TableHeaderVariant = "default" | "brand";
+type BuiltInAggregation = "sum" | "min" | "max" | "mean" | "median" | "unique" | "uniqueCount" | "count";
+type TableAggregation = BuiltInAggregation | AggregationFn<unknown>;
+type CustomColumn<TData> = {
+    id?: string;
+    accessorKey?: Extract<keyof TData, string>;
+    header: ReactNode;
+    columns?: CustomColumn<TData>[];
+    cell?: (value: unknown, row: TData) => ReactNode;
+    aggregatedCell?: (value: unknown) => ReactNode;
+    aggregationFn?: TableAggregation;
+    enableGrouping?: boolean;
+    enableSorting?: boolean;
+    enableHiding?: boolean;
+    size?: number;
+};
+type CustomTableProps<TData extends Record<string, unknown>> = {
+    id?: string;
+    stateStore?: AsyncStateStore;
+    data: TData[];
+    columns: CustomColumn<TData>[];
+    grouping?: string[];
+    defaultGrouping?: string[];
+    enableGrouping?: boolean;
+    enableSorting?: boolean;
+    enableFiltering?: boolean;
+    enablePagination?: boolean;
+    pageSize?: number;
+    fillParentHeight?: boolean;
+    maxBodyHeightPx?: number;
+    className?: string;
+    emptyMessage?: string;
+    title?: ReactNode;
+    subtitle?: ReactNode;
+    sidePanel?: boolean;
+    onGroupingChange?: (grouping: string[]) => void;
+    toolbarSlot?: ReactNode | ((selectedRows: TData[], api: {
+        clearSelection: () => void;
+    }) => ReactNode);
+    belowToolbarSlot?: ReactNode | ((selectedRows: TData[], api: {
+        clearSelection: () => void;
+    }) => ReactNode);
+    loading?: boolean;
+    loadingMessage?: string;
+    isFetching?: boolean;
+    error?: ReactNode;
+    onRetry?: () => void;
+    onRefresh?: () => void;
+    /** Clic en cualquier parte de una fila (excepto botones/enlaces internos). */
+    onRowClick?: (row: TData) => void;
+    enableRowSelection?: boolean;
+    getRowActions?: (row: TData) => Array<{
+        icon?: IconType;
+        label: string;
+        onSelect: (row: TData) => void;
+        disabled?: boolean;
+    }>;
+    getBulkActions?: (selectedRows: TData[], api: {
+        clearSelection: () => void;
+    }) => Array<{
+        icon?: ReactNode;
+        label: string;
+        onSelect: (selectedRows: TData[], api: {
+            clearSelection: () => void;
+        }) => void;
+        disabled?: boolean;
+    }>;
+    bulkActionsSlot?: (selectedRows: TData[], api: {
+        clearSelection: () => void;
+    }) => ReactNode;
+    onSelectionChange?: (selectedRows: TData[]) => void;
+    headerVariant?: TableHeaderVariant;
+    /** Oculta título, toolbar y chrome exterior — para uso dentro de ExpandableTableSection u otros contenedores. */
+    embedded?: boolean;
+    controller?: CustomTableController<TData>;
+};
+export declare function CustomTable<TData extends Record<string, unknown>>({ id, stateStore, data, columns, grouping, defaultGrouping, enableGrouping, enableSorting, enableFiltering, enablePagination, pageSize, fillParentHeight, maxBodyHeightPx, className, emptyMessage, title, subtitle, sidePanel, onGroupingChange, toolbarSlot, belowToolbarSlot, loading, loadingMessage, isFetching, error, onRetry, onRefresh, onRowClick, enableRowSelection, getRowActions, getBulkActions, bulkActionsSlot, onSelectionChange, headerVariant, embedded, controller, }: CustomTableProps<TData>): import("react").JSX.Element;
+export type { CustomColumn, CustomTableProps, TableAggregation };

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

@@ -0,0 +1,15 @@
+export type EditableColumn<T extends Record<string, unknown>> = {
+    id: keyof T & string;
+    header: string;
+    editable?: boolean;
+    sortable?: boolean;
+    align?: "left" | "right";
+};
+export type EditableDataGridProps<T extends Record<string, unknown>> = {
+    data: T[];
+    columns: EditableColumn<T>[];
+    rowKey: keyof T & string;
+    onChange?: (next: T[]) => void;
+    className?: string;
+};
+export declare const EditableDataGrid: <T extends Record<string, unknown>>({ data, columns, rowKey, onChange, className, }: EditableDataGridProps<T>) => import("react").JSX.Element;

package/dist/types/src/components/table/EditableDataGrid.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { CustomColumn, TableHeaderVariant } from './CustomTable';
+export type ExpandableTableSectionTableConfig<TData extends Record<string, unknown> = Record<string, unknown>> = {
+    data: TData[];
+    columns: CustomColumn<TData>[];
+    headerVariant?: TableHeaderVariant;
+    enablePagination?: boolean;
+    pageSize?: number;
+    emptyMessage?: string;
+};
+export type ExpandableTableSectionItem<TData extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    header: ReactNode;
+    trailing?: ReactNode;
+    content?: ReactNode;
+    table?: ExpandableTableSectionTableConfig<TData>;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+};
+export type ExpandableTableSectionProps<TData extends Record<string, unknown> = Record<string, unknown>> = {
+    items: ExpandableTableSectionItem<TData>[];
+    type?: "single" | "multiple";
+    className?: string;
+    ariaLabel?: string;
+};
+export declare const ExpandableTableSection: <TData extends Record<string, unknown> = Record<string, unknown>>({ items, type, className, ariaLabel, }: ExpandableTableSectionProps<TData>) => import("react").JSX.Element;

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

@@ -0,0 +1,14 @@
+import { default as React, RefCallback } from 'react';
+export interface PaginationRangeData {
+    totalItems: number;
+    limitItems: number;
+    offsetItems: number;
+}
+type Props = {
+    pageData: PaginationRangeData;
+    maxItemsRange: number;
+    onChange?: (limit: number, offset: number) => void;
+    divRef?: RefCallback<HTMLDivElement>;
+};
+export declare const PaginationRangeInput: React.FC<Props>;
+export {};

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

@@ -0,0 +1,13 @@
+import { TableColumnSettingsItem } from './useTableColumnSettings';
+export type TableColumnSettingsProps = {
+    open: boolean;
+    onClose: () => void;
+    items: TableColumnSettingsItem[];
+    onReorder: (fromIndex: number, toIndex: number) => void;
+    onToggleVisibility: (id: string) => void;
+    onReset?: () => void;
+    title?: string;
+    subtitle?: string;
+    className?: string;
+};
+export declare const TableColumnSettings: ({ open, onClose, items, onReorder, onToggleVisibility, onReset, title, subtitle, className, }: TableColumnSettingsProps) => import('react').ReactPortal | null;

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

@@ -0,0 +1,17 @@
+import { ColumnFiltersState, Table } from '@tanstack/react-table';
+export type TableColumnMeta = {
+    id: string;
+    headerLabel: string;
+};
+type Props<TData extends Record<string, unknown>> = {
+    open: boolean;
+    onClose: () => void;
+    columnsMeta: TableColumnMeta[];
+    headerLabelById: Map<string, string>;
+    columnTypeById: Map<string, "number" | "boolean" | "string">;
+    columnFilters: ColumnFiltersState;
+    table: Table<TData>;
+    markUserEdit: () => void;
+};
+export declare function TableFiltersPanel<TData extends Record<string, unknown>>({ open, onClose, columnsMeta, headerLabelById, columnTypeById, columnFilters, table, markUserEdit, }: Props<TData>): import("react").JSX.Element | null;
+export {};

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

@@ -0,0 +1,16 @@
+import { SortingState, Table } from '@tanstack/react-table';
+export type TableColumnMeta = {
+    id: string;
+    headerLabel: string;
+};
+type Props<TData extends Record<string, unknown>> = {
+    open: boolean;
+    onClose: () => void;
+    columnsMeta: TableColumnMeta[];
+    headerLabelById: Map<string, string>;
+    sorting: SortingState;
+    table: Table<TData>;
+    markUserEdit: () => void;
+};
+export declare function TableSortingPanel<TData extends Record<string, unknown>>({ open, onClose, columnsMeta, headerLabelById, sorting, table, markUserEdit, }: Props<TData>): import("react").JSX.Element | null;
+export {};

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

@@ -0,0 +1,9 @@
+import { ColumnFiltersState } from '@tanstack/react-table';
+import { ColumnFilterValue } from './tableFilters';
+export type ActiveFilterChip = {
+    id: string;
+    label: string;
+    valueLabel: string;
+};
+export declare const formatColumnFilterValue: (filter: ColumnFilterValue) => string;
+export declare const buildActiveFilterChips: (columnFilters: ColumnFiltersState, headerLabelById: Map<string, string> | Record<string, string>) => ActiveFilterChip[];

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

@@ -0,0 +1,6 @@
+export type AsyncStateStore = {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem?: (key: string) => Promise<void>;
+};
+export declare const createLocalStorageAsyncStateStore: (storage?: Storage) => AsyncStateStore;

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

@@ -0,0 +1,51 @@
+type SelectRowFn<T> = (row: T | T[]) => void;
+type SelectedRowsFn<T> = () => T[];
+type RegisterProps<T> = {
+    selection?: {
+        selectRowFn: SelectRowFn<T>;
+        cleanSelectionFn: () => void;
+        getSelectedRowsFn: SelectedRowsFn<T>;
+    };
+    row?: {
+        selectRowFn: (row: T) => void;
+        cleanSelectionFn: () => void;
+        getSelectedRowFn: () => T | undefined;
+    };
+};
+type SelectionController<T> = {
+    appendSelectRows: (rows: T | T[]) => void;
+    replaceSelection: (rows: T | T[]) => void;
+    cleanSelection: () => void;
+    getSelectedRows: () => T[];
+};
+type RowController<T> = {
+    selectRow: (row: T) => void;
+    replaceSelection: (row: T) => void;
+    cleanSelection: () => void;
+    getSelectedRow: () => T | undefined;
+};
+export type CustomTableController<T> = {
+    register: (props: RegisterProps<T>) => void;
+    selection: SelectionController<T>;
+    row: RowController<T>;
+};
+export type CustomTableControllerInternal<T> = {
+    events: {
+        selection: {
+            changeRowsSelection: (rows: T[]) => void;
+        };
+        row: {
+            changeRowSelection: (row?: T) => void;
+        };
+    };
+    register: (props: RegisterProps<T>) => void;
+} & CustomTableController<T>;
+export declare const useCustomTableController: <TData>(props?: {
+    selection?: {
+        onChange?: (rows: TData[]) => void;
+    };
+    row?: {
+        onChange?: (row?: TData) => void;
+    };
+}) => CustomTableController<TData>;
+export {};

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

@@ -0,0 +1,26 @@
+export { CustomTable } from './CustomTable';
+export type { CustomColumn, CustomTableProps, TableHeaderVariant } from './CustomTable';
+export { AsyncCustomTable } from './AsyncCustomTable';
+export type { AsyncCustomTableProps } from './AsyncCustomTable';
+export { PaginationRangeInput } from './PaginationRangeInput';
+export type { PaginationRangeData } from './PaginationRangeInput';
+export { TableFiltersPanel } from './TableFiltersPanel';
+export { TableSortingPanel } from './TableSortingPanel';
+export { createLocalStorageAsyncStateStore } from './asyncStateStore';
+export type { AsyncStateStore } from './asyncStateStore';
+export { useCustomTableController } from './customTableController';
+export type { CustomTableController } from './customTableController';
+export { columnFilterFn, inferInitialFilterValue, isColumnFilterValue, STRING_FILTER_OPS, NUMBER_FILTER_OPS, } from './tableFilters';
+export type { ColumnFilterValue, StringFilterOp, NumberFilterOp } from './tableFilters';
+export { useTableColumnSettings } from './useTableColumnSettings';
+export type { TableColumnDef, TableColumnSettingsItem, UseTableColumnSettingsOptions, } from './useTableColumnSettings';
+export { TableColumnSettings } from './TableColumnSettings';
+export type { TableColumnSettingsProps } from './TableColumnSettings';
+export { ActiveFiltersBar } from './ActiveFiltersBar';
+export type { ActiveFiltersBarProps } from './ActiveFiltersBar';
+export { buildActiveFilterChips, formatColumnFilterValue } from './activeFilterUtils';
+export type { ActiveFilterChip } from './activeFilterUtils';
+export { EditableDataGrid } from './EditableDataGrid';
+export type { EditableColumn, EditableDataGridProps } from './EditableDataGrid';
+export { ExpandableTableSection } from './ExpandableTableSection';
+export type { ExpandableTableSectionItem, ExpandableTableSectionProps, ExpandableTableSectionTableConfig, } from './ExpandableTableSection';

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

@@ -0,0 +1,21 @@
+import { Row } from '@tanstack/react-table';
+export declare const STRING_FILTER_OPS: readonly ["contains", "equals", "notContains", "startsWith", "endsWith"];
+export type StringFilterOp = (typeof STRING_FILTER_OPS)[number];
+export declare const NUMBER_FILTER_OPS: readonly ["eq", "gt", "gte", "lt", "lte"];
+export type NumberFilterOp = (typeof NUMBER_FILTER_OPS)[number];
+export type ColumnFilterValue = {
+    type: "string";
+    op: StringFilterOp;
+    value: string;
+} | {
+    type: "number";
+    op: NumberFilterOp;
+    value: number | null;
+} | {
+    type: "boolean";
+    op: "is";
+    value: boolean | null;
+};
+export declare const isColumnFilterValue: (value: unknown) => value is ColumnFilterValue;
+export declare const inferInitialFilterValue: (inferredType: "number" | "boolean" | "string") => ColumnFilterValue;
+export declare function columnFilterFn<TData extends Record<string, unknown>>(row: Row<TData>, columnId: string, filterValue: ColumnFilterValue): boolean;

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

@@ -0,0 +1,29 @@
+import { ColumnOrderState, VisibilityState } from '@tanstack/react-table';
+export type TableColumnDef = {
+    id: string;
+    label: string;
+    canHide?: boolean;
+    defaultVisible?: boolean;
+};
+export type TableColumnSettingsItem = {
+    id: string;
+    label: string;
+    visible: boolean;
+    canHide: boolean;
+};
+export type UseTableColumnSettingsOptions = {
+    columns: TableColumnDef[];
+    defaultOrder?: string[];
+    persistKey?: string;
+};
+export declare const useTableColumnSettings: ({ columns, defaultOrder, persistKey, }: UseTableColumnSettingsOptions) => {
+    columnOrder: string[];
+    columnVisibility: VisibilityState;
+    setColumnOrder: import('react').Dispatch<import('react').SetStateAction<ColumnOrderState>>;
+    setColumnVisibility: import('react').Dispatch<import('react').SetStateAction<VisibilityState>>;
+    items: TableColumnSettingsItem[];
+    toggleVisibility: (id: string) => void;
+    setVisible: (id: string, visible: boolean) => void;
+    reorder: (fromIndex: number, toIndex: number) => void;
+    reset: () => void;
+};

package/dist/types/src/components/visualization/NetworkLegend.d.ts

@@ -0,0 +1,8 @@
+import { NetworkEdge, NetworkNode } from './types';
+export type NetworkLegendProps = {
+    nodes: NetworkNode[];
+    edges?: NetworkEdge[];
+    placement?: "bottom-left" | "bottom-right";
+    className?: string;
+};
+export declare const NetworkLegend: ({ nodes, edges, placement, className, }: NetworkLegendProps) => import("react").JSX.Element;

package/dist/types/src/components/visualization/NetworkMap.d.ts

@@ -0,0 +1,19 @@
+import { LatLngExpression } from 'leaflet';
+import { NetworkBasemap, NetworkEdge, NetworkNode } from './types';
+export type NetworkMapProps = {
+    nodes: NetworkNode[];
+    edges?: NetworkEdge[];
+    center?: LatLngExpression;
+    zoom?: number;
+    height?: number | string;
+    selectedNodeId?: string;
+    onNodeClick?: (node: NetworkNode) => void;
+    showLegend?: boolean;
+    fitBoundsToNodes?: boolean;
+    basemap?: NetworkBasemap;
+    onBasemapChange?: (basemap: NetworkBasemap) => void;
+    showBasemapSwitcher?: boolean;
+    ariaLabel?: string;
+    className?: string;
+};
+export declare const NetworkMap: ({ nodes, edges, center, zoom, height, selectedNodeId, onNodeClick, showLegend, fitBoundsToNodes, basemap: controlledBasemap, onBasemapChange, showBasemapSwitcher, ariaLabel, className, }: NetworkMapProps) => import("react").JSX.Element;

package/dist/types/src/components/visualization/OrgTree.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+import { OrgTreeNode, OrgTreeNodeRow, OrgTreeTheme } from './types';
+export type OrgTreeProps<T extends OrgTreeNode = OrgTreeNode> = {
+    nodes: T[];
+    title?: string;
+    subtitle?: string;
+    loading?: boolean;
+    error?: Error | null;
+    onRefresh?: () => void;
+    canEdit?: boolean;
+    onAddNode?: (parent?: OrgTreeNodeRow<T>) => void;
+    onEditNode?: (node: OrgTreeNodeRow<T>) => void;
+    onDeleteNode?: (node: OrgTreeNodeRow<T>) => void;
+    showLegend?: boolean;
+    themes?: Record<string, OrgTreeTheme>;
+    onRenderNode?: (node: OrgTreeNodeRow<T>) => ReactNode;
+    maxHeight?: number | string;
+    className?: string;
+};
+export declare const OrgTree: <T extends OrgTreeNode = OrgTreeNode>({ nodes, title, subtitle, loading, error, onRefresh, canEdit, onAddNode, onEditNode, onDeleteNode, showLegend, themes, onRenderNode, maxHeight, className, }: OrgTreeProps<T>) => import("react").JSX.Element;

package/dist/types/src/components/visualization/index.d.ts

@@ -0,0 +1,9 @@
+export { OrgTree } from './OrgTree';
+export type { OrgTreeProps } from './OrgTree';
+export { NetworkMap } from './NetworkMap';
+export type { NetworkMapProps } from './NetworkMap';
+export { NetworkLegend } from './NetworkLegend';
+export type { NetworkLegendProps } from './NetworkLegend';
+export { ORG_TREE_DEFAULT_THEMES, buildOrgTreeRows, resolveOrgTreeTheme, countOrgTreeNodes, orgTreeRootNodes, } from './orgTreeUtils';
+export { NETWORK_STATUS_COLORS, NETWORK_STATUS_LABELS, NETWORK_EDGE_STYLES, NETWORK_BASEMAPS, NETWORK_KIND_LABELS, NETWORK_KIND_COLORS, normalizeNetworkNodes, normalizeNetworkEdges, countNetworkStatus, networkMapBounds, networkNodePositions, networkEdgeLines, } from './networkMapUtils';
+export type { OrgTreeNode, OrgTreeNodeRow, OrgTreeTheme, NetworkNode, NetworkEdge, NetworkNodeStatus, NetworkNodeKind, NetworkBasemap, NetworkEdgeType, } from './types';

package/dist/types/src/components/visualization/networkMapUtils.d.ts

@@ -0,0 +1,32 @@
+import { LatLngBoundsExpression, LatLngExpression } from 'leaflet';
+import { NetworkEdge, NetworkEdgeType, NetworkNode, NetworkNodeKind, NetworkNodeStatus } from './types';
+export declare const NETWORK_BASEMAPS: {
+    readonly street: {
+        readonly url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png";
+        readonly attribution: "&copy; <a href=\"https://www.openstreetmap.org/copyright\" target=\"_blank\" rel=\"noreferrer\">OpenStreetMap</a>";
+    };
+    readonly satellite: {
+        readonly url: "https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}";
+        readonly attribution: "Tiles &copy; Esri — Source: Esri, Maxar, Earthstar Geographics, and the GIS User Community";
+    };
+};
+export declare const NETWORK_KIND_LABELS: Record<NetworkNodeKind, string>;
+export declare const NETWORK_KIND_COLORS: Record<NetworkNodeKind, string>;
+export declare const NETWORK_STATUS_COLORS: Record<NetworkNodeStatus, string>;
+export declare const NETWORK_STATUS_LABELS: Record<NetworkNodeStatus, string>;
+export declare const NETWORK_EDGE_STYLES: Record<NetworkEdgeType, {
+    color: string;
+    weight: number;
+    dashArray?: string;
+}>;
+/** Resuelve `var(--sf-*)` para APIs que no aceptan variables CSS (p. ej. Leaflet SVG). */
+export declare const resolveNetworkColor: (value: string, fallback?: string) => string;
+export declare const normalizeNetworkNodes: (value: unknown) => NetworkNode[];
+export declare const normalizeNetworkEdges: (value: unknown) => NetworkEdge[];
+export declare const countNetworkStatus: (nodes: NetworkNode[]) => Record<NetworkNodeStatus, number>;
+export declare const networkMapBounds: (nodes: NetworkNode[]) => LatLngBoundsExpression | null;
+export declare const networkNodePositions: (nodes: NetworkNode[]) => Record<string, LatLngExpression>;
+export declare const networkEdgeLines: (edges: NetworkEdge[], positions: Record<string, LatLngExpression>) => Array<{
+    edge: NetworkEdge;
+    line: LatLngExpression[];
+}>;

package/dist/types/src/components/visualization/orgTreeUtils.d.ts

@@ -0,0 +1,6 @@
+import { OrgTreeNode, OrgTreeNodeRow, OrgTreeTheme } from './types';
+export declare const ORG_TREE_DEFAULT_THEMES: Record<string, OrgTreeTheme>;
+export declare const buildOrgTreeRows: <T extends OrgTreeNode>(nodes: T[]) => OrgTreeNodeRow<T>[];
+export declare const resolveOrgTreeTheme: (type: string, themes?: Record<string, OrgTreeTheme>) => OrgTreeTheme | null;
+export declare const countOrgTreeNodes: (nodes: OrgTreeNode[]) => number;
+export declare const orgTreeRootNodes: (nodes: OrgTreeNode[]) => OrgTreeNode[];