@memobit/libs 1.0.2 → 1.0.3

package/dist/src/components/ControlPanel/ControlPanel.types.d.ts

@@ -0,0 +1,206 @@
+import { ReactNode } from 'react';
+import { ButtonProps } from '../Button';
+import { DropdownOption } from '../Dropdown';
+import { IconName } from '../Icon';
+export interface ControlPanelHeader {
+    icon?: IconName;
+    emoji?: string;
+    svg?: ReactNode;
+    appName?: string;
+    siteName?: string;
+    heading?: string;
+    onClick?: () => void;
+}
+export interface ControlPanelActionConfirmButton {
+    text?: string;
+    icon?: IconName;
+    variant?: ButtonProps['variant'];
+}
+export interface ControlPanelActionConfirm {
+    /** Short heading shown above the message. Defaults to the action's label. */
+    title?: string;
+    /** Optional explanatory body. */
+    message?: string;
+    /** Optional leading icon next to the title. */
+    icon?: IconName;
+    /** Popover placement relative to the action button. Defaults to 'right'
+     *  so the popover floats out into the main content area instead of
+     *  obscuring the rest of the sidebar. */
+    placement?: 'top' | 'bottom' | 'left' | 'right' | 'auto';
+    /** Overrides for the confirm (primary) button label/icon/variant.
+     *  The click handler always comes from the parent `ControlPanelAction.onClick`. */
+    confirm?: ControlPanelActionConfirmButton;
+    /** Overrides for the cancel (secondary) button. */
+    cancel?: ControlPanelActionConfirmButton;
+}
+export interface ControlPanelAction {
+    id: string;
+    label: string;
+    onClick?: ButtonProps['onClick'];
+    icon?: IconName;
+    suffixIcon?: string;
+    variant?: ButtonProps['variant'];
+    size?: ButtonProps['size'];
+    fullWidth?: boolean;
+    disabled?: boolean;
+    /** When set, clicking the action opens a small confirmation popover anchored
+     *  to the button instead of firing onClick directly. onClick fires only after
+     *  the user picks the confirm option inside the popover. */
+    confirm?: ControlPanelActionConfirm;
+}
+export interface ControlPanelFilterOption extends DropdownOption {
+    color?: string;
+    count?: number | string;
+    /** Optional image URL rendered as a small round avatar before the option label.
+     *  Used by the `chips` filter to show a face crop / product thumbnail / etc. */
+    imageUrl?: string;
+}
+export interface ControlPanelDateRangePreset {
+    label: string;
+    days: number;
+}
+export type ControlPanelFilterType = 'radio' | 'chips' | 'dropdown' | 'text' | 'number' | 'rating' | 'range' | 'date-range' | 'search' | 'date' | 'checkbox';
+export type ControlPanelFilterValue = string | number | boolean | string[] | number[] | null;
+export interface ControlPanelFilter {
+    id: string;
+    label: string;
+    icon?: IconName;
+    type: ControlPanelFilterType;
+    options?: ControlPanelFilterOption[];
+    value?: ControlPanelFilterValue;
+    count?: number | string;
+    placeholder?: string;
+    multiple?: boolean;
+    searchable?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    maxRate?: number;
+    ratingIcon?: 'star' | 'bullet';
+    ratingVariant?: 'success' | 'info' | 'warning' | 'danger';
+    minDate?: string;
+    maxDate?: string;
+    presets?: ControlPanelDateRangePreset[];
+    isActive?: boolean;
+    /** Optional cap on the rendered options area. When set, the chip/option
+     *  list becomes vertically scrollable past this height. Number is taken as
+     *  px; string is passed through (`'40vh'`, `'320px'`, etc.). Omit to let
+     *  the list expand freely. Honored by the `chips` filter today. */
+    maxHeight?: string | number;
+}
+export interface ControlPanelFilterChangeEvent {
+    filterId: string;
+    type: ControlPanelFilterType;
+    value: ControlPanelFilterValue;
+    option?: ControlPanelFilterOption | null;
+    options?: ControlPanelFilterOption[];
+}
+export interface ControlPanelClearFiltersEvent {
+    source: 'control-panel';
+}
+export interface ControlPanelOptionItem {
+    value: string | number;
+    label: string;
+    /** Optional hover tooltip describing the option. */
+    title?: string;
+}
+export type ControlPanelOption = {
+    id: string;
+    label: string;
+    type: 'checkbox';
+    value?: boolean;
+} | {
+    id: string;
+    label?: string;
+    type: 'radio';
+    value?: string | number;
+    options: ControlPanelOptionItem[];
+} | {
+    id: string;
+    label?: string;
+    type: 'chips';
+    value: Array<string | number>;
+    options: ControlPanelOptionItem[];
+};
+export interface ControlPanelOptionGroup {
+    id?: string;
+    label?: string;
+    options: ControlPanelOption[];
+}
+export interface ControlPanelOptionChangeEvent {
+    optionId: string;
+    value: boolean | string | number | Array<string | number>;
+}
+export type ControlPanelViewMode = 'table' | 'cards' | 'gallery';
+export interface ControlPanelViewToggleOption {
+    value: ControlPanelViewMode;
+    label: string;
+    icon: IconName;
+}
+export interface ControlPanelViewToggleConfig {
+    value: string;
+    showGallery?: boolean;
+    /** Override the default Grid/Table/Gallery buttons with custom labels and icons. */
+    options?: ControlPanelViewToggleOption[];
+    onChange: (value: ControlPanelViewMode) => void;
+}
+export interface ControlPanelGroupByConfig {
+    value: string | null;
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    onChange: (value: string | null) => void;
+}
+export interface ControlPanelVisibleColumnsConfig {
+    value: string[];
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    onChange: (next: string[]) => void;
+}
+export interface ControlPanelNavItemBadge {
+    count: number;
+    variant: 'danger' | 'warning';
+}
+export interface ControlPanelNavItem {
+    id: string;
+    label: string;
+    isActive: boolean;
+    /** Visually fades the item (e.g. a toggled-off entry) while keeping it clickable. */
+    dimmed?: boolean;
+    onClick?: () => void;
+    icon?: IconName;
+    color?: string;
+    count?: number | string;
+    badges?: ControlPanelNavItemBadge[];
+    children?: ControlPanelNavItem[];
+    isOpen?: boolean;
+    onOpenChange?: (isOpen: boolean, item: ControlPanelNavItem) => void;
+}
+export interface ControlPanelProps {
+    width?: string;
+    className?: string;
+    isOpen?: boolean;
+    onClose?: () => void;
+    isMobile?: boolean;
+    showOverlay?: boolean;
+    contained?: boolean;
+    /** Removes the desktop margin and border-radius so the panel sits flush against content. */
+    flush?: boolean;
+    shadow?: string;
+    header?: ControlPanelHeader;
+    navigation?: ControlPanelNavItem[];
+    actions?: ControlPanelAction[];
+    filters?: ControlPanelFilter[];
+    filtersCount?: number;
+    onFilterChange?: (event: ControlPanelFilterChangeEvent) => void;
+    onClearFilters?: (event: ControlPanelClearFiltersEvent) => void;
+    options?: ControlPanelOption[] | ControlPanelOptionGroup[];
+    onOptionChange?: (event: ControlPanelOptionChangeEvent) => void;
+    viewToggle?: ControlPanelViewToggleConfig;
+    groupBy?: ControlPanelGroupByConfig;
+    visibleColumns?: ControlPanelVisibleColumnsConfig;
+}
+export declare const DEFAULT_DATE_RANGE_PRESETS: ControlPanelDateRangePreset[];

