forlogic-core 2.2.7 → 2.3.0

package/dist/places/components/ui/updates-notification.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { type UpdateNotificationItem } from '../../hooks/useUpdatesNotification';
+/** @deprecated Use `UpdateNotificationItem` instead */
+export type UpdateNotification = UpdateNotificationItem;
+export type { UpdateNotificationItem };
+/**
+ * Props do `UpdatesNotification`. Quando `updates` é `undefined`, ativa o modo
+ * automático (busca da API via `useUpdatesNotification`); quando é um array,
+ * o componente fica controlado.
+ *
+ * @example
+ * ```tsx
+ * // Modo controlado:
+ * const props: UpdatesNotificationProps = { updates: [], badgeCount: 0 };
+ * ```
+ */
+export interface UpdatesNotificationProps {
+    /** Lista de atualizações (undefined = modo automático, [] = vazio controlado) */
+    updates?: UpdateNotificationItem[];
+    /** Badge numérico (undefined = modo automático) */
+    badgeCount?: number;
+    onOpen?: () => void;
+    onViewAll?: () => void;
+}
+/**
+ * Botão de notificações do header (ícone de café ☕). Possui dois modos:
+ *
+ * - **Automático** (sem props): busca atualizações via `useUpdatesNotification`,
+ *   marca como visualizado ao abrir e abre o portal Qualiex no "Ver todas".
+ * - **Controlado**: passe `updates` + `badgeCount` + `onOpen` + `onViewAll`.
+ *
+ * @example Automático (recomendado dentro do AppHeader)
+ * ```tsx
+ * <UpdatesNotification />
+ * ```
+ *
+ * @example Controlado
+ * ```tsx
+ * <UpdatesNotification
+ *   updates={updates}
+ *   badgeCount={updates.length}
+ *   onOpen={markAllRead}
+ *   onViewAll={() => navigate('/updates')}
+ * />
+ * ```
+ */
+export declare const UpdatesNotification: React.ForwardRefExoticComponent<UpdatesNotificationProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/places/components/ui/users-groups-selector.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Usuário disponível para seleção. `groupIds` permite o filtro por grupo no header.
+ *
+ * @example
+ * ```tsx
+ * const u: UsersGroupUser = { id: '42', name: 'Ana', email: 'ana@x.com', groupIds: ['g1'] };
+ * ```
+ */
+export interface UsersGroupUser {
+    id: string;
+    name: string;
+    email?: string;
+    avatar?: string;
+    groupIds?: string[];
+}
+/**
+ * Grupo usado para filtrar a lista de usuários.
+ *
+ * @example
+ * ```tsx
+ * const g: UsersGroup = { id: 'g1', name: 'Liderança' };
+ * ```
+ */
+export interface UsersGroup {
+    id: string;
+    name: string;
+}
+/**
+ * Props do `UsersGroupsSelector`. Componente controlado: passe `value` (IDs
+ * selecionados) + `onChange`. Quando `disabled`, esconde o header de edição.
+ *
+ * @example
+ * ```tsx
+ * const props: UsersGroupsSelectorProps = {
+ *   users, groups, value, onChange: setSelected
+ * };
+ * ```
+ */
+export interface UsersGroupsSelectorProps {
+    /** Available users to select from */
+    users: UsersGroupUser[];
+    /** Available groups for filtering */
+    groups?: UsersGroup[];
+    /** Currently selected user IDs (controlled) */
+    value: string[];
+    /** Called when selection changes */
+    onChange: (selectedIds: string[]) => void;
+    /** Whether the component is editable */
+    disabled?: boolean;
+    /** Max height of the user list in px */
+    maxHeight?: number;
+    /** Hide the group filter dropdown */
+    hideGroupFilter?: boolean;
+    /** Placeholder for search input */
+    searchPlaceholder?: string;
+    /** Label for "Select" action */
+    selectLabel?: string;
+    /** Label for "Done" action */
+    doneLabel?: string;
+    /** Label for "All" checkbox */
+    allLabel?: string;
+    /** Label for empty state */
+    emptyLabel?: string;
+    /** Label for selected count (singular) */
+    selectedLabel?: string;
+    /** Label for selected count (plural) */
+    selectedPluralLabel?: string;
+    /** Additional className */
+    className?: string;
+}
+/**
+ * Seletor de usuários com avatar, busca por nome/email, filtro por grupo e
+ * "selecionar todos". Possui dois modos visuais alternados pelo header:
+ * **leitura** (mostra apenas selecionados) e **edição** (lista completa filtrável).
+ *
+ * @example
+ * ```tsx
+ * const [selected, setSelected] = useState<string[]>([]);
+ * <UsersGroupsSelector
+ *   users={users}
+ *   groups={groups}
+ *   value={selected}
+ *   onChange={setSelected}
+ * />
+ * ```
+ */
+export declare function UsersGroupsSelector({ users, groups, value, onChange, disabled, maxHeight, hideGroupFilter, searchPlaceholder, selectLabel, doneLabel, allLabel, emptyLabel, selectedLabel, selectedPluralLabel, className, }: UsersGroupsSelectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/places/components/ui/viewer-dialog.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Tipos de viewer suportados pelo `ViewerDialog`. Resolvido automaticamente
+ * pela extensão do arquivo via `getViewerType`.
+ *
+ * @example
+ * ```tsx
+ * if (type === FileViewerType.image) { ... }
+ * ```
+ */
+export declare enum FileViewerType {
+    none = 0,
+    image = 1,
+    video = 2,
+    audio = 3,
+    wopi = 4,
+    onlineEditor = 5,
+    report = 6
+}
+/**
+ * Modo de impressão para documentos controlados (cópia gerenciada / não gerenciada).
+ *
+ * @example
+ * ```tsx
+ * config.printType = FilePrintType.ManagedCopy;
+ * ```
+ */
+export declare enum FilePrintType {
+    SimplePrint = 0,
+    ManagedCopy = 1,
+    NonManagedCopy = 2
+}
+/**
+ * Descritor de um arquivo a ser visualizado pelo `ViewerDialog`.
+ *
+ * @example
+ * ```tsx
+ * const tpl: FileViewerTemplate = { name: 'manual.pdf', extension: '.pdf', url: '/files/123' };
+ * ```
+ */
+export interface FileViewerTemplate {
+    code?: string;
+    name: string;
+    extension?: string;
+    url: string;
+}
+/**
+ * Configuração para visualização de documentos controlados (Qualiex).
+ * Reúne callbacks para criação de cópia física e marca d'água.
+ *
+ * @example
+ * ```tsx
+ * const cfg: ViewerDocumentControlConfig = { isControlledDocument: true, physicalCopyCode: 'C-001' };
+ * ```
+ */
+export interface ViewerDocumentControlConfig {
+    isControlledDocument?: boolean;
+    physicalCopyCode?: string | null;
+    physicalCopyId?: string | null;
+    watermarkedFileId?: string | null;
+    watermarkedFileRevisionId?: string | null;
+    handlePhysicalCopyCreationCallback?: (fileId: string) => Promise<Record<string, any> | null>;
+    handleAddNonManagedCopyWatermarkCallback?: (fileId: string, justification?: string | null, revisionId?: string) => Promise<Record<string, any> | null>;
+    askUserForPrintOrDownloadConfirmationCallback?: (params: {
+        contextId: string;
+        categoryId?: string;
+        isDownload?: boolean;
+    }) => Promise<any>;
+}
+/**
+ * Props do `ViewerDialog`. Suporta imagem, vídeo, áudio, PDF/Office (WOPI),
+ * editor online (Google Docs) e relatórios (iframe genérico).
+ *
+ * @example
+ * ```tsx
+ * const props: ViewerDialogProps = { open, onOpenChange, template };
+ * ```
+ */
+export interface ViewerDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The file template to display (name, code, url, extension) */
+    template: FileViewerTemplate;
+    /** Which viewer type to use. If not provided, it's auto-detected from extension. */
+    viewerType?: FileViewerType;
+    /** Show loading state */
+    isLoading?: boolean;
+    /** Enable download button */
+    enableDownload?: boolean;
+    onDownload?: () => void | Promise<void>;
+    isDownloading?: boolean;
+    /** Enable favorite button */
+    enableFavorite?: boolean;
+    isFavorite?: boolean;
+    onFavorite?: (currentState: boolean) => void | Promise<void>;
+    isFavoriting?: boolean;
+    /** Reading confirmation */
+    enableConfirmReading?: boolean;
+    readingConfirmationDate?: Date;
+    onConfirmReading?: () => void | Promise<void>;
+    isConfirmingReading?: boolean;
+    /** Reading confirmation timer (seconds remaining) */
+    readingConfirmationTimeRemaining?: number;
+    /** Called when iframe loads (for report/wopi types) */
+    onIframeLoad?: (iframe: HTMLIFrameElement) => void;
+    /** Custom className for the dialog */
+    className?: string;
+}
+/**
+ * Resolve o `FileViewerType` a partir da extensão do arquivo (case-insensitive).
+ * Retorna `FileViewerType.none` quando a extensão não é suportada.
+ *
+ * @example
+ * ```tsx
+ * getViewerType('.pdf'); // FileViewerType.wopi
+ * getViewerType('.png'); // FileViewerType.image
+ * ```
+ */
+export declare function getViewerType(extension?: string): FileViewerType;
+/**
+ * Resolve qual editor online (Google Docs vs Sheets) deve ser usado pela extensão.
+ *
+ * @example
+ * ```tsx
+ * getOnlineViewerType('.gsheets'); // 'spreadsheets'
+ * ```
+ */
+export declare function getOnlineViewerType(extension: string): 'document' | 'spreadsheets';
+/**
+ * Resolve a rota WOPI (Office Web Apps) para a extensão informada.
+ * Retorna string vazia quando não suportado.
+ *
+ * @example
+ * ```tsx
+ * getWopiViewer('.docx'); // 'wv/wordviewerframe.aspx?'
+ * ```
+ */
+export declare function getWopiViewer(extension: string): string;
+/**
+ * Constrói a URL completa do WOPI viewer com query params (`access_token`, `WOPISrc`, `ui`).
+ * Retorna `null` se a extensão não tiver viewer WOPI mapeado.
+ *
+ * @example
+ * ```tsx
+ * const url = buildWopiUrl({
+ *   viewerUrl: 'https://wopi.qualiex.com/',
+ *   wopiUrl: 'https://api.qualiex.com/wopi/files/',
+ *   fileId: '42',
+ *   token: 'abc',
+ *   extension: '.pdf',
+ * });
+ * ```
+ */
+export declare function buildWopiUrl(params: {
+    viewerUrl: string;
+    wopiUrl: string;
+    fileId: string;
+    token: string;
+    extension: string;
+    language?: string;
+}): string | null;
+/**
+ * Dialog full-screen para visualizar arquivos de qualquer tipo. Detecta
+ * automaticamente o viewer apropriado pela extensão (`getViewerType`):
+ * imagem (`<img>`), vídeo (`<video>`), áudio (`<audio>`), PDF/Office (iframe WOPI),
+ * editor online (Google Docs/Sheets) ou relatório (iframe).
+ *
+ * Recursos do header: botão de download, favoritar e confirmação de leitura
+ * (com timer mínimo opcional). Fecha com **ESC** ou clique no X.
+ *
+ * @example
+ * ```tsx
+ * <ViewerDialog
+ *   open={open}
+ *   onOpenChange={setOpen}
+ *   template={{ name: 'Manual.pdf', extension: '.pdf', url: pdfUrl }}
+ *   enableDownload
+ *   onDownload={handleDownload}
+ * />
+ * ```
+ *
+ * @see `docs/design-system/dialogs.md`
+ */
+export declare function ViewerDialog({ open, onOpenChange, template, viewerType: viewerTypeProp, isLoading, enableDownload, onDownload, isDownloading, enableFavorite, isFavorite, onFavorite, isFavoriting, enableConfirmReading, readingConfirmationDate, onConfirmReading, isConfirmingReading, readingConfirmationTimeRemaining, onIframeLoad, className, }: ViewerDialogProps): import("react/jsx-runtime").JSX.Element;
+export default ViewerDialog;

