forlogic-core 1.15.3 → 1.15.5

package/dist/assets/index.d.ts

@@ -0,0 +1,6 @@
+export declare const assets: {
+    logo: string;
+    smallLogo: string;
+};
+export declare const logoSrc: string;
+export declare const smallLogoSrc: string;

package/dist/auth/components/ProtectedRoute.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ProtectedRouteProps {
+    children: React.ReactNode;
+}
+export declare const ProtectedRoute: React.FC<ProtectedRouteProps>;
+export {};

package/dist/auth/components/UserInfo.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { Company } from '../../types';
+interface UserInfoProps {
+    variant?: 'card' | 'dropdown';
+    className?: string;
+    selectedUnit?: Company | null;
+    onUnitChange?: (unit: Company) => void;
+}
+declare const UserInfo: React.FC<UserInfoProps>;
+export default UserInfo;

package/dist/auth/contexts/AuthContext.d.ts

@@ -0,0 +1,84 @@
+import React from 'react';
+import { AuthState, Company } from '../../types';
+interface AuthContextType extends AuthState {
+    logout: () => void;
+    processCallback: () => Promise<boolean>;
+    switchUnit: (company: Company) => Promise<void>;
+    availableUnits: Company[];
+    isSearchVisible: boolean;
+    setSearchVisible: (visible: boolean) => void;
+    clearSearch: () => void;
+    refreshData: () => void;
+}
+export declare const AuthProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+/**
+ * Hook para acessar informações de autenticação e gerenciar sessão
+ *
+ * Fornece dados do usuário autenticado, empresa/unidade selecionada,
+ * e funções para logout e troca de unidade.
+ *
+ * **DEVE SER USADO DENTRO DE `<AuthProvider>`**
+ *
+ * @example
+ * ```typescript
+ * import { useAuth } from 'forlogic-core';
+ *
+ * function MyComponent() {
+ *   const {
+ *     user,              // Dados do usuário logado
+ *     alias,             // Alias da empresa/unidade ativa
+ *     companies,         // Lista de empresas disponíveis
+ *     isAuthenticated,   // true se está logado
+ *     isLoading,         // true durante inicialização
+ *     logout,            // Função para fazer logout
+ *     switchUnit         // Função para trocar de unidade
+ *   } = useAuth();
+ *
+ *   if (isLoading) return <div>Carregando...</div>;
+ *   if (!isAuthenticated) return <div>Não autenticado</div>;
+ *
+ *   return (
+ *     <div>
+ *       <p>Olá, {user?.name}</p>
+ *       <p>Empresa: {alias}</p>
+ *       <button onClick={logout}>Sair</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Trocar de unidade/empresa
+ * function UnitSelector() {
+ *   const { companies, alias, switchUnit } = useAuth();
+ *
+ *   const handleSwitch = async (company: Company) => {
+ *     await switchUnit(company);
+ *     // Cache será limpo automaticamente
+ *     // Todas as queries serão recarregadas com novo alias
+ *   };
+ *
+ *   return (
+ *     <select value={alias} onChange={(e) => {
+ *       const company = companies.find(c => c.alias === e.target.value);
+ *       if (company) handleSwitch(company);
+ *     }}>
+ *       {companies.map(c => (
+ *         <option key={c.id} value={c.alias}>{c.name}</option>
+ *       ))}
+ *     </select>
+ *   );
+ * }
+ * ```
+ *
+ * @returns Contexto de autenticação completo com user, companies, alias, etc
+ *
+ * @throws {Error} Se usado fora do AuthProvider
+ *
+ * @see {@link AuthProvider} - Provider que deve envolver a aplicação
+ */
+export declare const useAuth: () => AuthContextType;
+export {};

package/dist/auth/pages/CallbackPage.d.ts

@@ -0,0 +1 @@
+export declare const CallbackPage: () => import("react/jsx-runtime").JSX.Element;

