@mt-gloss/ui 0.0.2

package/lib/dashboard/TimeFrame/HybridDatePicker.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { HybridDatePickerProps } from './types';
+/**
+ * HybridDatePicker - Advanced date picker with presets, calendar, and market events.
+ *
+ * GlossUI version: fully controlled via props. No localStorage reads/writes.
+ * Container provides preferences, markets, and compare state via callback props.
+ *
+ * NOTE: Fixed jitter issue by removing smart viewport positioning (getBoundingClientRect).
+ * MUI Popover's native positioning handles overflow detection without layout thrashing.
+ *
+ * @example
+ * ```tsx
+ * <HybridDatePicker
+ *   value={[startDate, endDate]}
+ *   onChange={(payload) => setDateRange(payload)}
+ *   enableCompare
+ *   calendarSize="medium"
+ *   preferences={prefs}
+ *   onPreferenceChange={setPrefs}
+ * />
+ * ```
+ */
+export declare const HybridDatePicker: React.FC<HybridDatePickerProps>;

package/lib/dashboard/TimeFrame/MarketPresetRow.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { MarketPresetRowProps } from './types';
+/**
+ * MarketPresetRow - Market event row item with edit functionality.
+ *
+ * @example
+ * ```tsx
+ * <MarketPresetRow
+ *   preset={{ id: 'atlanta', label: 'Atlanta Market', startDate, endDate, location: 'Atlanta, GA' }}
+ *   isSelected={false}
+ *   onSelect={(id) => setSelected(id)}
+ *   onEdit={(preset) => openEditor(preset)}
+ * />
+ * ```
+ */
+export declare const MarketPresetRow: React.FC<MarketPresetRowProps>;

package/lib/dashboard/TimeFrame/MiniCalendar.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { MiniCalendarProps } from './types';
+/**
+ * MiniCalendar - Compact calendar for date range selection.
+ *
+ * @example
+ * ```tsx
+ * <MiniCalendar
+ *   selectedStart={startDate}
+ *   selectedEnd={endDate}
+ *   onSelect={(start, end) => setRange(start, end)}
+ *   size="medium"
+ * />
+ * ```
+ */
+export declare const MiniCalendar: React.FC<MiniCalendarProps>;

package/lib/dashboard/TimeFrame/TimeFrame.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { TimeFrameProps } from './types';
+export { HybridDatePicker } from './HybridDatePicker';
+export type { HybridDatePickerProps } from './types';
+/**
+ * TimeFrame - MUI DateRangePicker wrapper with shortcuts and compare mode.
+ *
+ * GlossUI version: fully controlled via props. No localStorage reads/writes.
+ * Container provides preferences and pinned state via callback props.
+ *
+ * @example
+ * ```tsx
+ * <TimeFrame
+ *   value={[startDate, endDate]}
+ *   onChange={(payload) => setDateRange(payload)}
+ *   preferences={prefs}
+ *   onPreferenceChange={setPrefs}
+ * />
+ * ```
+ */
+export declare const TimeFrame: React.FC<TimeFrameProps>;

package/lib/dashboard/TimeFrame/fixtures/timeFrameSamples.d.ts

@@ -0,0 +1,17 @@
+import { DateRangeValue, CompareValue, DatePreferences, MarketPreset, MarketEvent, PresetDefinition, MarketPresetData } from '../types';
+/** A 30-day date range ending today */
+export declare const sampleDateRange: DateRangeValue;
+/** Compare ranges with 3 named periods */
+export declare const sampleCompareRanges: CompareValue;
+/** Default date preferences */
+export declare const samplePreferences: DatePreferences;
+/** Built-in market presets */
+export declare const sampleMarkets: MarketPreset[];
+/** Custom market events */
+export declare const sampleCustomMarkets: MarketEvent[];
+/** Sample data for MarketPresetRow demo */
+export declare const sampleMarketPresetData: MarketPresetData[];
+/** Sample presets for ExpandableChip demo */
+export declare const samplePresets: PresetDefinition[];
+/** Period presets for ExpandableChip demo */
+export declare const samplePeriodPresets: PresetDefinition[];