package/dist/src/components/ControlPanel/ControlPanelContext.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+interface ControlPanelContextValue {
+    isMobile: boolean;
+    isOpen: boolean;
+    toggle: () => void;
+    open: () => void;
+    close: () => void;
+}
+interface ControlPanelProviderProps {
+    children: React.ReactNode;
+}
+export declare const useControlPanelContext: () => ControlPanelContextValue | null;
+export declare const useControlPanel: () => ControlPanelContextValue;
+export declare const ControlPanelProvider: React.FC<ControlPanelProviderProps>;
+export {};

package/dist/src/components/ControlPanel/ControlPanelFilter.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+import { ControlPanelFilter, ControlPanelFilterChangeEvent } from './ControlPanel.types';
+interface ControlPanelFilterItemProps {
+    filter: ControlPanelFilter;
+    onChange: (event: ControlPanelFilterChangeEvent) => void;
+}
+export declare const ControlPanelFilterItem: React.FC<ControlPanelFilterItemProps>;
+export {};

package/dist/src/components/ControlPanel/ControlPanelNav.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { ControlPanelNavItem } from './ControlPanel.types';
+interface ControlPanelNavProps {
+    navigation: ControlPanelNavItem[];
+}
+export declare const ControlPanelNav: React.FC<ControlPanelNavProps>;
+export {};