package/dist/auth/pages/LoginPage.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const LoginPage: React.FC;

package/dist/auth/services/AuthService.d.ts

@@ -0,0 +1,40 @@
+import type { AuthState } from '../../types';
+export declare class AuthService {
+    /**
+     * Inicializa o estado de autenticação verificando apenas tokens armazenados
+     * Tokens da URL devem ser processados exclusivamente na CallbackPage
+     */
+    static initialize(): Promise<AuthState>;
+    /**
+     * Login para ambiente de desenvolvimento - redireciona para callback com tokens
+     */
+    static loginDev(): Promise<boolean>;
+    /**
+     * Login para ambiente de produção (OAuth)
+     */
+    static loginProd(): void;
+    /**
+     * Processa o callback do OAuth (simplificado)
+     */
+    static processCallback(): Promise<boolean>;
+    /**
+     * Logout do usuário
+     */
+    static logout(): void;
+    /**
+     * Decodifica um token JWT usando TokenService robusto
+     */
+    private static decodeToken;
+    /**
+     * Extrai informações do usuário do ID token
+     */
+    private static extractUserFromIdToken;
+    /**
+     * Extrai empresas do ID token com companyId incluído
+     */
+    private static extractCompaniesFromIdToken;
+    /**
+     * Extrai alias do access token (campo default)
+     */
+    private static extractAliasFromAccessToken;
+}

package/dist/auth/services/SupabaseTokenService.d.ts

@@ -0,0 +1,3 @@
+export declare class SupabaseTokenService {
+    static generateToken(accessToken: string, selectedAlias: string, onAuthFailure?: () => void, forceRegeneration?: boolean): Promise<string | null>;
+}

package/dist/auth/services/TokenManager.d.ts

@@ -0,0 +1,51 @@
+export declare const TokenManager: {
+    setAccessToken: (token: string) => void;
+    getAccessToken: () => string;
+    setIdToken: (token: string) => void;
+    getIdToken: () => string;
+    getSupabaseToken: () => string;
+    setOAuthState: (state: string) => void;
+    getOAuthState: () => string;
+    clearOAuthState: () => void;
+    setOAuthNonce: (nonce: string) => void;
+    getOAuthNonce: () => string;
+    clearOAuthNonce: () => void;
+    setSelectedAlias: (alias: string) => void;
+    getSelectedAlias: () => string;
+    clearSelectedAlias: () => void;
+    generateOAuthState: () => string;
+    generateOAuthNonce: () => string;
+    hasAllTokens: () => boolean;
+    setSupabaseToken: (token: string) => void;
+    areAllTokensValid: () => boolean;
+    clearExpiredTokens: () => boolean;
+    clearAll: () => void;
+    setManualLogout: () => void;
+    isManualLogout: () => boolean;
+    clearManualLogout: () => void;
+    isTokenExpired: (token: string) => boolean;
+    _validationCache: {
+        isValid: boolean;
+        timestamp: number;
+        cacheValidityMs: number;
+    };
+    _clearValidationCache: () => void;
+    isSupabaseTokenValid: () => boolean;
+    getValidSupabaseToken: () => string | null;
+    _handleExpiredToken: () => void;
+    extractTokenData: () => {
+        alias: any;
+        companyId: any;
+        placeId: any;
+        placeName: any;
+        payload: import("./TokenService").JwtPayload;
+    };
+    getCompanyId: (alias?: string) => string | null;
+    getCurrentCompanyId: () => string | null;
+    getAllCompaniesData: () => {
+        id: string;
+        alias: string;
+        name: string;
+        payload: any;
+    }[];
+};

package/dist/auth/services/TokenRegenerationService.d.ts

@@ -0,0 +1,12 @@
+export declare class TokenRegenerationService {
+    private static isRegenerating;
+    private static onLogoutCallback;
+    /**
+     * Registra callback para ser chamado em caso de falha de autenticação
+     */
+    static setLogoutCallback(callback: () => void): void;
+    /**
+     * Tenta regenerar o token Supabase se os tokens Qualiex são válidos
+     */
+    static attemptRegeneration(): Promise<string | null>;
+}