package/lib/dashboard/TimeFrame/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * TimeFrame Family Barrel
+ *
+ * Exports all TimeFrame components, types, and utilities from glossui.
+ */
+export { HybridDatePicker } from './HybridDatePicker';
+export { TimeFrame } from './TimeFrame';
+export { MiniCalendar } from './MiniCalendar';
+export { ExpandableChip } from './ExpandableChip';
+export { MarketPresetRow } from './MarketPresetRow';
+export type { HybridDatePickerProps, TimeFrameProps, MiniCalendarProps, ExpandableChipProps, MarketPresetRowProps, MarketPresetData, DateRangeValue, CompareValue, DateChangePayload, DatePreferences, ComparePreferences, MarketEvent, PresetDefinition, MarketPreset, DateRange, CalendarSize, RangeColor, MarketDateInfo, } from './types';
+export { formatDateRange, formatMarketDates, isMarketActive, isSameDay, isInRange, generateMarketId } from './utils/dateHelpers';
+export { getDateRangeForPreset, findPreset, getPresetLabel, normalizePresetId, toUppercasePresetId, getAllPresets, ROLLING_OPTIONS, PERIOD_OPTIONS, TODAY_PRESET, DEFAULT_MARKET_PRESETS, DEFAULT_PINNED, } from './utils/presets';
+export { sampleDateRange, sampleCompareRanges, samplePreferences, sampleMarkets, sampleCustomMarkets, sampleMarketPresetData, samplePresets, samplePeriodPresets, } from './fixtures/timeFrameSamples';

package/lib/dashboard/TimeFrame/types.d.ts

