@archbase/admin 3.0.8 → 3.0.10

package/dist/sidebar/ArchbaseMantineSidebar.d.ts

@@ -0,0 +1,43 @@
+import { ArchbaseMantineSidebarProps } from './types';
+import { StandardSidebar } from './variants/StandardSidebar';
+import { MinimalSidebar } from './variants/MinimalSidebar';
+import { RailSidebar } from './variants/RailSidebar';
+/**
+ * ArchbaseMantineSidebar - Componente de sidebar moderno baseado em Mantine
+ *
+ * Este componente substitui o ArchbaseAdvancedSidebar (baseado em react-pro-sidebar)
+ * oferecendo 3 variantes de design:
+ *
+ * - **standard**: Menu completo com accordion, nested menus, search integrado (Notion/Slack style)
+ * - **minimal**: Icon-only com tooltips e menus flutuantes (VSCode/Outlook style)
+ * - **rail**: Double panel com coluna de grupos e menu detalhado (Discord/Supabase style)
+ *
+ * @example
+ * ```tsx
+ * // Variante Standard (padrão)
+ * <ArchbaseMantineSidebar
+ *   navigationData={navigationData}
+ *   variant="standard"
+ *   showSearch
+ *   header={<Logo />}
+ *   footer={<UserProfile />}
+ * />
+ *
+ * // Variante Minimal
+ * <ArchbaseMantineSidebar
+ *   navigationData={navigationData}
+ *   variant="minimal"
+ *   width={60}
+ * />
+ *
+ * // Variante Rail (similar ao ArchbaseAdvancedSidebar)
+ * <ArchbaseMantineSidebar
+ *   navigationData={navigationData}
+ *   variant="rail"
+ *   groupColumnWidth={80}
+ *   showGroupLabels
+ * />
+ * ```
+ */
+export declare function ArchbaseMantineSidebar({ variant, ...props }: ArchbaseMantineSidebarProps): import("react/jsx-runtime").JSX.Element;
+export { StandardSidebar, MinimalSidebar, RailSidebar };