package/dist/auth/services/TokenService.d.ts

@@ -0,0 +1,42 @@
+export interface JwtPayload {
+    [key: string]: any;
+    exp?: number;
+    iat?: number;
+    sub?: string;
+    iss?: string;
+}
+interface TokenValidationResult {
+    isValid: boolean;
+    idTokenValid: boolean;
+    accessTokenValid: boolean;
+    warnings: string[];
+    errors: string[];
+}
+export declare class TokenService {
+    private static readonly LARGE_PAYLOAD_THRESHOLD;
+    /**
+     * Converte base64url para base64 padrão
+     * Resolve problema com tokens JWT que usam base64url encoding
+     */
+    private static normalizeBase64Url;
+    /**
+     * Parse JWT payload com suporte completo a base64url e múltiplas estratégias
+     * Implementa 3 estratégias de fallback para tokens grandes/problemáticos
+     */
+    static parseJwtPayload(token: string): JwtPayload | null;
+    /**
+     * Validação de tokens com diferenciação ID vs Access
+     * ID token é CRÍTICO - deve ser válido ou bloqueia login
+     * Access token é OPCIONAL - apenas warning se falhar
+     */
+    static validateTokens(accessToken: string, idToken: string): TokenValidationResult;
+    /**
+     * Verifica se um token está expirado usando validação robusta
+     */
+    static isTokenExpired(token: string): boolean;
+    /**
+     * Extrai dados do token de forma segura
+     */
+    static extractTokenData(token: string): JwtPayload | null;
+}
+export {};

package/dist/auth/utils/AuthUtils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Limpa o flag de logout manual ao fazer login com sucesso
+ */
+export declare const clearManualLogout: () => void;

package/dist/auth/utils/ErrorInterceptor.d.ts

@@ -0,0 +1,15 @@
+export declare class AuthErrorInterceptor {
+    /**
+     * Intercepts and handles authentication-related errors
+     * Returns true if error was handled and should not bubble up
+     */
+    static handleError(error: any): boolean;
+    /**
+     * Determines if an error is authentication-related
+     */
+    private static isAuthenticationError;
+    /**
+     * Wraps a promise to automatically handle authentication errors
+     */
+    static wrapAsync<T>(promise: Promise<T>): Promise<T>;
+}

package/dist/components/ErrorBoundary.d.ts

@@ -0,0 +1,19 @@
+import React, { Component, ReactNode } from 'react';
+interface Props {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+interface State {
+    hasError: boolean;
+    error?: Error;
+    errorInfo?: React.ErrorInfo;
+    showDetails: boolean;
+}
+export declare class ErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): Partial<State>;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    copyErrorDetails: () => void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element;
+}
+export default ErrorBoundary;

package/dist/components/layout/AppHeader.d.ts