@@ -0,0 +1,202 @@
+import { SxProps, Theme } from '@mui/material';
+/** Tuple representing a nullable date range [start, end] */
+export type DateRangeValue = [Date | null, Date | null];
+/** Compare mode value with up to 3 named ranges */
+export interface CompareValue {
+    rangeA: DateRangeValue;
+    rangeB?: DateRangeValue;
+    rangeC?: DateRangeValue;
+}
+/** Union type for date picker onChange payload */
+export type DateChangePayload = DateRangeValue | CompareValue;
+/** A named date preset (e.g., MTD, 30D) */
+export interface PresetDefinition {
+    id: string;
+    label: string;
+}
+/** A market event preset with date range and location */
+export interface MarketPreset extends PresetDefinition {
+    startDate: Date;
+    endDate: Date;
+    location: string;
+}
+/** Resolved date range from a preset */
+export interface DateRange {
+    start: Date;
+    end: Date;
+    label?: string;
+}
+/** User date preferences (persisted by container, not glossui) */
+export interface DatePreferences {
+    version: number;
+    lastPreset: string;
+    pinnedPreset: string;
+    compareEnabled: boolean;
+    rangeCount: number;
+    lastPresetB: string | null;
+    lastPresetC: string | null;
+    pinnedRolling?: string;
+    pinnedPeriod?: string;
+    [key: string]: unknown;
+}
+/** Compare mode preferences */
+export interface ComparePreferences {
+    enabled: boolean;
+    rangeCount: number;
+    presetB: string | null;
+    presetC: string | null;
+}
+/** A market event (built-in or custom) */
+export interface MarketEvent {
+    id: string;
+    label: string;
+    startDate: Date;
+    endDate: Date;
+    location?: string;
+    isCustom?: boolean;
+    [key: string]: unknown;
+}
+/** Calendar display size */
+export type CalendarSize = 'small' | 'medium' | 'large';
+/** Color variant for range highlighting */
+export type RangeColor = 'primary' | 'secondary' | 'tertiary';
+/** Market date info for calendar dot rendering */
+export interface MarketDateInfo {
+    startDate: Date;
+    endDate: Date;
+    label: string;
+    [key: string]: unknown;
+}
+/** Props for HybridDatePicker -- the main date picker component */
+export interface HybridDatePickerProps {
+    /** Current value: a single range tuple, compare value, or null */
+    value: [Date, Date] | CompareValue | null;
+    /** Called when the date selection changes */
+    onChange: (value: DateChangePayload) => void;
+    /** Enable compare mode toggle (default: false) */
+    enableCompare?: boolean;
+    /** Calendar display size (default: 'medium') */
+    calendarSize?: CalendarSize;
+    /** Show header bar (default: false) */
+    showHeader?: boolean;
+    /** Header bar title (default: 'Select Time Frame') */
+    headerTitle?: string;
+    /** Force popover open for testing (default: false) */
+    forceOpen?: boolean;
+    /** Called when popover closes */
+    onClose?: () => void;
+    /** MUI sx prop for container styling */
+    sx?: SxProps<Theme>;
+    /** Current user preferences */
+    preferences?: DatePreferences;
+    /** Called when preferences should be saved */
+    onPreferenceChange?: (prefs: DatePreferences) => void;
+    /** Built-in market presets */
+    markets?: MarketPreset[];
+    /** User-created custom markets */
+    customMarkets?: MarketEvent[];
+    /** Called when a custom market is saved */
+    onMarketSave?: (market: MarketEvent) => void;
+    /** Called when a custom market is deleted */
+    onMarketDelete?: (marketId: string) => void;
+    /** Whether compare mode is active */
+    compareEnabled?: boolean;
+    /** Called when compare mode is toggled */
+    onCompareToggle?: (enabled: boolean) => void;
+}
+/** Props for MiniCalendar -- compact calendar for date range selection */
+export interface MiniCalendarProps {
+    /** Currently selected start date */
+    selectedStart: Date | null;
+    /** Currently selected end date */
+    selectedEnd: Date | null;
+    /** Called when dates are selected */
+    onSelect: (start: Date, end: Date | null) => void;
+    /** Market date info for dot indicators */
+    marketDates?: MarketDateInfo[];
+    /** Maximum selectable date */
+    maxDate?: Date;
+    /** Calendar size preset (default: 'medium') */
+    size?: CalendarSize;
+    /** Show market legend below calendar */
+    showMarketLegend?: boolean;
+    /** Show month/year dropdown selectors */
+    showMonthYearDropdowns?: boolean;
+    /** Date to focus/navigate to */
+    focusDate?: Date;
+    /** Color variant for range highlighting (default: 'primary') */
+    rangeColor?: RangeColor;
+}
+/** Props for ExpandableChip -- hover-expand preset group with pinning */
+export interface ExpandableChipProps {
+    /** Unique group identifier */
+    groupId: string;
+    /** Available preset options */
+    options: PresetDefinition[];
+    /** Currently selected preset ID */
+    selectedId: string;
+    /** Default preset ID for this group */
+    defaultId: string;
+    /** Called when a preset is selected */
+    onSelect: (id: string) => void;
+    /** Currently pinned preset ID */
+    pinnedId: string;
+    /** Called when a preset is pinned */
+    onPin?: (id: string) => void;
+    /** Whether the dropdown is open (controlled) */
+    isOpen?: boolean;
+    /** Called when open state changes */
+    onOpenChange?: (groupId: string, isOpen: boolean) => void;
+}
+/** Market preset data for MarketPresetRow */
+export interface MarketPresetData {
+    id: string;
+    label: string;
+    startDate: Date;
+    endDate: Date;
+    location?: string;
+    active?: boolean;
+    [key: string]: unknown;
+}
+/** Props for MarketPresetRow -- market event row item */
+export interface MarketPresetRowProps {
+    /** Market preset data to display */
+    preset: MarketPresetData;
+    /** Whether this preset is currently selected */
+    isSelected: boolean;
+    /** Whether interaction is disabled */
+    disabled?: boolean;
+    /** Called when the preset is selected */
+    onSelect: (id: string) => void;
+    /** Called when edit is clicked */
+    onEdit?: (preset: MarketPresetData) => void;
+}
+/** Props for the TimeFrame wrapper component */
+export interface TimeFrameProps {
+    /** Current value: a single range tuple or compare value */
+    value: DateRangeValue;
+    /** Called when the date selection changes */
+    onChange: (value: DateChangePayload) => void;
+    /** Called when preset selection changes */
+    onPresetChange?: (presetId: string) => void;
+    /** User preferences (controlled) */
+    preferences?: DatePreferences;
+    /** Called when preferences should be saved */
+    onPreferenceChange?: (prefs: DatePreferences) => void;
+    /** Calendar display size */
+    calendarSize?: CalendarSize;
+    /** Whether compare mode is active */
+    compareEnabled?: boolean;
+    /** Called when compare mode is toggled */
+    onCompareToggle?: (enabled: boolean) => void;
+    /** Built-in market presets */
+    markets?: MarketPreset[];
+    /** User-created custom markets */
+    customMarkets?: MarketEvent[];
+    /** Called when a custom market is saved */
+    onMarketSave?: (market: MarketEvent) => void;
+    /** Called when a custom market is deleted */
+    onMarketDelete?: (marketId: string) => void;
+    /** MUI sx prop for container styling */
+    sx?: SxProps<Theme>;
+}