package/dist/src/components/ControlPanel/ControlPanelOptions.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { ControlPanelGroupByConfig, ControlPanelOptionChangeEvent, ControlPanelOptionGroup, ControlPanelViewToggleConfig, ControlPanelVisibleColumnsConfig } from './ControlPanel.types';
+interface ControlPanelOptionsProps {
+    normalizedOptionGroups: ControlPanelOptionGroup[];
+    onOptionChange?: (event: ControlPanelOptionChangeEvent) => void;
+    viewToggle?: ControlPanelViewToggleConfig;
+    groupBy?: ControlPanelGroupByConfig;
+    visibleColumns?: ControlPanelVisibleColumnsConfig;
+}
+export declare const ControlPanelOptions: React.FC<ControlPanelOptionsProps>;
+export {};

package/dist/src/components/ControlPanel/index.d.ts

@@ -0,0 +1,2 @@
+export { ControlPanelProvider, useControlPanel, useControlPanelContext } from './ControlPanelContext';
+export { ControlPanel, type ControlPanelProps, type ControlPanelHeader, type ControlPanelNavItem, type ControlPanelNavItemBadge, type ControlPanelAction, type ControlPanelFilter, type ControlPanelFilterOption, type ControlPanelFilterType, type ControlPanelFilterValue, type ControlPanelFilterChangeEvent, type ControlPanelClearFiltersEvent, type ControlPanelOption, type ControlPanelOptionGroup, type ControlPanelOptionItem, type ControlPanelOptionChangeEvent, type ControlPanelViewMode, type ControlPanelViewToggleConfig, type ControlPanelViewToggleOption, type ControlPanelGroupByConfig, type ControlPanelVisibleColumnsConfig, } from './ControlPanel';

package/dist/src/components/CopyButton/CopyButton.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { ButtonVariant } from '../Button';
+export type CopyButtonStatus = 'idle' | 'copied' | 'error';
+export interface CopyButtonProps {
+    children?: React.ReactNode;
+    className?: string;
+    copiedLabel?: string;
+    disabled?: boolean;
+    errorLabel?: string;
+    iconOnly?: boolean;
+    label?: string;
+    onCopy?: (value: string) => void;
+    onError?: (error: unknown) => void;
+    resetDelay?: number;
+    size?: 'small' | 'medium' | 'large';
+    title?: string;
+    value: string;
+    variant?: ButtonVariant;
+}
+export declare const CopyButton: React.FC<CopyButtonProps>;

package/dist/src/components/CopyButton/index.d.ts

@@ -0,0 +1 @@
+export { CopyButton, type CopyButtonProps, type CopyButtonStatus } from './CopyButton';

package/dist/src/components/CountryWithFlag/CountryWithFlag.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface CountryWithFlagProps {
+    code: string;
+    label?: string;
+    size?: 'xxs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+    className?: string;
+}
+export declare const CountryWithFlag: React.FC<CountryWithFlagProps>;
+export {};

package/dist/src/components/CountryWithFlag/index.d.ts

@@ -0,0 +1 @@
+export { CountryWithFlag } from './CountryWithFlag';