@@ -0,0 +1,63 @@
+import React from 'react';
+/**
+ * AppHeader Component
+ *
+ * Header principal da aplicação com:
+ * - Título e subtítulo da página
+ * - Busca global integrada ao CRUD
+ * - Botão de refresh
+ * - Informações do usuário e seleção de unidade
+ *
+ * @example
+ * ```tsx
+ * <AppHeader actions={<Button>Nova Ação</Button>} />
+ * ```
+ *
+ * ## 🔍 Busca Global
+ *
+ * A busca é exibida automaticamente quando `isSearchVisible = true` no AuthContext.
+ *
+ * **Características:**
+ * - ⏱️ Debounce de 500ms (configurável via SEARCH_CONFIG.debounceDelay)
+ * - 🔗 Sincroniza com URL (?search=termo)
+ * - ♻️ Reset automático para página 1 ao buscar
+ * - 🎯 Integração automática com useCrud
+ *
+ * **Configurar campos pesquisáveis:**
+ * ```typescript
+ * // No service
+ * createSimpleService({
+ *   tableName: 'items',
+ *   searchFields: ['name', 'description', 'code'], // 🔍 Campos de busca
+ * });
+ * ```
+ *
+ * **Customizar placeholder:**
+ * ```tsx
+ * // Opção 1: Modificar diretamente no AppHeader (linha ~102)
+ * <Input placeholder="Buscar artigos..." />
+ *
+ * // Opção 2: Por rota (já implementado)
+ * location.pathname === '/wiki' ? "Buscar artigos..." : "Buscar..."
+ * ```
+ *
+ * **Controle programático:**
+ * ```typescript
+ * const [searchParams, setSearchParams] = useSearchParams();
+ *
+ * // Definir busca
+ * const newParams = new URLSearchParams(searchParams);
+ * newParams.set('search', 'termo');
+ * newParams.set('page', '1');
+ * setSearchParams(newParams);
+ *
+ * // Limpar busca
+ * newParams.delete('search');
+ * setSearchParams(newParams);
+ * ```
+ */
+interface AppHeaderProps {
+    actions?: React.ReactNode;
+}
+declare const AppHeader: React.NamedExoticComponent<AppHeaderProps>;
+export default AppHeader;

package/dist/components/layout/AppLayout.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { SidebarConfig } from '../../types/sidebar';
+interface AppLayoutProps {
+    children: ReactNode;
+    sidebar?: ReactNode;
+    sidebarConfig?: SidebarConfig;
+    showHeader?: boolean;
+}
+export declare const AppLayout: import("react").NamedExoticComponent<AppLayoutProps>;
+export {};

package/dist/components/layout/AppSidebar.d.ts

@@ -0,0 +1,10 @@
+import { SidebarConfig } from '../../types/sidebar';
+interface AppSidebarProps {
+    config?: SidebarConfig;
+    customContent?: React.ReactNode;
+    resizable?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+}
+export declare function AppSidebar({ config, customContent, resizable, minWidth, maxWidth }?: AppSidebarProps): import("react/jsx-runtime").JSX.Element;
+export default AppSidebar;

package/dist/components/layout/BodyContent.d.ts