package/lib/dashboard/TimeFrame/utils/dateHelpers.d.ts

@@ -0,0 +1 @@
+export { formatDateRange, formatMarketDates, isMarketActive, isSameDay, isInRange, generateMarketId } from '@mt-gloss/utils';

package/lib/dashboard/TimeFrame/utils/presets.d.ts

@@ -0,0 +1 @@
+export { ROLLING_OPTIONS, PERIOD_OPTIONS, TODAY_PRESET, DEFAULT_MARKET_PRESETS, PRESET_ID_MAP, PRESET_ID_REVERSE_MAP, getDateRangeForPreset, findPreset, getPresetLabel, normalizePresetId, toUppercasePresetId, getAllPresets, DEFAULT_PINNED } from '@mt-gloss/utils';

package/lib/dashboard/TimeFrame/utils/smartDateFormat.d.ts

@@ -0,0 +1 @@
+export { formatDateRangeSmart as formatDateRange, detectPreset, formatDateRangeWithPreset, getDateRangeDisplayInfo, formatShortYear, stripLeadingZeros, formatSingleDate, parseDateRange, isValidDateRangeFormat, getDurationDays, formatDuration, formatPreset, getPresetDateRange } from '@mt-gloss/utils';

package/lib/dashboard/UnifiedBreakdownTable/UnifiedBreakdownTable.d.ts

@@ -0,0 +1,24 @@
+import { UnifiedBreakdownTableProps } from './types';
+declare function UnifiedBreakdownTableInner<TRow extends {
+    id: string | number;
+}>(props: UnifiedBreakdownTableProps<TRow>): import("react/jsx-runtime").JSX.Element;
+/**
+ * UnifiedBreakdownTable - generic typed DataGridPro wrapper for breakdown data.
+ *
+ * Accepts a generic `TRow` type for type-safe row data. Uses an internal
+ * `toGridColDef` adapter to map public `ColumnDef<TRow>` to MUI `GridColDef`,
+ * isolating consumers from MUI DataGrid types.
+ *
+ * @example
+ * ```tsx
+ * import { UnifiedBreakdownTable } from '@mt-gloss/ui';
+ * import type { ColumnDef } from '@mt-gloss/ui';
+ *
+ * const columns: ColumnDef<MyRow>[] = [...];
+ * <UnifiedBreakdownTable data={rows} columns={columns} pageSize={10} />
+ * ```
+ */
+export declare const UnifiedBreakdownTable: typeof UnifiedBreakdownTableInner & {
+    displayName?: string;
+};
+export {};