package/dist/places/config/backend.d.ts

@@ -0,0 +1,10 @@
+export type BackendMode = 'supabase' | 'dotnet';
+/**
+ * Define o backend ativo da aplicação. Deve ser chamado o mais cedo possível
+ * (normalmente pelo `CoreProviders`) antes que `AuthService.initialize()` rode.
+ */
+export declare function setBackendMode(mode: BackendMode): void;
+/** Retorna o backend ativo. Default: `'supabase'`. */
+export declare function getBackendMode(): BackendMode;
+/** True se o backend ativo é Supabase. */
+export declare function isSupabaseBackend(): boolean;

package/dist/places/config/environments.d.ts

@@ -0,0 +1,12 @@
+declare const PROD_PROJECT_ID = "ccjfvpnndclajkleyqkc";
+export interface EnvironmentConfig {
+    storageProjectId: string;
+    oauth: {
+        authUrl: string;
+        clientId: string;
+    };
+    qualiexApiUrl: string;
+}
+export declare function getEnvironmentConfig(): EnvironmentConfig;
+export declare function isDevSupabaseProject(): boolean;
+export { PROD_PROJECT_ID };

package/dist/places/config/index.d.ts

@@ -0,0 +1,75 @@
+export declare const AUTH_CONFIG: {
+    readonly oauth: {
+        authUrl: string;
+        clientId: string;
+        responseType: string;
+        scope: string;
+    };
+};
+export declare const CRUD_CONFIG: {
+    readonly pagination: {
+        readonly defaultPageSize: 25;
+        readonly pageSizeOptions: readonly [10, 25, 50, 100];
+    };
+    readonly sorting: {
+        readonly defaultField: "updated_at";
+        readonly defaultDirection: "desc";
+    };
+};
+export declare const SEARCH_CONFIG: {
+    readonly debounceDelay: 500;
+};
+export declare const isLovablePreview: () => boolean;
+/**
+ * Determines auth method: true → use dev-tokens edge function, false → use OAuth.
+ * This is independent of which API environment (prod/dev) is used — that's decided
+ * by getEnvironmentConfig() based on the Supabase project ID.
+ */
+export declare const shouldUseDevTokens: () => boolean;
+/** @deprecated Use `isLovablePreview()` or `shouldUseDevTokens()` instead */
+export declare const isDevEnvironment: () => boolean;
+export { isDevSupabaseProject } from './environments';
+export declare const getQualiexApiUrl: () => string;
+export declare const QUERY_KEYS: {
+    readonly crud: (entity: string) => readonly [string];
+    readonly list: (entity: string, filters?: Record<string, any>) => readonly [string, "list", Record<string, any>];
+    readonly detail: (entity: string, id: string) => readonly [string, "detail", string];
+};
+export declare const QUALIEX_CONFIG: {
+    readonly userNameFieldSuffix: "_name";
+    readonly userEmailFieldSuffix: "_email";
+    readonly userUsernameFieldSuffix: "_username";
+};
+export declare const LOGO_CONFIG: {
+    readonly isQualiex: boolean;
+};
+export declare const MESSAGES: {
+    readonly success: {
+        readonly created: (entity: string) => string;
+        readonly updated: (entity: string) => string;
+        readonly deleted: (entity: string) => string;
+    };
+    readonly error: {
+        readonly create: (entity: string) => string;
+        readonly update: (entity: string) => string;
+        readonly delete: (entity: string) => string;
+        readonly load: (entity: string) => string;
+    };
+};
+/**
+ * Creates translated MESSAGES using a i18n.t() function with PT fallbacks.
+ * Safe for projects without i18n — falls back to Portuguese defaults.
+ */
+export declare const createTranslatedMessages: (t: (key: string, defaultValue: string) => string) => {
+    success: {
+        created: (entity: string) => string;
+        updated: (entity: string) => string;
+        deleted: (entity: string) => string;
+    };
+    error: {
+        create: (entity: string) => string;
+        update: (entity: string) => string;
+        delete: (entity: string) => string;
+        load: (entity: string) => string;
+    };
+};