@@ -0,0 +1,60 @@
+import * as React from "react";
+export interface BreadcrumbItemConfig {
+    /** Texto do item */
+    label: string;
+    /** Link de navegação (não incluir para página atual) */
+    href?: string;
+    /** Componente customizado para o link (ex: Link do React Router) */
+    asChild?: boolean;
+    /** Elemento filho quando asChild é true */
+    children?: React.ReactNode;
+}
+export interface BodyContentProps {
+    /** Itens do breadcrumb */
+    breadcrumbs?: BreadcrumbItemConfig[];
+    /** Conteúdo principal */
+    children: React.ReactNode;
+    /** Classes CSS adicionais para o container externo */
+    className?: string;
+}
+export interface ContentContainerProps {
+    /** Título do container (opcional) */
+    title?: string;
+    /** Subtítulo do container (opcional) */
+    subtitle?: string;
+    /** Conteúdo do container */
+    children?: React.ReactNode;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Se o container tem header com título/subtítulo separado do conteúdo */
+    hasHeader?: boolean;
+}
+/**
+ * Container de conteúdo branco com título e subtítulo opcionais.
+ * Pode ser usado múltiplas vezes dentro do BodyContent.
+ */
+export declare function ContentContainer({ title, subtitle, children, className, hasHeader, }: ContentContainerProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * BodyContent - Container principal de página
+ *
+ * Componente de layout que encapsula o conteúdo da página com:
+ * - Background na cor Escala Neutra 100 (#F5F5F5)
+ * - Breadcrumb no topo
+ * - Suporte a múltiplos ContentContainers
+ *
+ * @example
+ * ```tsx
+ * <BodyContent
+ *   breadcrumbs={[
+ *     { label: 'Módulo', href: '/modulo' },
+ *     { label: 'Seção 1', href: '/modulo/secao1' },
+ *     { label: 'Seção 2' }, // Página atual (sem href)
+ *   ]}
+ * >
+ *   <ContentContainer title="Título" subtitle="Subtítulo">
+ *     Conteúdo aqui
+ *   </ContentContainer>
+ * </BodyContent>
+ * ```
+ */
+export declare function BodyContent({ breadcrumbs, children, className, }: BodyContentProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/layout/SidebarActionTrigger.d.ts

@@ -0,0 +1,34 @@
+import { SidebarActionsConfig } from '../../types/sidebar';
+export interface SidebarActionTriggerProps {
+    /** Configuração das ações do módulo */
+    config: SidebarActionsConfig;
+    /** Se a sidebar está colapsada (modo ícone) */
+    isCollapsed?: boolean;
+    /** Desabilita o gatilho (ex: quando há modais abertos) */
+    isDisabled?: boolean;
+    /** Classes adicionais */
+    className?: string;
+}
+/**
+ * SidebarActionTrigger - Gatilho de ações principais do módulo
+ *
+ * Exibe um botão de ação destacado no topo do sidebar.
+ * - Uma ação: executa diretamente ao clicar
+ * - Múltiplas ações: exibe dropdown com opções
+ *
+ * @example
+ * ```tsx
+ * <SidebarActionTrigger
+ *   config={{
+ *     triggerLabel: 'Criar',
+ *     actions: [
+ *       { id: 'new-item', label: 'Novo Item', onClick: () => openDialog() }
+ *     ]
+ *   }}
+ *   isCollapsed={!open}
+ *   isDisabled={hasOpenModal}
+ * />
+ * ```
+ */
+export declare function SidebarActionTrigger({ config, isCollapsed, isDisabled, className, }: SidebarActionTriggerProps): import("react/jsx-runtime").JSX.Element;
+export default SidebarActionTrigger;

package/dist/components/layout/SidebarHeader.d.ts

@@ -0,0 +1,5 @@
+export interface SidebarHeaderProps {
+    open: boolean;
+    appName?: string;
+}
+export declare function SidebarHeader({ open, appName }: SidebarHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/layout/sidebar-utils.d.ts

@@ -0,0 +1,12 @@
+export declare const SIDEBAR_PINNED_KEY = "forlogic-sidebar-pinned";
+export declare const getSidebarPinnedPreference: () => boolean;
+export declare const setSidebarPinnedPreference: (isPinned: boolean) => void;
+export declare const getColorVariant: (index: number) => string;
+interface Module {
+    id: string;
+    name: string;
+    url?: string;
+    status: 'active' | 'inactive';
+}
+export declare const handleModuleClick: (modules: Module[] | undefined, moduleUrl: string) => void;
+export {};

package/dist/components/modules/ModuleGrid.d.ts

@@ -0,0 +1,9 @@
+import { Module } from "./types";
+interface ModuleGridProps {
+    modules: Module[];
+    onModuleClick?: (module: Module) => void;
+    contractedModules?: string[];
+    onModuleInterest?: (module: Module) => void;
+}
+export declare function ModuleGrid({ modules, onModuleClick, contractedModules, onModuleInterest, }: ModuleGridProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/modules/ModulesDialog.d.ts

@@ -0,0 +1,3 @@
+import { ModulesDialogProps } from "./types";
+export declare function ModulesDialog({ open, onOpenChange, onModuleClick, contractedModules, onModuleInterest, educaUrl, saberGestaoUrl, wikiUrl, }: ModulesDialogProps): import("react/jsx-runtime").JSX.Element;
+export default ModulesDialog;

package/dist/components/modules/icons/ModulesCardIcons.d.ts

@@ -0,0 +1,19 @@
+interface IconProps {
+    className?: string;
+}
+/**
+ * Ícone outline do Qualiex para marca d'água
+ * Usado no card "Aprenda a usar o Qualiex"
+ */
+export declare function QualiexOutlineIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Ícone outline do Saber Gestão para marca d'água
+ * Usado no card "Conheça o Saber Gestão"
+ */
+export declare function SaberGestaoOutlineIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Ícone de livro/wiki para marca d'água
+ * Usado no card "Dúvidas sobre os módulos?"
+ */
+export declare function WikiOutlineIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,4 @@
+export { ModulesDialog } from './ModulesDialog';
+export { ModuleGrid } from './ModuleGrid';
+export { MODULES_DATA } from './modulesData';
+export type { ModulesDialogProps, Module, ModuleGroup } from './types';

package/dist/components/modules/modulesData.d.ts

@@ -0,0 +1,6 @@
+import { ModuleGroup } from "./types";
+/**
+ * Dados dos módulos organizados por grupo.
+ * Cores no formato 'bg-[#HEX]' para cores precisas baseadas no design.
+ */
+export declare const MODULES_DATA: ModuleGroup[];

package/dist/components/modules/types.d.ts

@@ -0,0 +1,35 @@
+import React from "react";
+import { OnboardingStep } from "../ui/onboarding-dialog";
+export interface Module {
+    name: string;
+    description?: string;
+    color: string;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    url?: string;
+    /** Steps do onboarding para módulos não contratados */
+    onboardingSteps?: OnboardingStep[];
+}
+export interface ModuleGroup {
+    id: string;
+    label: string;
+    modules: Module[];
+}
+export interface ModulesDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onModuleClick?: (module: Module) => void;
+    /** Lista de nomes de módulos contratados. Se não fornecido, todos aparecem como contratados. */
+    contractedModules?: string[];
+    /** Callback quando usuário mostra interesse em módulo não contratado (após onboarding) */
+    onModuleInterest?: (module: Module) => void;
+    /** URL do Forlogic Educa */
+    educaUrl?: string;
+    /** URL do Saber Gestão */
+    saberGestaoUrl?: string;
+    /** @deprecated Use educaUrl. URL da wiki (mantido para compatibilidade) */
+    wikiUrl?: string;
+    /** @deprecated Não mais utilizado no novo layout */
+    allModulesUrl?: string;
+}

package/dist/components/ui/accordion.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+declare const Accordion: React.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/components/ui/action-button.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import { type ButtonProps } from './button';
+interface ActionButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    children?: React.ReactNode;
+    variant?: ButtonProps['variant'];
+}
+/**
+ * Botão estilizado para ações em tabelas e menus
+ *
+ * Botão pequeno otimizado para actions em linhas de tabela, com estilo
+ * consistente usando cores do tema (primary).
+ *
+ * **Características:**
+ * - Tamanho compacto (height: 28px, padding: 8px)
+ * - Ícone padrão: três pontos verticais (EllipsisVertical)
+ * - Estilo padrão: fundo azul claro (bg-primary/10), hover com primary/20
+ * - Variante action-secondary disponível para contextos secundários
+ * - Perfeito para menus de ação em linhas de tabela
+ *
+ * @example
+ * ```typescript
+ * import { ActionButton } from 'forlogic-core';
+ *
+ * // Botão de ações com ícone padrão (três pontos)
+ * <ActionButton onClick={() => setMenuOpen(true)} />
+ *
+ * // Botão customizado com ícone próprio
+ * <ActionButton>
+ *   <Edit size={12} />
+ * </ActionButton>
+ *
+ * // Variante secundária
+ * <ActionButton variant="action-secondary">
+ *   <LayoutGrid size={12} />
+ * </ActionButton>
+ * ```
+ *
+ * @param props.children Conteúdo customizado (default: ícone de três pontos)
+ * @param props.variant Variante do botão (default: "action")
+ * @param props.className Classes CSS adicionais
+ */
+export declare const ActionButton: React.ForwardRefExoticComponent<ActionButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export {};