package/lib/dashboard/UnifiedBreakdownTable/fixtures/columns.d.ts

@@ -0,0 +1,5 @@
+import { ColumnDef } from '../types';
+import { OrderRow } from './orderRows';
+import { ItemRow } from './itemRows';
+export declare const orderColumns: ColumnDef<OrderRow>[];
+export declare const itemColumns: ColumnDef<ItemRow>[];

package/lib/dashboard/UnifiedBreakdownTable/fixtures/itemRows.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Sample item row data for table explorer / testing.
+ */
+export interface ItemRow {
+    id: string;
+    sku: string;
+    name: string;
+    category: string;
+    price: number;
+    quantity: number;
+    total: number;
+    manufacturerName: string;
+    lastDate: string;
+}
+export declare const itemRows: ItemRow[];

package/lib/dashboard/UnifiedBreakdownTable/fixtures/orderRows.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Sample order row data for table explorer / testing.
+ */
+export interface OrderRow {
+    id: string;
+    orderNumber: string;
+    customerName: string;
+    manufacturerName: string;
+    salespersonName: string;
+    status: string;
+    total: number;
+    date: string;
+    skuCount: number;
+}
+export declare const orderRows: OrderRow[];

package/lib/dashboard/UnifiedBreakdownTable/index.d.ts

@@ -0,0 +1,7 @@
+export { UnifiedBreakdownTable } from './UnifiedBreakdownTable';
+export * from './types';
+export { orderRows } from './fixtures/orderRows';
+export type { OrderRow } from './fixtures/orderRows';
+export { itemRows } from './fixtures/itemRows';
+export type { ItemRow } from './fixtures/itemRows';
+export { orderColumns, itemColumns } from './fixtures/columns';

package/lib/dashboard/UnifiedBreakdownTable/types.d.ts

@@ -0,0 +1,61 @@
+import { ReactNode } from 'react';
+/** Column definition for UnifiedBreakdownTable. Generic over row type for field safety. */
+export interface ColumnDef<TRow> {
+    field: keyof TRow & string;
+    headerName: string;
+    width?: number;
+    minWidth?: number;
+    flex?: number;
+    align?: 'left' | 'right' | 'center';
+    headerAlign?: 'left' | 'right' | 'center';
+    cellClassName?: string;
+    headerClassName?: string;
+    renderCell?: (params: {
+        row: TRow;
+        value: TRow[keyof TRow];
+    }) => ReactNode;
+    renderHeader?: () => ReactNode;
+    valueGetter?: (params: {
+        row: TRow;
+    }) => unknown;
+}
+/** Controlled pagination configuration. */
+export interface PaginationConfig {
+    page: number;
+    pageSize: number;
+    total: number;
+    onPageChange: (page: number, pageSize: number) => void;
+}
+/** Single sort directive. */
+export interface SortModel {
+    field: string;
+    sort: 'asc' | 'desc';
+}
+/** Data for an active filter displayed as a removable chip. */
+export interface FilterChipData {
+    id: string;
+    label: string;
+    field: string;
+    value: string;
+    onRemove?: (id: string) => void;
+}
+/** Props for the presentational UnifiedBreakdownTable component. */
+export interface UnifiedBreakdownTableProps<TRow extends {
+    id: string | number;
+}> {
+    data: TRow[];
+    columns: ColumnDef<TRow>[];
+    isLoading?: boolean;
+    isError?: boolean;
+    isEmpty?: boolean;
+    sortModel?: SortModel[];
+    onSort?: (model: SortModel[]) => void;
+    pagination?: PaginationConfig;
+    activeFilters?: FilterChipData[];
+    onFilterRemove?: (filterId: string) => void;
+    rowHeight?: number;
+    headerHeight?: number;
+    onCellClick?: (row: TRow, field: keyof TRow & string, event: React.MouseEvent) => void;
+    onContextMenu?: (row: TRow, field: keyof TRow & string, anchorEl: HTMLElement) => void;
+    getRowId?: (row: TRow) => string;
+}