package/dist/src/components/DataView/DataView.CardView.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+import { DataViewCardConfig, DataViewColumn, DataViewEmptyConfig, DataViewGroup, DataViewGroupKey, DataViewTimelineConfig } from './DataView.types';
+export declare const DEFAULT_PAGE_SIZES: number[];
+export declare const getColumnLabel: <T>(column: DataViewColumn<T>) => string;
+export declare const renderColumnLabel: <T>(column: DataViewColumn<T>) => import("react/jsx-runtime").JSX.Element;
+export declare const renderCellContent: <T>(column: DataViewColumn<T>, row: T) => string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+export interface CardViewProps<T> {
+    data: T[];
+    columns: DataViewColumn<T>[];
+    rowKey: (row: T, index: number) => string | number;
+    card?: DataViewCardConfig<T>;
+    actions?: (row: T) => React.ReactNode;
+    timeline?: DataViewTimelineConfig<T>;
+    onRowClick?: (row: T) => void;
+    rowHref?: (row: T) => string | undefined;
+    rowClassName?: (row: T) => string;
+    empty?: DataViewEmptyConfig;
+    selectable?: boolean;
+    selectedIds?: Array<string | number>;
+    onToggleSelect?: (rowId: string | number, checked: boolean) => void;
+    cardMaxWidth?: number | string;
+    isMobile?: boolean;
+    groups?: DataViewGroup<T>[];
+    showGroupCount?: boolean;
+    collapsible?: boolean;
+    collapsedGroups?: Set<DataViewGroupKey>;
+    onToggleGroup?: (key: DataViewGroupKey) => void;
+}
+export declare function CardView<T>({ data, columns, rowKey, card, actions, timeline, onRowClick, rowHref, rowClassName, empty, selectable, selectedIds, onToggleSelect, cardMaxWidth, isMobile, groups, showGroupCount, collapsible, collapsedGroups, onToggleGroup, }: CardViewProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/DataView/DataView.MiniSort.d.ts

@@ -0,0 +1,10 @@
+import { DataViewColumn, DataViewMiniSortConfig, SortDirection } from './DataView.types';
+interface DataViewMiniSortProps<T> {
+    columns: DataViewColumn<T>[];
+    config?: DataViewMiniSortConfig;
+    sortDirection: SortDirection;
+    sortKey: string | null;
+    onSort: (column: string, direction: SortDirection) => void;
+}
+export declare function DataViewMiniSort<T>({ columns, config, sortDirection, sortKey, onSort }: DataViewMiniSortProps<T>): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/src/components/DataView/DataView.d.ts

@@ -0,0 +1,2 @@
+import { DataViewProps } from './DataView.types';
+export declare function DataView<T>({ columns, data, rowKey, selectable, onSelectionChange, selectedIds: controlledSelectedIds, pageSizeOptions, initialPageSize, showPageSize, card, actions, actionsWidth, timeline, onRowClick, rowHref, rowClassName, empty, initialSortKey, initialSortDirection, sortKey: controlledSortKey, sortDirection: controlledSortDirection, onSortChange, miniSort, showCardSortControls, desktopView, cardMaxWidth, className, onPageChange, onPageSizeChange, currentPage: controlledCurrentPage, totalItems: controlledTotalItems, group, showResultsCount, totalCount, itemNoun, }: DataViewProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/DataView/DataView.types.d.ts

@@ -0,0 +1,133 @@
+import { default as React } from 'react';
+import { ExternalButtonConfig } from '../Button';
+import { IconName } from '../Icon';
+export type SortDirection = 'asc' | 'desc';
+export type DataViewDisplayMode = 'table' | 'cards';
+export interface DataViewColumn<T> {
+    key: string;
+    header: React.ReactNode;
+    icon?: IconName;
+    /** Optional per-row icon rendered before the cell value. */
+    cellIcon?: (row: T) => IconName | undefined;
+    /** Optional filter input rendered below the column header (table) or in the filter bar (card) */
+    filter?: React.ReactNode;
+    accessor?: (row: T) => React.ReactNode;
+    sortAccessor?: (row: T) => string | number;
+    sortable?: boolean;
+    width?: number;
+    minWidth?: number;
+    hideInCard?: boolean;
+    hideInTable?: boolean;
+    /** Hide this column only on mobile breakpoint (not when cards are used on desktop). */
+    hideInMobile?: boolean;
+}
+export interface DataViewCardConfig<T> {
+    icon?: (row: T) => IconName | undefined;
+    /** Renders above the card header. Use for thumbnails / hero images. */
+    media?: (row: T) => React.ReactNode;
+    title: (row: T) => React.ReactNode;
+    subtitle?: (row: T) => React.ReactNode;
+    badges?: (row: T) => React.ReactNode;
+}
+export interface DataViewTimelineConfig<T> {
+    dateAccessor: (row: T) => string;
+    idAccessor: (row: T) => string | number;
+    granularity?: 'day' | 'month';
+}
+export interface DataViewEmptyConfig {
+    title: string;
+    description?: string;
+    icon?: React.ReactNode;
+    primary?: ExternalButtonConfig;
+    secondary?: ExternalButtonConfig;
+}
+export interface DataViewMiniSortItem {
+    column: string;
+    direction?: SortDirection;
+    icon?: IconName;
+    label?: React.ReactNode;
+}
+export interface DataViewMiniSortConfig {
+    align?: 'left' | 'center' | 'right';
+    columns?: DataViewMiniSortItem[];
+    /** Alias for `columns`, supported for concise configs like `{ column: [...] }`. */
+    column?: DataViewMiniSortItem[];
+}
+export type DataViewGroupKey = string | number | null;
+export interface DataViewGroup<T> {
+    key: DataViewGroupKey;
+    label: React.ReactNode;
+    items: T[];
+    totalCount: number;
+}
+export interface DataViewGroupConfig<T> {
+    /** Extract group key from row. Return null for ungrouped/uncategorized items. */
+    groupBy: (row: T) => DataViewGroupKey;
+    /** Display label for a group header. */
+    groupLabel: (groupKey: DataViewGroupKey) => React.ReactNode;
+    /** Optional comparator to order groups; default keeps first-encountered order with null last. */
+    sortGroups?: (a: DataViewGroup<T>, b: DataViewGroup<T>) => number;
+    /** Show item count badge next to group label. Default: true. */
+    showCount?: boolean;
+    /** Allow users to collapse/expand individual groups by clicking the header. */
+    collapsible?: boolean;
+}
+export interface DataViewProps<T> {
+    columns: DataViewColumn<T>[];
+    data: T[];
+    rowKey?: (row: T, index: number) => string | number;
+    selectable?: boolean;
+    onSelectionChange?: (rows: T[]) => void;
+    /** Controlled selection. When provided, DataView reflects this array of row keys instead of its internal state. */
+    selectedIds?: Array<string | number>;
+    pageSizeOptions?: number[];
+    initialPageSize?: number;
+    showPageSize?: boolean;
+    card?: DataViewCardConfig<T>;
+    actions?: (row: T) => React.ReactNode;
+    actionsWidth?: number;
+    timeline?: DataViewTimelineConfig<T>;
+    onRowClick?: (row: T) => void;
+    /** When provided, each row/card renders as a real link so middle-click,
+     *  Ctrl/Cmd-click, and the browser's "Open in new tab" all work natively.
+     *  Plain left-click still calls `onRowClick` (or follows the href if no
+     *  click handler is set). Return `undefined` to opt a specific row out. */
+    rowHref?: (row: T) => string | undefined;
+    rowClassName?: (row: T) => string;
+    empty?: DataViewEmptyConfig;
+    /** Initial sorted column key for uncontrolled sorting. */
+    initialSortKey?: string | null;
+    /** Initial sort direction for uncontrolled sorting. */
+    initialSortDirection?: SortDirection;
+    /** Controlled sorted column key. */
+    sortKey?: string | null;
+    /** Controlled sort direction. */
+    sortDirection?: SortDirection;
+    onSortChange?: (sort: {
+        key: string | null;
+        direction: SortDirection;
+    }) => void;
+    /** Optional desktop quick-sort nav. Hidden by default. */
+    miniSort?: DataViewMiniSortConfig;
+    /** Show the built-in sort controls above cards. */
+    showCardSortControls?: boolean;
+    /** Selected layout mode. */
+    desktopView?: DataViewDisplayMode;
+    /** Maximum width for each card. Number values are treated as px. */
+    cardMaxWidth?: number | string;
+    className?: string;
+    onPageChange?: (page: number) => void;
+    onPageSizeChange?: (pageSize: number) => void;
+    /** Controlled current page (1-indexed). When provided, DataView uses this instead of its internal state. */
+    currentPage?: number;
+    /** When set, DataView assumes `data` is already a server-paged slice and uses this for the pagination total. */
+    totalItems?: number;
+    /** Group rows by a key. Rows render in group sections within the paginated slice. */
+    group?: DataViewGroupConfig<T>;
+    /** Display the "Showing X-Y of Z" results-count label above the data. Default: true. */
+    showResultsCount?: boolean;
+    /** Unfiltered total used to render the "filtered (... total)" form when smaller than this value. Defaults to `data.length`. */
+    totalCount?: number;
+    /** Noun appended to the results-count label, e.g. "books". */
+    itemNoun?: string;
+}

package/dist/src/components/DataView/index.d.ts

@@ -0,0 +1,2 @@
+export { DataView } from './DataView';
+export type { DataViewCardConfig, DataViewColumn, DataViewDisplayMode, DataViewEmptyConfig, DataViewGroup, DataViewGroupConfig, DataViewGroupKey, DataViewMiniSortConfig, DataViewMiniSortItem, DataViewProps, DataViewTimelineConfig, SortDirection, } from './DataView.types';

package/dist/src/components/DatePicker/DatePicker.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { CalendarProps, CalendarDateRange } from '../Calendar';
+export interface DatePickerProps extends Omit<CalendarProps, 'onChange' | 'value'> {
+    value?: Date | CalendarDateRange | Date[];
+    onChange?: (value: Date | CalendarDateRange | Date[] | undefined) => void;
+    withTime?: boolean;
+    timeFormat?: '12h' | '24h';
+    withSeconds?: boolean;
+    dateFormat?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    autoClose?: boolean;
+    alwaysOpen?: boolean;
+}
+export declare const DatePicker: React.FC<DatePickerProps>;

package/dist/src/components/DatePicker/index.d.ts

@@ -0,0 +1,2 @@
+export { DatePicker } from './DatePicker';
+export type { DatePickerProps } from './DatePicker';

package/dist/src/components/DateRangePicker/DateRangePicker.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+interface DateRange {
+    start?: string;
+    end?: string;
+}
+export interface DateRangePreset {
+    label: string;
+    days: number;
+}
+export interface DateRangePickerProps {
+    label?: string;
+    value?: DateRange;
+    onChange?: (range: DateRange) => void;
+    min?: string;
+    max?: string;
+    alwaysOpen?: boolean;
+    autoClose?: boolean;
+    presets?: DateRangePreset[];
+}
+export declare const DateRangePicker: React.FC<DateRangePickerProps>;
+export {};

package/dist/src/components/DateRangePicker/index.d.ts

@@ -0,0 +1 @@
+export { DateRangePicker, type DateRangePickerProps, type DateRangePreset } from './DateRangePicker';

package/dist/src/components/DiffViewer/DiffViewer.d.ts

@@ -0,0 +1,15 @@
+export type DiffMode = 'split' | 'inline';
+export type DiffType = 'text' | 'code';
+export type DiffLang = 'javascript' | 'typescript' | 'jsx' | 'tsx' | 'css' | 'scss' | 'html' | 'json' | 'python' | 'bash' | 'plaintext';
+interface DiffViewerProps {
+    oldValue: string;
+    newValue: string;
+    mode?: DiffMode;
+    type?: DiffType;
+    language?: DiffLang;
+    oldTitle?: string;
+    newTitle?: string;
+    showLineNumbers?: boolean;
+}
+export declare const DiffViewer: ({ oldValue, newValue, mode, type, oldTitle, newTitle, showLineNumbers, }: DiffViewerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/DiffViewer/index.d.ts

@@ -0,0 +1,2 @@
+export { DiffViewer } from './DiffViewer';
+export type { DiffMode, DiffType, DiffLang } from './DiffViewer';

package/dist/src/components/Drawer/Drawer.d.ts

@@ -0,0 +1,45 @@
+import { default as React } from 'react';
+import { ButtonProps, ExternalButtonConfig } from '../Button';
+import { IconName } from '../Icon';
+export type DrawerPosition = 'left' | 'right';
+export interface DrawerHeaderAction {
+    id: string;
+    label?: string;
+    icon?: IconName;
+    emojiIcon?: string;
+    title?: string;
+    variant?: ButtonProps['variant'];
+    size?: ButtonProps['size'];
+    disabled?: boolean;
+    onClick?: ButtonProps['onClick'];
+}
+export interface DrawerProps {
+    isOpen: boolean;
+    onClose: () => void;
+    position?: DrawerPosition;
+    /** CSS width for the drawer. Accepts any CSS length or expression. */
+    width?: string;
+    /** Optional CSS max-width for responsive drawers. */
+    maxWidth?: string | number;
+    margin?: string | number;
+    borderRadius?: string | number;
+    shadow?: string;
+    children: React.ReactNode;
+    title?: string;
+    icon?: IconName;
+    className?: string;
+    showOverlay?: boolean;
+    /** When false, the drawer does not lock body scroll — use for persistent side panels. */
+    lockScroll?: boolean;
+    /** When true, the header close (×) button is not rendered — use for persistent panels. */
+    hideClose?: boolean;
+    actions?: DrawerHeaderAction[];
+    /** Optional back action rendered on the LEFT side of the header — typically a navigation affordance. */
+    onBack?: () => void;
+    /** Tooltip for the back button. */
+    backLabel?: string;
+    primary?: ExternalButtonConfig;
+    secondary?: ExternalButtonConfig;
+    footer?: React.ReactNode;
+}
+export declare const Drawer: React.FC<DrawerProps>;

package/dist/src/components/Drawer/index.d.ts

@@ -0,0 +1,2 @@
+export { Drawer } from './Drawer';
+export type { DrawerHeaderAction, DrawerPosition, DrawerProps } from './Drawer';

package/dist/src/components/Dropdown/Dropdown.d.ts

@@ -0,0 +1,37 @@
+import { default as React } from 'react';
+import { IconName } from '../Icon';
+export interface DropdownOption {
+    className?: string;
+    details?: React.ReactNode;
+    icon?: IconName;
+    label: string;
+    /** Custom node rendered before the icon/label (e.g. an avatar). */
+    prefix?: React.ReactNode;
+    suffixIcon?: IconName;
+    value: string | number;
+}
+export type DropdownSelectedCountDisplay = 'inline' | 'floating' | 'none';
+export interface DropdownProps {
+    allowCustomValue?: boolean;
+    autofocus?: boolean;
+    className?: string;
+    disabled?: boolean;
+    error?: string;
+    highlighted?: boolean;
+    id?: string;
+    label?: string;
+    multiple?: boolean;
+    name: string;
+    onChange: (option: DropdownOption | DropdownOption[] | null, name: string) => void;
+    onSearchChange?: (search: string) => void;
+    options: DropdownOption[];
+    placeholder?: string;
+    searchable?: boolean;
+    searchValue?: string;
+    selectedCountDisplay?: DropdownSelectedCountDisplay;
+    success?: string;
+    usePortal?: boolean;
+    value?: number | number[] | string | string[] | null;
+    valueAsChip?: boolean;
+}
+export declare const Dropdown: React.FC<DropdownProps>;

package/dist/src/components/Dropdown/index.d.ts

@@ -0,0 +1 @@
+export { Dropdown, type DropdownOption, type DropdownSelectedCountDisplay } from './Dropdown';

package/dist/src/components/EmojiPicker/EmojiPicker.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+export interface EmojiPickerProps {
+    value?: string;
+    onChange?: (emoji: string) => void;
+}
+export declare const EmojiPicker: React.FC<EmojiPickerProps>;

package/dist/src/components/EmojiPicker/emojiKeywords/activities.d.ts

@@ -0,0 +1 @@
+export declare const activitiesKeywords: Record<string, string[]>;

package/dist/src/components/EmojiPicker/emojiKeywords/animals.d.ts

@@ -0,0 +1 @@
+export declare const animalsKeywords: Record<string, string[]>;

package/dist/src/components/EmojiPicker/emojiKeywords/food.d.ts

@@ -0,0 +1 @@
+export declare const foodKeywords: Record<string, string[]>;

package/dist/src/components/EmojiPicker/emojiKeywords/index.d.ts

@@ -0,0 +1 @@
+export declare const EMOJI_KEYWORDS: Record<string, string[]>;