package/dist/places/contexts/LocaleContext.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+interface LocaleContextType {
+    locale: string;
+    timezone: string;
+    datetimeFormat: string;
+    setLocale: (locale: string) => Promise<void>;
+    setTimezone: (timezone: string) => Promise<void>;
+    setDatetimeFormat: (format: string) => Promise<void>;
+    isLoading: boolean;
+}
+export declare const LocaleProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useLocale: () => LocaleContextType;
+export {};

package/dist/places/contexts/ModalStateContext.d.ts

@@ -0,0 +1,57 @@
+import React from 'react';
+interface ModalStateContextValue {
+    /** IDs dos modais atualmente abertos */
+    openModals: Set<string>;
+    /** Indica se há pelo menos um modal aberto */
+    hasOpenModal: boolean;
+    /** Registra um modal como aberto */
+    registerModal: (id: string) => void;
+    /** Remove um modal do registro */
+    unregisterModal: (id: string) => void;
+    /** Define diretamente se há modal aberto (uso simplificado) */
+    setHasOpenModal: (value: boolean) => void;
+}
+declare const ModalStateContext: React.Context<ModalStateContextValue>;
+export interface ModalStateProviderProps {
+    children: React.ReactNode;
+}
+/**
+ * ModalStateProvider - Gerencia o estado global de modais abertos
+ *
+ * Permite que componentes como o SidebarActionTrigger saibam quando
+ * há modais abertos e se desabilitem para evitar conflitos.
+ *
+ * @example
+ * ```tsx
+ * // No App.tsx ou provider root
+ * <ModalStateProvider>
+ *   <AppLayout />
+ * </ModalStateProvider>
+ *
+ * // Em um componente com modal
+ * const { registerModal, unregisterModal } = useModalState();
+ *
+ * useEffect(() => {
+ *   if (isOpen) {
+ *     registerModal('my-dialog');
+ *   } else {
+ *     unregisterModal('my-dialog');
+ *   }
+ * }, [isOpen]);
+ * ```
+ */
+export declare function ModalStateProvider({ children }: ModalStateProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook para acessar o estado global de modais
+ *
+ * @returns Estado e funções para gerenciar modais
+ * @throws Error se usado fora do ModalStateProvider
+ */
+export declare function useModalState(): ModalStateContextValue;
+/**
+ * Hook simplificado que retorna apenas se há modal aberto
+ *
+ * @returns boolean indicando se há modal aberto
+ */
+export declare function useHasOpenModal(): boolean;
+export default ModalStateContext;

package/dist/places/contexts/ModuleContext.d.ts

@@ -0,0 +1,34 @@
+import { ReactNode } from 'react';
+interface ModuleContextType {
+    /** Alias do módulo configurado pelo projeto consumidor (ex: 'performance', 'suppliers') */
+    moduleAlias: string | null;
+}
+export interface ModuleProviderProps {
+    /** Alias do módulo do projeto consumidor */
+    moduleAlias?: string | null;
+    children: ReactNode;
+}
+/**
+ * Provider que armazena o alias do módulo configurado pelo projeto consumidor.
+ *
+ * Usado internamente pelo CoreProviders — normalmente não é necessário usar diretamente.
+ *
+ * @example
+ * ```tsx
+ * <ModuleProvider moduleAlias="performance">
+ *   <App />
+ * </ModuleProvider>
+ * ```
+ */
+export declare function ModuleProvider({ moduleAlias, children }: ModuleProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook para acessar o alias do módulo configurado pelo projeto consumidor.
+ *
+ * @example
+ * ```tsx
+ * const { moduleAlias } = useModuleConfig();
+ * // moduleAlias = 'performance' (conforme configurado no CoreProviders)
+ * ```
+ */
+export declare function useModuleConfig(): ModuleContextType;
+export {};

package/dist/places/contexts/NavigationContext.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { SidebarConfig } from '../types/sidebar';
+interface NavigationContextType {
+    navigation?: SidebarConfig['navigation'];
+    appName?: string;
+}
+interface NavigationProviderProps {
+    children: ReactNode;
+    config?: SidebarConfig;
+}
+export declare function NavigationProvider({ children, config }: NavigationProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useNavigation(): NavigationContextType;
+export {};

package/dist/places/contexts/PageMetadataContext.d.ts

@@ -0,0 +1,48 @@
+import { ReactNode } from 'react';
+export interface PageBreadcrumbItem {
+    label: string;
+    href?: string;
+}
+interface PageMetadata {
+    title?: string;
+    subtitle?: ReactNode;
+    breadcrumbs?: PageBreadcrumbItem[];
+}
+interface PageMetadataContextType {
+    metadata: PageMetadata;
+    setMetadata: (metadata: PageMetadata) => void;
+    clearMetadata: () => void;
+    headerActions?: React.ReactNode;
+    setHeaderActions: (actions: React.ReactNode) => void;
+}
+interface PageMetadataProviderProps {
+    children: ReactNode;
+    actions?: React.ReactNode;
+}
+export declare function PageMetadataProvider({ children, actions }: PageMetadataProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function usePageMetadataContext(): PageMetadataContextType;
+/**
+ * Hook para definir metadados customizados da página (título e subtítulo)
+ *
+ * Permite que páginas definam informações no header:
+ * - title: Título principal (grande, bold)
+ * - subtitle: Informações adicionais abaixo do título (médio, cinza)
+ *
+ * @example
+ * ```typescript
+ * import { usePageMetadata } from 'forlogic-core/modular';
+ *
+ * function ImportFlowsPage() {
+ *   usePageMetadata({
+ *     title: t('import_flows'),
+ *     subtitle: t('import_manage')
+ *   });
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ *
+ * @param metadata - Objeto com title e/ou subtitle customizados
+ */
+export declare function usePageMetadata(metadata: PageMetadata): void;
+export {};

package/dist/places/crud/components/ActionMenuItems.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+interface ActionMenuItemsProps {
+    onEdit?: () => void;
+    onDelete?: () => void;
+    onToggleStatus?: () => void;
+    isActive?: boolean;
+    canDelete?: boolean;
+    customActions?: Array<{
+        icon: any;
+        label: string;
+        onClick: () => void;
+        destructive?: boolean;
+    }>;
+    renderAs: 'dropdown' | 'context';
+}
+/**
+ * Componente `ActionMenuItems` da lib.
+ * @example
+ * <ActionMenuItems />
+ */
+export declare const ActionMenuItems: React.FC<ActionMenuItemsProps>;
+export {};

package/dist/places/crud/components/BaseForm.d.ts

@@ -0,0 +1,52 @@
+import type { BaseFormProps } from '../../types';
+/**
+ * Formulário modal genérico baseado em configuração declarativa de seções e campos.
+ *
+ * Renderiza um `Dialog` com navegação por seções (sidebar) quando há 2+ seções, ou um único
+ * painel para forms simples. Suporta os tipos: `text`, `number`, `select`, `multiselect`,
+ * `textarea`, `switch`, `checkbox`, `color`, `icon`, `qualiex-user` e custom render.
+ *
+ * Normalmente é renderizado automaticamente por `createCrudPage` — use diretamente apenas
+ * para forms standalone (fora do pipeline CRUD).
+ *
+ * @example
+ * const sections: FormSection[] = [
+ *   {
+ *     id: 'general',
+ *     title: 'Dados gerais',
+ *     fields: [
+ *       { key: 'title', label: 'Título', type: 'text', required: true },
+ *       { key: 'description', label: 'Descrição', type: 'textarea' },
+ *       {
+ *         key: 'status',
+ *         label: 'Status',
+ *         type: 'select',
+ *         options: [
+ *           { label: 'Ativo', value: 'active' },
+ *           { label: 'Pausado', value: 'paused' },
+ *         ],
+ *       },
+ *     ],
+ *   },
+ *   {
+ *     id: 'responsible',
+ *     title: 'Responsável',
+ *     fields: [{ key: 'id_user', label: 'Usuário', type: 'qualiex-user', required: true }],
+ *   },
+ * ];
+ *
+ * <BaseForm
+ *   open={isOpen}
+ *   title="Novo plano de ação"
+ *   sections={sections}
+ *   initialData={editing ?? undefined}
+ *   isLoading={manager.isCreating || manager.isUpdating}
+ *   onSubmit={(data) => onSave(data)}
+ *   onCancel={() => setIsOpen(false)}
+ * />
+ */
+declare function BaseForm<T extends Record<string, any>>({ title, sections, initialData, onSubmit, onCancel, open, submitButtonText, isLoading, usersData }: BaseFormProps<T> & {
+    usersData?: any[];
+    isLoading?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export default BaseForm;