package/lib/dashboard/UnifiedContextMenu/UnifiedContextMenu.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+import { UnifiedContextMenuProps } from './types';
+declare function UnifiedContextMenuInner({ anchorEl, open, onClose, actions, row, entityType, dispatch, onAddTab, onFilter, onUpdateViz, onActionClick, }: UnifiedContextMenuProps): import("react/jsx-runtime").JSX.Element;
+export declare const UnifiedContextMenu: React.MemoExoticComponent<typeof UnifiedContextMenuInner>;
+export {};

package/lib/dashboard/UnifiedContextMenu/fixtures/menuActions.d.ts

@@ -0,0 +1,9 @@
+import { UnifiedMenuAction } from '../types';
+export declare const entityNameActions: UnifiedMenuAction[];
+export declare const orderIdActions: UnifiedMenuAction[];
+export declare const numericActions: UnifiedMenuAction[];
+export declare const allFixtures: {
+    entityName: UnifiedMenuAction[];
+    orderId: UnifiedMenuAction[];
+    numeric: UnifiedMenuAction[];
+};

package/lib/dashboard/UnifiedContextMenu/index.d.ts

@@ -0,0 +1,3 @@
+export { UnifiedContextMenu } from './UnifiedContextMenu';
+export type { UnifiedContextMenuProps, UnifiedMenuAction, MenuActionContext, MenuFilterOptions, CellKind, MenuSection, EntityType, } from './types';
+export { entityNameActions, orderIdActions, numericActions, allFixtures as contextMenuFixtures } from './fixtures/menuActions';