package/dist/sidebar/components/SidebarBadge.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { SidebarBadgeProps } from '../types';
+/**
+ * Badge para exibir notificações/contadores em items do sidebar
+ */
+export declare function SidebarBadge({ value, color, size, }: SidebarBadgeProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Indicador de ponto para notificações
+ * Útil quando não precisa mostrar número
+ */
+export declare function SidebarIndicator({ children, show, color, processing, }: {
+    children: React.ReactNode;
+    show?: boolean;
+    color?: string;
+    processing?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/sidebar/components/SidebarGroup.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { SidebarGroupProps } from '../types';
+/**
+ * Componente de grupo colapsável do sidebar
+ * Agrupa items relacionados com header clicável
+ */
+export declare function SidebarGroup({ label, icon, children, defaultExpanded, expanded: controlledExpanded, onExpandedChange, groupId, }: SidebarGroupProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Componente de divisor/seção do sidebar
+ * Apenas exibe um label sem funcionalidade de colapso
+ */
+export declare function SidebarSection({ label, children, }: {
+    label: string;
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/sidebar/components/SidebarGroupIcon.d.ts

@@ -0,0 +1,6 @@
+import { SidebarGroupIconProps } from '../types';
+/**
+ * Componente de ícone de grupo para a variante Rail
+ * Renderiza um ícone clicável com label opcional
+ */
+export declare function SidebarGroupIcon({ group, active, onClick, showLabel, activeColor, inactiveColor, }: SidebarGroupIconProps): import("react/jsx-runtime").JSX.Element;

package/dist/sidebar/components/SidebarItem.d.ts

@@ -0,0 +1,6 @@
+import { SidebarItemProps } from '../types';
+/**
+ * Componente de item de menu do sidebar
+ * Usa NavLink do Mantine com suporte a aninhamento
+ */
+export declare function SidebarItem({ item, depth, collapsed, active, onClick, textColor, iconColor, hoverColor, itemHeight, }: SidebarItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/sidebar/components/SidebarSearch.d.ts

@@ -0,0 +1,6 @@
+import { SidebarSearchProps } from '../types';
+/**
+ * Campo de busca para o sidebar
+ * Suporta atalho de teclado e botão de limpar
+ */
+export declare function SidebarSearch({ placeholder, value, onChange, onClear, collapsed, }: SidebarSearchProps): import("react/jsx-runtime").JSX.Element;

package/dist/sidebar/components/SidebarSkeleton.d.ts

@@ -0,0 +1,45 @@
+export interface SidebarSkeletonProps {
+    /** Número de items a exibir */
+    itemCount?: number;
+    /** Se o sidebar está colapsado */
+    collapsed?: boolean;
+    /** Cor de fundo */
+    backgroundColor?: string;
+    /** Altura de cada item */
+    itemHeight?: number;
+    /** Mostrar grupos */
+    showGroups?: boolean;
+    /** Número de grupos */
+    groupCount?: number;
+}
+/**
+ * Skeleton para loading do menu do sidebar
+ */
+export declare function SidebarMenuSkeleton({ itemCount, collapsed, backgroundColor, itemHeight, showGroups, groupCount, }: SidebarSkeletonProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton para a coluna de grupos (Rail variant)
+ */
+export declare function SidebarGroupsSkeleton({ groupCount, width, backgroundColor, }: {
+    groupCount?: number;
+    width?: string | number;
+    backgroundColor?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton para o header do sidebar
+ */
+export declare function SidebarHeaderSkeleton({ collapsed, }: {
+    collapsed?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton para o perfil do usuário no footer
+ */
+export declare function SidebarUserProfileSkeleton({ collapsed, }: {
+    collapsed?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Mensagem de erro para o sidebar
+ */
+export declare function SidebarErrorMessage({ message, backgroundColor, }: {
+    message: string;
+    backgroundColor?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/sidebar/components/SidebarUserProfile.d.ts

@@ -0,0 +1,6 @@
+import { SidebarUserProfileProps } from '../types';
+/**
+ * Componente de perfil do usuário para o footer do sidebar
+ * Exibe avatar, nome e email do usuário
+ */
+export declare function SidebarUserProfile({ name, email, avatar, onClick, collapsed, }: SidebarUserProfileProps): import("react/jsx-runtime").JSX.Element;

package/dist/sidebar/components/index.d.ts

@@ -0,0 +1,8 @@
+export { SidebarItem } from './SidebarItem';
+export { SidebarGroup, SidebarSection } from './SidebarGroup';
+export { SidebarGroupIcon } from './SidebarGroupIcon';
+export { SidebarSearch } from './SidebarSearch';
+export { SidebarUserProfile } from './SidebarUserProfile';
+export { SidebarBadge, SidebarIndicator } from './SidebarBadge';
+export { SidebarMenuSkeleton, SidebarGroupsSkeleton, SidebarHeaderSkeleton, SidebarUserProfileSkeleton, SidebarErrorMessage, } from './SidebarSkeleton';
+export type { SidebarSkeletonProps } from './SidebarSkeleton';

package/dist/sidebar/context/SidebarContext.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { SidebarContextValue, SidebarProviderProps } from '../types';
+declare const SidebarContext: React.Context<SidebarContextValue>;
+/**
+ * Hook para acessar o contexto do Sidebar
+ */
+export declare function useSidebar(): SidebarContextValue;
+/**
+ * Hook opcional que não lança erro se usado fora do provider
+ */
+export declare function useSidebarOptional(): SidebarContextValue | null;
+/**
+ * Provider do contexto do Sidebar
+ */
+export declare function SidebarProvider({ children, navigationData, variant, defaultCollapsed, collapsed: controlledCollapsed, onCollapsedChange, defaultActiveGroup, activeGroup: controlledActiveGroup, onActiveGroupChange, showKeyboardShortcuts, highlightActiveItem, onMenuItemClick, }: SidebarProviderProps): import("react/jsx-runtime").JSX.Element;
+export { SidebarContext };

package/dist/sidebar/context/index.d.ts

@@ -0,0 +1 @@
+export { SidebarProvider, useSidebar, useSidebarOptional, SidebarContext } from './SidebarContext';

package/dist/sidebar/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export { useSidebarNavigation } from './useSidebarNavigation';
+export type { UseSidebarNavigationOptions, UseSidebarNavigationReturn } from './useSidebarNavigation';
+export { useSidebarSearch } from './useSidebarSearch';
+export type { UseSidebarSearchOptions, UseSidebarSearchReturn } from './useSidebarSearch';
+export { useSidebarKeyboard } from './useSidebarKeyboard';
+export type { UseSidebarKeyboardOptions, UseSidebarKeyboardReturn } from './useSidebarKeyboard';

package/dist/sidebar/hooks/useSidebarKeyboard.d.ts

@@ -0,0 +1,20 @@
+import { ArchbaseNavigationItem } from '../../types';
+export interface UseSidebarKeyboardOptions {
+    navigationData: ArchbaseNavigationItem[];
+    navigateToItem: (item: ArchbaseNavigationItem) => void;
+    onToggleSidebar?: () => void;
+    enabled?: boolean;
+}
+export interface UseSidebarKeyboardReturn {
+    /** Mapa de atalhos registrados */
+    shortcuts: Map<string, ArchbaseNavigationItem>;
+    /** Verificar se um item tem atalho */
+    hasShortcut: (item: ArchbaseNavigationItem) => boolean;
+    /** Obter atalho de um item */
+    getShortcut: (item: ArchbaseNavigationItem) => string | undefined;
+}
+/**
+ * Hook para gerenciar atalhos de teclado do sidebar
+ * Registra hotkeys globais para navegação rápida
+ */
+export declare function useSidebarKeyboard({ navigationData, navigateToItem, onToggleSidebar, enabled, }: UseSidebarKeyboardOptions): UseSidebarKeyboardReturn;

package/dist/sidebar/hooks/useSidebarNavigation.d.ts

@@ -0,0 +1,24 @@
+import { ArchbaseNavigationItem } from '../../types';
+export interface UseSidebarNavigationOptions {
+    navigationData: ArchbaseNavigationItem[];
+    onMenuItemClick?: (item: ArchbaseNavigationItem) => void;
+}
+export interface UseSidebarNavigationReturn {
+    /** Item atualmente ativo baseado na rota */
+    activeItem: ArchbaseNavigationItem | null;
+    /** Caminho da rota atual */
+    currentPath: string;
+    /** Navegar para um item */
+    navigateToItem: (item: ArchbaseNavigationItem) => void;
+    /** Verificar se um item está ativo */
+    isItemActive: (item: ArchbaseNavigationItem) => boolean;
+    /** Verificar se um item ou algum de seus filhos está ativo */
+    isItemOrChildActive: (item: ArchbaseNavigationItem) => boolean;
+    /** Encontrar o caminho de breadcrumb até o item ativo */
+    activeBreadcrumb: ArchbaseNavigationItem[];
+}
+/**
+ * Hook para gerenciar a navegação do sidebar
+ * Integra com React Router para detectar rota ativa
+ */
+export declare function useSidebarNavigation({ navigationData, onMenuItemClick, }: UseSidebarNavigationOptions): UseSidebarNavigationReturn;

package/dist/sidebar/hooks/useSidebarSearch.d.ts

@@ -0,0 +1,26 @@
+import { ArchbaseNavigationItem } from '../../types';
+export interface UseSidebarSearchOptions {
+    navigationData: ArchbaseNavigationItem[];
+    onSearch?: (query: string, results: ArchbaseNavigationItem[]) => void;
+}
+export interface UseSidebarSearchReturn {
+    /** Query de busca atual */
+    query: string;
+    /** Definir query de busca */
+    setQuery: (value: string) => void;
+    /** Limpar busca */
+    clearSearch: () => void;
+    /** Items filtrados */
+    filteredItems: ArchbaseNavigationItem[];
+    /** Se há resultados */
+    hasResults: boolean;
+    /** Se a busca está ativa (query não vazia) */
+    isSearching: boolean;
+    /** Total de items encontrados (incluindo aninhados) */
+    totalResults: number;
+}
+/**
+ * Hook para gerenciar a busca no sidebar
+ * Filtra items de navegação com suporte a aninhamento
+ */
+export declare function useSidebarSearch({ navigationData, onSearch, }: UseSidebarSearchOptions): UseSidebarSearchReturn;

package/dist/sidebar/index.d.ts

@@ -0,0 +1,13 @@
+export type { SidebarVariant, SidebarCollapsibleMode, ExtendedNavigationItem, ArchbaseMantineSidebarProps, SidebarContextValue, SidebarItemProps, SidebarGroupProps, SidebarSearchProps, SidebarUserProfileProps, SidebarGroupIconProps, SidebarBadgeProps, SidebarProviderProps, } from './types';
+export { SidebarProvider, useSidebar, useSidebarOptional, SidebarContext } from './context';
+export { useSidebarNavigation, useSidebarSearch, useSidebarKeyboard, } from './hooks';
+export type { UseSidebarNavigationOptions, UseSidebarNavigationReturn, UseSidebarSearchOptions, UseSidebarSearchReturn, UseSidebarKeyboardOptions, UseSidebarKeyboardReturn, } from './hooks';
+export { SidebarItem } from './components/SidebarItem';
+export { SidebarGroup, SidebarSection } from './components/SidebarGroup';
+export { SidebarGroupIcon } from './components/SidebarGroupIcon';
+export { SidebarSearch } from './components/SidebarSearch';
+export { SidebarUserProfile } from './components/SidebarUserProfile';
+export { SidebarBadge, SidebarIndicator } from './components/SidebarBadge';
+export { SidebarMenuSkeleton, SidebarGroupsSkeleton, SidebarHeaderSkeleton, SidebarUserProfileSkeleton, SidebarErrorMessage, } from './components/SidebarSkeleton';
+export type { SidebarSkeletonProps } from './components/SidebarSkeleton';
+export { ArchbaseMantineSidebar, StandardSidebar, MinimalSidebar, RailSidebar } from './ArchbaseMantineSidebar';

package/dist/sidebar/types.d.ts

@@ -0,0 +1,303 @@
+import { ReactNode } from 'react';
+import { MantineColor, MantineTheme } from '@mantine/core';
+import { ArchbaseNavigationItem, ArchbaseNavigationGroup } from '../types';
+/**
+ * Variantes disponíveis para o sidebar
+ */
+export type SidebarVariant = 'minimal' | 'standard' | 'rail';
+/**
+ * Modo de colapso do sidebar
+ */
+export type SidebarCollapsibleMode = 'icon' | 'offcanvas' | 'none';
+/**
+ * Extensão do ArchbaseNavigationItem para features avançadas
+ */
+export interface ExtendedNavigationItem extends ArchbaseNavigationItem {
+    /** Badge de notificação (número ou texto) */
+    badge?: string | number;
+    /** Cor do badge */
+    badgeColor?: MantineColor;
+    /** Atalho de teclado (ex: "Ctrl+Shift+H") */
+    shortcut?: string;
+    /** Tooltip customizado */
+    tooltip?: string;
+    /** Se o item é um divisor/seção */
+    isSection?: boolean;
+    /** Label da seção */
+    sectionLabel?: string;
+}
+/**
+ * Props principais do componente ArchbaseMantineSidebar
+ */
+export interface ArchbaseMantineSidebarProps {
+    /** Dados de navegação (compatível com API existente) */
+    navigationData: ArchbaseNavigationItem[];
+    /** Variante do sidebar */
+    variant?: SidebarVariant;
+    /** Posição do sidebar */
+    side?: 'left' | 'right';
+    /** Largura do sidebar expandido */
+    width?: string | number;
+    /** Largura do sidebar colapsado */
+    collapsedWidth?: string | number;
+    /** Altura do sidebar */
+    height?: string | number;
+    /** Largura da coluna de grupos (apenas para variante Rail) */
+    groupColumnWidth?: string | number;
+    /** Estado controlado de colapso */
+    collapsed?: boolean;
+    /** Estado inicial de colapso */
+    defaultCollapsed?: boolean;
+    /** Callback quando o estado de colapso muda */
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /** Grupo ativo (controlado) */
+    activeGroup?: string;
+    /** Grupo ativo inicial */
+    defaultActiveGroup?: string;
+    /** Callback quando o grupo ativo muda */
+    onActiveGroupChange?: (groupName: string) => void;
+    /** Ícone padrão para grupos sem ícone */
+    defaultGroupIcon?: ReactNode;
+    /** Mostrar labels dos grupos */
+    showGroupLabels?: boolean;
+    /** Callback quando um item de menu é clicado */
+    onMenuItemClick?: (item: ArchbaseNavigationItem) => void;
+    /** Mostrar campo de busca */
+    showSearch?: boolean;
+    /** Placeholder do campo de busca */
+    searchPlaceholder?: string;
+    /** Callback de busca */
+    onSearch?: (query: string, results: ArchbaseNavigationItem[]) => void;
+    /** Mostrar área de perfil do usuário */
+    showUserProfile?: boolean;
+    /** Conteúdo customizado do perfil */
+    userProfileContent?: ReactNode;
+    /** Callback ao clicar no perfil */
+    onUserProfileClick?: () => void;
+    /** Mostrar atalhos de teclado */
+    showKeyboardShortcuts?: boolean;
+    /** Destacar item ativo */
+    highlightActiveItem?: boolean;
+    /** Fechar sidebar ao clicar em item (mobile) */
+    closeOnItemClick?: boolean;
+    /** Conteúdo do header */
+    header?: ReactNode;
+    /** Conteúdo do footer */
+    footer?: ReactNode;
+    /** Altura do footer */
+    footerHeight?: string | number;
+    /** Indica se está carregando */
+    isLoading?: boolean;
+    /** Mensagem de erro */
+    loadingError?: string | null;
+    /** Componente de loading customizado */
+    loadingComponent?: ReactNode;
+    /** Componente de erro customizado */
+    errorComponent?: ReactNode;
+    /** Número de itens no skeleton */
+    skeletonItemCount?: number;
+    /** Tema do Mantine */
+    theme?: MantineTheme;
+    /** Cor de fundo (dark mode) */
+    backgroundDarkColor?: string;
+    /** Cor de fundo (light mode) */
+    backgroundLightColor?: string;
+    /** Cor do texto (dark mode) */
+    textDarkColor?: string;
+    /** Cor do texto (light mode) */
+    textLightColor?: string;
+    /** Cor dos ícones (dark mode) */
+    iconDarkColor?: string;
+    /** Cor dos ícones (light mode) */
+    iconLightColor?: string;
+    /** Cor do item ativo */
+    activeColor?: MantineColor;
+    /** Cor de hover */
+    hoverColor?: MantineColor;
+    /** Cor de fundo da coluna de grupos */
+    groupBackgroundColor?: string;
+    /** Cor do grupo selecionado */
+    selectedGroupColor?: string;
+    /** Cor dos grupos */
+    groupColor?: string;
+    /** Cor do label do grupo (dark mode) */
+    groupLabelDarkColor?: string;
+    /** Cor do label do grupo (light mode) */
+    groupLabelLightColor?: string;
+    /** Mostrar borda */
+    withBorder?: boolean;
+    /** Mostrar sombra */
+    withShadow?: boolean;
+    /** Aria label para o sidebar */
+    ariaLabel?: string;
+    /** Ref para o elemento raiz */
+    sidebarRef?: React.Ref<HTMLElement>;
+}
+/**
+ * Valor do context interno do Sidebar
+ */
+export interface SidebarContextValue {
+    /** Se o sidebar está colapsado */
+    collapsed: boolean;
+    /** Função para alterar o estado de colapso */
+    setCollapsed: (value: boolean) => void;
+    /** Toggle do estado de colapso */
+    toggleCollapsed: () => void;
+    /** Nome do grupo ativo */
+    activeGroup: string;
+    /** Função para alterar o grupo ativo */
+    setActiveGroup: (value: string) => void;
+    /** Caminho do item ativo atual */
+    activeItemPath: string;
+    /** Navegar para um item */
+    navigateToItem: (item: ArchbaseNavigationItem) => void;
+    /** Query de busca */
+    searchQuery: string;
+    /** Função para alterar a query de busca */
+    setSearchQuery: (value: string) => void;
+    /** Itens filtrados pela busca */
+    filteredItems: ArchbaseNavigationItem[];
+    /** IDs dos grupos expandidos */
+    expandedGroups: Set<string>;
+    /** Toggle de um grupo */
+    toggleGroup: (groupId: string) => void;
+    /** Expandir um grupo */
+    expandGroup: (groupId: string) => void;
+    /** Colapsar um grupo */
+    collapseGroup: (groupId: string) => void;
+    /** Variante atual */
+    variant: SidebarVariant;
+    /** Se deve mostrar atalhos de teclado */
+    showKeyboardShortcuts: boolean;
+    /** Se deve destacar item ativo */
+    highlightActiveItem: boolean;
+}
+/**
+ * Props do componente SidebarItem
+ */
+export interface SidebarItemProps {
+    /** Item de navegação */
+    item: ArchbaseNavigationItem;
+    /** Nível de aninhamento (0 = raiz) */
+    depth?: number;
+    /** Se o sidebar está colapsado */
+    collapsed?: boolean;
+    /** Se o item está ativo */
+    active?: boolean;
+    /** Callback ao clicar */
+    onClick?: (item: ArchbaseNavigationItem) => void;
+    /** Cor do texto */
+    textColor?: string;
+    /** Cor do ícone */
+    iconColor?: string;
+    /** Cor de hover/ativo (background) */
+    hoverColor?: string;
+    /** Altura do item */
+    itemHeight?: string | number;
+}
+/**
+ * Props do componente SidebarGroup
+ */
+export interface SidebarGroupProps {
+    /** Label do grupo */
+    label: string;
+    /** Ícone do grupo */
+    icon?: ReactNode;
+    /** Conteúdo do grupo (items) */
+    children: ReactNode;
+    /** Se o grupo inicia expandido */
+    defaultExpanded?: boolean;
+    /** Estado controlado de expansão */
+    expanded?: boolean;
+    /** Callback quando a expansão muda */
+    onExpandedChange?: (expanded: boolean) => void;
+    /** ID único do grupo */
+    groupId?: string;
+}
+/**
+ * Props do componente SidebarSearch
+ */
+export interface SidebarSearchProps {
+    /** Placeholder do input */
+    placeholder?: string;
+    /** Valor controlado */
+    value?: string;
+    /** Callback de mudança */
+    onChange?: (value: string) => void;
+    /** Callback ao limpar */
+    onClear?: () => void;
+    /** Se o sidebar está colapsado */
+    collapsed?: boolean;
+}
+/**
+ * Props do componente SidebarUserProfile
+ */
+export interface SidebarUserProfileProps {
+    /** Nome do usuário */
+    name?: string;
+    /** Email do usuário */
+    email?: string;
+    /** Avatar (URL ou componente) */
+    avatar?: string | ReactNode;
+    /** Callback ao clicar */
+    onClick?: () => void;
+    /** Se o sidebar está colapsado */
+    collapsed?: boolean;
+}
+/**
+ * Props do componente SidebarGroupIcon (Rail)
+ */
+export interface SidebarGroupIconProps {
+    /** Dados do grupo */
+    group: ArchbaseNavigationGroup;
+    /** Se o grupo está ativo */
+    active?: boolean;
+    /** Callback ao clicar */
+    onClick?: () => void;
+    /** Mostrar label abaixo do ícone */
+    showLabel?: boolean;
+    /** Cor quando ativo */
+    activeColor?: string;
+    /** Cor quando inativo */
+    inactiveColor?: string;
+}
+/**
+ * Props do componente SidebarBadge
+ */
+export interface SidebarBadgeProps {
+    /** Valor do badge */
+    value: string | number;
+    /** Cor do badge */
+    color?: MantineColor;
+    /** Tamanho do badge */
+    size?: 'xs' | 'sm' | 'md';
+}
+/**
+ * Props do provider do Sidebar
+ */
+export interface SidebarProviderProps {
+    /** Filhos */
+    children: ReactNode;
+    /** Dados de navegação */
+    navigationData: ArchbaseNavigationItem[];
+    /** Variante do sidebar */
+    variant?: SidebarVariant;
+    /** Estado inicial de colapso */
+    defaultCollapsed?: boolean;
+    /** Estado controlado de colapso */
+    collapsed?: boolean;
+    /** Callback quando colapso muda */
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /** Grupo ativo inicial */
+    defaultActiveGroup?: string;
+    /** Grupo ativo controlado */
+    activeGroup?: string;
+    /** Callback quando grupo ativo muda */
+    onActiveGroupChange?: (groupName: string) => void;
+    /** Mostrar atalhos de teclado */
+    showKeyboardShortcuts?: boolean;
+    /** Destacar item ativo */
+    highlightActiveItem?: boolean;
+    /** Callback ao clicar em item */
+    onMenuItemClick?: (item: ArchbaseNavigationItem) => void;
+}

package/dist/sidebar/variants/MinimalSidebar.d.ts

@@ -0,0 +1,13 @@
+import { ArchbaseMantineSidebarProps } from '../types';
+/**
+ * MinimalSidebar - Variante minimal/icon-only do sidebar
+ *
+ * Características:
+ * - Exibe apenas ícones
+ * - Tooltips com labels no hover
+ * - Submenus em Menu flutuante (popover)
+ * - Ideal para economizar espaço
+ *
+ * Inspiração: VSCode, Outlook Web
+ */
+export declare function MinimalSidebar(props: Omit<ArchbaseMantineSidebarProps, 'variant'>): import("react/jsx-runtime").JSX.Element;

package/dist/sidebar/variants/RailSidebar.d.ts

@@ -0,0 +1,13 @@
+import { ArchbaseMantineSidebarProps } from '../types';
+/**
+ * RailSidebar - Variante com coluna de grupos (Double Panel)
+ *
+ * Características:
+ * - Coluna de ícones de grupos à esquerda
+ * - Painel de menu detalhado à direita
+ * - Transição suave entre grupos
+ * - Suporte a múltiplos grupos de navegação
+ *
+ * Inspiração: Discord, Supabase, ArchbaseAdvancedSidebar atual
+ */
+export declare function RailSidebar(props: Omit<ArchbaseMantineSidebarProps, 'variant'>): import("react/jsx-runtime").JSX.Element;

package/dist/sidebar/variants/StandardSidebar.d.ts

@@ -0,0 +1,12 @@
+import { ArchbaseMantineSidebarProps } from '../types';
+/**
+ * StandardSidebar - Variante padrão do sidebar
+ *
+ * Características:
+ * - Menu com seções accordion
+ * - Suporte a nested menus (até 2+ níveis)
+ * - Header/Footer customizáveis
+ * - Search integrado
+ * - Collapse/expand com transição suave
+ */
+export declare function StandardSidebar(props: Omit<ArchbaseMantineSidebarProps, 'variant'>): import("react/jsx-runtime").JSX.Element;

package/dist/sidebar/variants/index.d.ts

@@ -0,0 +1,3 @@
+export { StandardSidebar } from './StandardSidebar';
+export { MinimalSidebar } from './MinimalSidebar';
+export { RailSidebar } from './RailSidebar';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archbase/admin",
-  "version": "3.0.8",
+  "version": "3.0.10",
   "description": "Admin interface components for Archbase React",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -43,12 +43,12 @@
     "react-router-dom": "^6.28.0",
     "usehooks-ts": "^2.16.0",
     "zustand": "^5.0.6",
-    "@archbase/components": "3.0.8",
-    "@archbase/core": "3.0.8",
-    "@archbase/data": "3.0.8",
-    "@archbase/layout": "3.0.8",
-    "@archbase/security": "3.0.8",
-    "@archbase/template": "3.0.8"
+    "@archbase/components": "3.0.10",
+    "@archbase/core": "3.0.10",
+    "@archbase/data": "3.0.10",
+    "@archbase/layout": "3.0.10",
+    "@archbase/security": "3.0.10",
+    "@archbase/template": "3.0.10"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.200",