@archbase/components 3.0.25 → 4.0.1

package/dist/list/ArchbaseTreeList.d.ts

@@ -0,0 +1,76 @@
+import { default as React, ReactNode } from 'react';
+import { MantineColor, MantineSize } from '@mantine/core';
+import { ArchbaseDataSource } from '@archbase/data';
+export interface ArchbaseTreeListColumn<T> {
+    /** ID da coluna */
+    id: string;
+    /** Header da coluna */
+    header: string;
+    /** Accessor do campo */
+    accessor: keyof T | ((row: T) => any);
+    /** Largura da coluna */
+    width?: number | string;
+    /** Alinhamento */
+    align?: 'left' | 'center' | 'right';
+    /** Renderizador customizado */
+    render?: (value: any, row: T, index: number) => ReactNode;
+    /** Se é a coluna de árvore (com indent e expand) */
+    isTreeColumn?: boolean;
+}
+export interface ArchbaseTreeListProps<T extends object, ID> {
+    /** Dados da árvore */
+    data?: T[];
+    /** Fonte de dados */
+    dataSource?: ArchbaseDataSource<T, ID>;
+    /** Colunas */
+    columns: ArchbaseTreeListColumn<T>[];
+    /** Função para obter filhos de um item */
+    getSubRows?: (row: T) => T[] | undefined;
+    /** Campo que contém os filhos */
+    childrenField?: string;
+    /** Campo de ID único */
+    idField?: keyof T;
+    /** IDs expandidos (controlado) */
+    expandedIds?: Set<any>;
+    /** IDs expandidos por padrão */
+    defaultExpandedIds?: Set<any>;
+    /** Se deve expandir todos por padrão */
+    defaultExpandAll?: boolean;
+    /** Callback ao expandir/colapsar */
+    onExpandChange?: (expandedIds: Set<any>) => void;
+    /** Profundidade máxima */
+    maxDepth?: number;
+    /** Indentação por nível em pixels */
+    indentSize?: number;
+    /** Se deve mostrar linhas de conexão */
+    showLines?: boolean;
+    /** Se permite seleção */
+    selectable?: boolean;
+    /** Modo de seleção */
+    selectionMode?: 'single' | 'multiple';
+    /** IDs selecionados */
+    selectedIds?: Set<any>;
+    /** Callback ao selecionar */
+    onSelectionChange?: (selectedIds: Set<any>) => void;
+    /** Cor de destaque */
+    highlightColor?: MantineColor;
+    /** Altura da linha */
+    rowHeight?: number;
+    /** Altura máxima (scroll) */
+    maxHeight?: number | string;
+    /** Tamanho */
+    size?: MantineSize;
+    /** Se deve ter bordas */
+    withBorder?: boolean;
+    /** Se deve ter listras */
+    striped?: boolean;
+    /** Se deve destacar no hover */
+    highlightOnHover?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseTreeList: <T extends object = any, ID = string>(props: ArchbaseTreeListProps<T, ID> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => React.ReactElement;

package/dist/list/index.d.ts

@@ -6,3 +6,5 @@ export type { ArchbaseListItemProps } from './ArchbaseListItem';
 export type { ArchbaseListContextValue } from './ArchbaseList.context';
 export { ArchbaseListContext };
 export * from './treeview';
+export { ArchbaseTreeList } from './ArchbaseTreeList';
+export type { ArchbaseTreeListProps, ArchbaseTreeListColumn } from './ArchbaseTreeList';

package/dist/navigation/ArchbaseActionSheet.d.ts

@@ -0,0 +1,70 @@
+import { default as React, ReactNode } from 'react';
+import { MantineColor, MantineSize } from '@mantine/core';
+export interface ArchbaseActionSheetItem {
+    /** Chave única */
+    key: string;
+    /** Tipo do item */
+    type?: 'item' | 'divider';
+    /** Label do item */
+    label?: string;
+    /** Descrição */
+    description?: string;
+    /** Ícone */
+    icon?: ReactNode;
+    /** Cor */
+    color?: MantineColor;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Callback ao clicar */
+    onClick?: () => void;
+}
+export interface ArchbaseActionSheetProps {
+    /** Itens do action sheet */
+    items: ArchbaseActionSheetItem[];
+    /** Se está aberto */
+    opened: boolean;
+    /** Callback ao fechar */
+    onClose: () => void;
+    /** Título */
+    title?: string;
+    /** Descrição */
+    description?: string;
+    /** Label do botão cancelar */
+    cancelLabel?: string;
+    /** Se deve mostrar botão cancelar */
+    showCancel?: boolean;
+    /** Breakpoint para mudar de drawer para menu */
+    breakpoint?: string;
+    /** Posição do menu no desktop */
+    menuPosition?: 'bottom' | 'top' | 'left' | 'right';
+    /** Elemento alvo do menu (desktop) */
+    target?: ReactNode;
+    /** Tamanho */
+    size?: MantineSize;
+    /** Raio das bordas do drawer */
+    radius?: MantineSize;
+    /** Se deve ter overlay */
+    withOverlay?: boolean;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseActionSheet: React.ForwardRefExoticComponent<ArchbaseActionSheetProps & React.RefAttributes<HTMLDivElement>>;
+export interface UseArchbaseActionSheetOptions {
+    items: ArchbaseActionSheetItem[];
+    title?: string;
+    description?: string;
+    cancelLabel?: string;
+    showCancel?: boolean;
+}
+export interface UseArchbaseActionSheetReturn {
+    opened: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    ActionSheet: React.FC<{
+        target?: ReactNode;
+    }>;
+}
+export declare function useArchbaseActionSheet(options: UseArchbaseActionSheetOptions): UseArchbaseActionSheetReturn;

package/dist/navigation/ArchbaseAppBar.d.ts

@@ -0,0 +1,63 @@
+import { default as React, ReactNode } from 'react';
+import { MantineColor, MantineSize } from '@mantine/core';
+export interface ArchbaseAppBarAction {
+    /** Chave única */
+    key: string;
+    /** Ícone */
+    icon: ReactNode;
+    /** Label (para menu mobile) */
+    label: string;
+    /** Callback ao clicar */
+    onClick: () => void;
+    /** Cor */
+    color?: MantineColor;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Se deve esconder no mobile */
+    hideOnMobile?: boolean;
+    /** Se deve mostrar sempre (não ir para menu) */
+    alwaysVisible?: boolean;
+}
+export interface ArchbaseAppBarProps {
+    /** Seção esquerda (logo, back button, menu) */
+    leftSection?: ReactNode;
+    /** Seção central (título, busca) */
+    centerSection?: ReactNode;
+    /** Seção direita (ações, avatar) */
+    rightSection?: ReactNode;
+    /** Ações (alternativa ao rightSection) */
+    actions?: ArchbaseAppBarAction[];
+    /** Título */
+    title?: string;
+    /** Subtítulo */
+    subtitle?: string;
+    /** Altura */
+    height?: number;
+    /** Cor de fundo */
+    backgroundColor?: string;
+    /** Cor do texto */
+    textColor?: MantineColor;
+    /** Se deve ter sombra */
+    withShadow?: boolean;
+    /** Se deve ter borda inferior */
+    withBorder?: boolean;
+    /** Se está fixo no topo */
+    fixed?: boolean;
+    /** Z-index quando fixo */
+    zIndex?: number;
+    /** Breakpoint para modo mobile */
+    mobileBreakpoint?: string;
+    /** Callback do burger (para abrir drawer) */
+    onBurgerClick?: () => void;
+    /** Se o burger está aberto */
+    burgerOpened?: boolean;
+    /** Padding horizontal */
+    px?: MantineSize | number;
+    /** Tamanho das ações */
+    actionSize?: MantineSize;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseAppBar: React.ForwardRefExoticComponent<ArchbaseAppBarProps & React.RefAttributes<HTMLElement>>;

package/dist/navigation/ArchbaseBottomNavigation.d.ts

@@ -0,0 +1,61 @@
+import { default as React, ReactNode } from 'react';
+import { MantineColor, MantineSize } from '@mantine/core';
+export interface ArchbaseBottomNavigationItem {
+    /** Chave única */
+    key: string;
+    /** Label do item */
+    label: string;
+    /** Ícone */
+    icon: ReactNode;
+    /** Ícone quando ativo */
+    activeIcon?: ReactNode;
+    /** Badge */
+    badge?: number | string;
+    /** Cor do badge */
+    badgeColor?: MantineColor;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Link (navegação) */
+    href?: string;
+    /** Callback ao clicar */
+    onClick?: () => void;
+}
+export interface ArchbaseBottomNavigationProps {
+    /** Itens da navegação */
+    items: ArchbaseBottomNavigationItem[];
+    /** Item ativo (controlado) */
+    value?: string;
+    /** Item ativo padrão */
+    defaultValue?: string;
+    /** Callback ao mudar */
+    onChange?: (value: string) => void;
+    /** Altura da barra */
+    height?: number;
+    /** Cor de destaque */
+    activeColor?: MantineColor;
+    /** Cor inativa */
+    inactiveColor?: MantineColor;
+    /** Tamanho do ícone */
+    iconSize?: number;
+    /** Tamanho do texto */
+    labelSize?: MantineSize;
+    /** Se deve mostrar labels */
+    showLabels?: boolean;
+    /** Se deve mostrar labels apenas no ativo */
+    showActiveLabel?: boolean;
+    /** Se deve ter sombra */
+    withShadow?: boolean;
+    /** Se deve ter borda superior */
+    withBorder?: boolean;
+    /** Cor de fundo */
+    backgroundColor?: string;
+    /** Se está fixo na parte inferior */
+    fixed?: boolean;
+    /** Z-index quando fixo */
+    zIndex?: number;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseBottomNavigation: React.ForwardRefExoticComponent<ArchbaseBottomNavigationProps & React.RefAttributes<HTMLDivElement>>;

package/dist/navigation/ArchbaseContextMenu.d.ts

@@ -0,0 +1,76 @@
+import { default as React, ReactNode, MouseEvent as ReactMouseEvent } from 'react';
+import { MantineColor, MantineSize } from '@mantine/core';
+export interface ArchbaseContextMenuItem {
+    /** Chave única do item */
+    key: string;
+    /** Tipo do item */
+    type?: 'item' | 'divider' | 'label';
+    /** Label do item */
+    label?: string;
+    /** Ícone do item */
+    icon?: ReactNode;
+    /** Ícone à direita */
+    rightSection?: ReactNode;
+    /** Atalho de teclado */
+    shortcut?: string;
+    /** Cor do item */
+    color?: MantineColor;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Callback ao clicar */
+    onClick?: () => void;
+    /** Subitems (submenu) */
+    children?: ArchbaseContextMenuItem[];
+}
+export interface ArchbaseContextMenuProps {
+    /** Itens do menu */
+    items: ArchbaseContextMenuItem[];
+    /** Elemento alvo (elemento que abre o menu ao clicar com botão direito) */
+    children: ReactNode;
+    /** Se está desabilitado */
+    disabled?: boolean;
+    /** Tamanho do menu */
+    size?: MantineSize;
+    /** Largura do menu */
+    width?: number | string;
+    /** Se deve mostrar sombra */
+    shadow?: MantineSize;
+    /** Raio das bordas */
+    radius?: MantineSize;
+    /** Offset do menu */
+    offset?: number;
+    /** Classe CSS do menu */
+    menuClassName?: string;
+    /** Estilo do menu */
+    menuStyle?: React.CSSProperties;
+    /** Callback ao abrir */
+    onOpen?: () => void;
+    /** Callback ao fechar */
+    onClose?: () => void;
+    /** Classe CSS */
+    className?: string;
+    /** Estilo */
+    style?: React.CSSProperties;
+}
+export declare const ArchbaseContextMenu: React.ForwardRefExoticComponent<ArchbaseContextMenuProps & React.RefAttributes<HTMLDivElement>>;
+export interface UseArchbaseContextMenuOptions {
+    items: ArchbaseContextMenuItem[];
+    onOpen?: () => void;
+    onClose?: () => void;
+}
+export interface UseArchbaseContextMenuReturn {
+    opened: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    open: (event: ReactMouseEvent) => void;
+    close: () => void;
+    getHandlers: () => {
+        onContextMenu: (event: ReactMouseEvent) => void;
+    };
+    Menu: React.FC<{
+        children?: ReactNode;
+    }>;
+}
+export declare function useArchbaseContextMenu(options: UseArchbaseContextMenuOptions): UseArchbaseContextMenuReturn;

package/dist/navigation/ArchbaseKeyboardShortcuts.d.ts

@@ -0,0 +1,85 @@
+import { ReactNode } from 'react';
+export interface KeyboardShortcut {
+    /** Identificador único */
+    id: string;
+    /** Combinação de teclas (formato Mantine: 'mod+K', 'shift+Enter', etc.) */
+    keys: string;
+    /** Handler do atalho */
+    handler: () => void;
+    /** Descrição do atalho */
+    description: string;
+    /** Grupo do atalho */
+    group?: string;
+    /** Se o atalho está desabilitado */
+    disabled?: boolean;
+    /** Escopo (global ou específico) */
+    scope?: string;
+}
+export interface ArchbaseKeyboardShortcutsContextValue {
+    /** Atalhos registrados */
+    shortcuts: KeyboardShortcut[];
+    /** Registrar um atalho */
+    registerShortcut: (shortcut: KeyboardShortcut) => void;
+    /** Remover um atalho */
+    unregisterShortcut: (id: string) => void;
+    /** Atualizar um atalho */
+    updateShortcut: (id: string, updates: Partial<KeyboardShortcut>) => void;
+    /** Abrir modal de ajuda */
+    openHelpModal: () => void;
+    /** Fechar modal de ajuda */
+    closeHelpModal: () => void;
+    /** Se o modal está aberto */
+    isHelpModalOpen: boolean;
+}
+export interface ArchbaseKeyboardShortcutsProviderProps {
+    children: ReactNode;
+    /** Tecla para abrir o modal de ajuda (padrão: '?') */
+    helpKey?: string;
+    /** Desabilitar modal de ajuda */
+    disableHelpModal?: boolean;
+    /** Atalhos iniciais */
+    initialShortcuts?: Omit<KeyboardShortcut, 'id'>[];
+}
+export interface ArchbaseKeyboardShortcutsModalProps {
+    /** Se o modal está aberto */
+    opened: boolean;
+    /** Callback ao fechar */
+    onClose: () => void;
+    /** Atalhos a exibir */
+    shortcuts: KeyboardShortcut[];
+    /** Título do modal */
+    title?: string;
+    /** Mostrar campo de busca */
+    searchable?: boolean;
+}
+export interface UseArchbaseRegisterShortcutOptions {
+    /** Descrição do atalho */
+    description: string;
+    /** Grupo do atalho */
+    group?: string;
+    /** Se o atalho está desabilitado */
+    disabled?: boolean;
+    /** Escopo do atalho */
+    scope?: string;
+}
+export declare function useArchbaseKeyboardShortcuts(): ArchbaseKeyboardShortcutsContextValue;
+export declare function ArchbaseKeyboardShortcutsProvider({ children, helpKey, disableHelpModal, initialShortcuts, }: ArchbaseKeyboardShortcutsProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function ArchbaseKeyboardShortcutsModal({ opened, onClose, shortcuts, title, searchable, }: ArchbaseKeyboardShortcutsModalProps): import("react/jsx-runtime").JSX.Element;
+export declare function useArchbaseRegisterShortcut(keys: string, handler: () => void, options: UseArchbaseRegisterShortcutOptions): void;
+export interface UseArchbaseShortcutScopeReturn {
+    /** Registrar atalho no escopo */
+    register: (keys: string, handler: () => void, description: string, group?: string) => () => void;
+    /** Desabilitar todos os atalhos do escopo */
+    disable: () => void;
+    /** Habilitar todos os atalhos do escopo */
+    enable: () => void;
+}
+export declare function useArchbaseShortcutScope(scope: string): UseArchbaseShortcutScopeReturn;
+export interface ArchbaseShortcutHintProps {
+    /** Combinação de teclas */
+    keys: string;
+    /** Tamanho */
+    size?: 'xs' | 'sm' | 'md';
+}
+export declare function ArchbaseShortcutHint({ keys, size }: ArchbaseShortcutHintProps): import("react/jsx-runtime").JSX.Element;
+export default ArchbaseKeyboardShortcutsProvider;

package/dist/navigation/ArchbaseSpotlight.d.ts

@@ -0,0 +1,69 @@
+import { default as React, ReactNode } from 'react';
+export interface SpotlightAction {
+    /** ID único da ação */
+    id: string;
+    /** Título da ação */
+    title: string;
+    /** Descrição opcional */
+    description?: string;
+    /** Ícone */
+    icon?: ReactNode;
+    /** Grupo/categoria */
+    group?: string;
+    /** Atalho de teclado */
+    shortcut?: string[];
+    /** Callback ao selecionar */
+    onTrigger: () => void;
+    /** Desabilitado */
+    disabled?: boolean;
+    /** Palavras-chave para busca */
+    keywords?: string[];
+    /** Badge */
+    badge?: string;
+    /** Cor do badge */
+    badgeColor?: string;
+}
+export interface ArchbaseSpotlightProps {
+    /** Array de ações */
+    actions: SpotlightAction[];
+    /** Atalho para abrir (padrão: mod+K) */
+    shortcut?: string;
+    /** Placeholder da busca */
+    searchPlaceholder?: string;
+    /** Mensagem quando não encontra resultados */
+    nothingFoundMessage?: string;
+    /** Limite de resultados exibidos */
+    limit?: number;
+    /** Filtrar ações por permissão */
+    filterByPermission?: (action: SpotlightAction) => boolean;
+    /** Agrupar ações */
+    groupActions?: boolean;
+    /** Loading state */
+    loading?: boolean;
+    /** Aberto (controlado) */
+    opened?: boolean;
+    /** Callback ao mudar estado */
+    onOpenChange?: (opened: boolean) => void;
+    /** Fechar ao selecionar ação */
+    closeOnActionTrigger?: boolean;
+    /** Destacar match na busca */
+    highlightQuery?: boolean;
+    /** Ações recentes */
+    recentActions?: string[];
+    /** Callback ao usar ação (para rastrear recentes) */
+    onActionUsed?: (actionId: string) => void;
+    /** Máximo de ações recentes */
+    maxRecentActions?: number;
+}
+export declare function ArchbaseSpotlight({ actions, shortcut, searchPlaceholder, nothingFoundMessage, limit, filterByPermission, groupActions, loading, opened: controlledOpened, onOpenChange, closeOnActionTrigger, highlightQuery, recentActions, onActionUsed, maxRecentActions, }: ArchbaseSpotlightProps): import("react/jsx-runtime").JSX.Element;
+export interface UseArchbaseSpotlightOptions {
+    shortcut?: string;
+}
+export declare function useArchbaseSpotlight(options?: UseArchbaseSpotlightOptions): {
+    opened: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    setOpened: React.Dispatch<React.SetStateAction<boolean>>;
+};
+export default ArchbaseSpotlight;

package/dist/navigation/index.d.ts

@@ -1,3 +1,15 @@
 export { NavLink as ArchbaseNavLink } from '@mantine/core';
 export { Breadcrumbs as ArchbaseBreadcrumbs } from '@mantine/core';
 export { Pagination as ArchbasePagination } from '@mantine/core';
+export { ArchbaseContextMenu, useArchbaseContextMenu } from './ArchbaseContextMenu';
+export type { ArchbaseContextMenuProps, ArchbaseContextMenuItem, UseArchbaseContextMenuOptions, UseArchbaseContextMenuReturn, } from './ArchbaseContextMenu';
+export { ArchbaseActionSheet, useArchbaseActionSheet } from './ArchbaseActionSheet';
+export type { ArchbaseActionSheetProps, ArchbaseActionSheetItem, UseArchbaseActionSheetOptions, UseArchbaseActionSheetReturn, } from './ArchbaseActionSheet';
+export { ArchbaseBottomNavigation } from './ArchbaseBottomNavigation';
+export type { ArchbaseBottomNavigationProps, ArchbaseBottomNavigationItem } from './ArchbaseBottomNavigation';
+export { ArchbaseAppBar } from './ArchbaseAppBar';
+export type { ArchbaseAppBarProps, ArchbaseAppBarAction } from './ArchbaseAppBar';
+export { ArchbaseSpotlight, useArchbaseSpotlight } from './ArchbaseSpotlight';
+export type { ArchbaseSpotlightProps, SpotlightAction, UseArchbaseSpotlightOptions, } from './ArchbaseSpotlight';
+export { ArchbaseKeyboardShortcutsProvider, ArchbaseKeyboardShortcutsModal, ArchbaseShortcutHint, useArchbaseKeyboardShortcuts, useArchbaseRegisterShortcut, useArchbaseShortcutScope, } from './ArchbaseKeyboardShortcuts';
+export type { KeyboardShortcut, ArchbaseKeyboardShortcutsContextValue, ArchbaseKeyboardShortcutsProviderProps, ArchbaseKeyboardShortcutsModalProps, UseArchbaseRegisterShortcutOptions, UseArchbaseShortcutScopeReturn, ArchbaseShortcutHintProps, } from './ArchbaseKeyboardShortcuts';

package/dist/notification/ArchbaseNotificationCenter.d.ts

@@ -0,0 +1,56 @@
+import { MantineSize, FloatingPosition } from '@mantine/core';
+import { CSSProperties, ReactNode } from 'react';
+export interface ArchbaseNotificationItem {
+    id: string;
+    title: string;
+    message: string;
+    type?: 'info' | 'success' | 'warning' | 'error';
+    read: boolean;
+    createdAt: Date;
+    icon?: ReactNode;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    metadata?: Record<string, any>;
+}
+export interface ArchbaseNotificationCenterProps {
+    /** Lista de notificacoes a exibir */
+    notifications: ArchbaseNotificationItem[];
+    /** Callback ao marcar uma notificacao como lida */
+    onMarkAsRead?: (id: string) => void;
+    /** Callback ao marcar todas como lidas */
+    onMarkAllAsRead?: () => void;
+    /** Callback ao remover uma notificacao */
+    onRemove?: (id: string) => void;
+    /** Callback ao limpar todas as notificacoes */
+    onClearAll?: () => void;
+    /** Callback ao clicar em uma notificacao */
+    onClick?: (notification: ArchbaseNotificationItem) => void;
+    /** Modo de renderizacao: popover ou drawer */
+    renderAs?: 'drawer' | 'popover';
+    /** Posicao do popover (ignorado no modo drawer) */
+    position?: FloatingPosition;
+    /** Largura do painel */
+    width?: number;
+    /** Altura maxima da area de scroll */
+    maxHeight?: number;
+    /** Titulo do painel */
+    title?: string;
+    /** Mensagem quando nao ha notificacoes */
+    emptyMessage?: string;
+    /** Mostrar badge com contagem de nao-lidas */
+    showBadge?: boolean;
+    /** Tamanho do botao */
+    buttonSize?: MantineSize;
+    /** Variante do botao */
+    buttonVariant?: string;
+    /** Estilo customizado do wrapper */
+    style?: CSSProperties;
+    /** Classe CSS customizada */
+    className?: string;
+}
+export declare function ArchbaseNotificationCenter(props: ArchbaseNotificationCenterProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseNotificationCenter {
+    var displayName: string;
+}

package/dist/notification/index.d.ts

@@ -2,3 +2,5 @@ export { ArchbaseNotifications } from './ArchbaseNotifications';
 export { ArchbaseAlert } from './ArchbaseAlert';
 export type { ArchbaseAlertProps } from './ArchbaseAlert';
 export { ArchbaseDialog, CustomShowErrorModal } from './ArchbaseDialog';
+export { ArchbaseNotificationCenter } from './ArchbaseNotificationCenter';
+export type { ArchbaseNotificationCenterProps, ArchbaseNotificationItem } from './ArchbaseNotificationCenter';