package/lib/dashboard/UnifiedContextMenu/types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * GlossUI UnifiedContextMenu Type Definitions
+ *
+ * Shared TypeScript interfaces for the unified context menu system.
+ * These types define the glossui component's API contract.
+ * Copied from app/components/UnifiedContextMenu/types.ts with
+ * the addition of the component props interface.
+ */
+export type EntityType = 'customer' | 'manufacturer' | 'salesperson';
+/** Cell kinds that trigger context menus */
+export type CellKind = 'entityName' | 'orderId' | 'itemName' | 'numeric';
+/** Menu sections rendered in order with dividers between groups */
+export type MenuSection = 'tab-actions' | 'graph-actions' | 'direct-nav' | 'related-nav';
+/**
+ * A single menu action definition.
+ * Each action belongs to a section, supports multiple cell kinds,
+ * and can be filtered by role, status, entity type, table type, and field.
+ */
+export interface UnifiedMenuAction {
+    /** Unique action identifier */
+    id: string;
+    /** Display label */
+    label: string;
+    /** MUI icon name string (resolved via ICON_MAP in component) */
+    icon: string;
+    /** Which section this action belongs to */
+    section: MenuSection;
+    /** Action behavior type */
+    type: 'create-tab' | 'graph' | 'navigate' | 'filter' | 'dispatch';
+    /** Which cell kinds this action appears for */
+    cellKinds: CellKind[];
+    /** Restrict to specific user roles (sales-agency, manufacturer, buyer) */
+    roleVisibility?: string[];
+    /** Only show when order status matches one of these */
+    statusFilter?: string[];
+    /** When cellKind is 'entityName', restrict to these entity types */
+    entityTypes?: Array<'customer' | 'manufacturer' | 'salesperson'>;
+    /** Restrict to specific table types (e.g., 'items', 'leaderboard') */
+    tableTypes?: string[];
+    /** Restrict to specific field names within a cell kind (e.g., 'sold', 'revenue') */
+    fields?: string[];
+    /** Route key for navigation actions */
+    routeKey?: string;
+    /** Param key mapping entity ID to route param */
+    paramKey?: string;
+    /** Tab type for create-tab actions */
+    tabType?: string;
+    /** Filter key for filter/create-tab actions */
+    filterKey?: string;
+    /** Graph type for graph actions */
+    graphType?: string;
+    /** Quantity metric for graph actions (# or $) */
+    quant?: string;
+    /** Override timeframe for graph actions (QTD, YTD, SEASONAL) */
+    timeframeOverride?: string;
+    /** Dynamic disabled check based on row data */
+    disabled?: (row: Record<string, unknown>) => boolean;
+    /** Tooltip shown when action is disabled */
+    disabledTooltip?: string;
+    /** Subtitle/hint text (e.g., "Opens in RepTime") */
+    subtitle?: string;
+    /** Dynamic label function based on row and entity context */
+    labelFn?: (row: Record<string, unknown>, entityType?: string) => string;
+}
+/**
+ * Context provided to menu action handlers.
+ * Contains all data needed to execute an action (create tab, graph, navigate).
+ */
+export interface MenuActionContext {
+    /** The data row that triggered the context menu */
+    row: Record<string, unknown>;
+    /** Entity type (singular: customer, manufacturer, salesperson) */
+    entityType?: string;
+    /** Entity ID from the row */
+    entityId?: string;
+    /** Entity display name from the row */
+    entityName?: string;
+    /** Current timeframe for the table/context */
+    timeFrame?: unknown;
+    /** Current user type (sales-agency, manufacturer, buyer) */
+    userType?: string;
+    /** Current table type */
+    tableType?: string;
+    /** Clicked field name */
+    field?: string;
+}
+/**
+ * Options passed to getMenuActions for filtering the action registry.
+ */
+export interface MenuFilterOptions {
+    /** Entity type (singular) */
+    entityType?: 'customer' | 'manufacturer' | 'salesperson';
+    /** User role */
+    userType?: string;
+    /** Current order status (for status-aware actions) */
+    orderStatus?: string;
+    /** Table type context (items, orders, leaderboard) */
+    tableType?: string;
+    /** Clicked field name (sold, revenue, orders, total) */
+    field?: string;
+}
+/**
+ * Props for the glossui UnifiedContextMenu component.
+ * Receives pre-filtered actions from the container.
+ * Supports dual-mode: dispatch prop OR individual callbacks.
+ */
+export interface UnifiedContextMenuProps {
+    /** Anchor element for menu positioning */
+    anchorEl: HTMLElement | null;
+    /** Whether menu is open */
+    open: boolean;
+    /** Close handler */
+    onClose: () => void;
+    /** Pre-filtered actions from container */
+    actions: UnifiedMenuAction[];
+    /** The data row that triggered the menu */
+    row: Record<string, unknown>;
+    /** Entity type context */
+    entityType?: string;
+    /** Dashboard dispatch function (if available) */
+    dispatch?: (action: Record<string, unknown>) => void;
+    /** Callback for tab creation actions */
+    onAddTab?: (tab: Record<string, unknown>) => void;
+    /** Callback for filter actions */
+    onFilter?: (entityType: string, entityId: string, entityName: string) => void;
+    /** Callback for viz/graph update actions */
+    onUpdateViz?: (config: Record<string, unknown>) => void;
+    /** Generic action click handler (receives action + full context) */
+    onActionClick?: (action: UnifiedMenuAction, context: MenuActionContext) => void;
+}

package/lib/dashboard/index.d.ts

@@ -0,0 +1,10 @@
+export * from './FilterChip';
+export * from './TabGroup';
+export * from './Skeleton';
+export * from './MetricCard';
+export * from './UnifiedBreakdownTable';
+export * from './ChartControlBar';
+export * from './UnifiedContextMenu';
+export * from './TimeFrame';
+export * from './MetricCardGrid';
+export * from './TabbedDataView';

package/lib/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useFocusTrap, type UseFocusTrapOptions } from './useFocusTrap';
+export { useFocusReturn, type UseFocusReturnOptions } from './useFocusReturn';
+export { useArrowNavigation, type UseArrowNavigationOptions, type UseArrowNavigationReturn, } from './useArrowNavigation';