forlogic-core 1.15.2 → 1.15.4

package/dist/leadership/components/LeaderRow.d.ts

@@ -0,0 +1,9 @@
+import { LeaderNode, Leader } from '../types';
+interface LeaderRowProps {
+    leader: LeaderNode;
+    expandedIds: Set<string>;
+    onToggleExpand: (id: string) => void;
+    onEdit: (leader: Leader) => void;
+}
+export declare function LeaderRow({ leader, expandedIds, onToggleExpand, onEdit }: LeaderRowProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/leadership/components/LeadershipDialog.d.ts

@@ -0,0 +1,10 @@
+import { Leader } from '../types';
+interface LeadershipDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    leader?: Leader;
+    prefilledLeaderId?: string | null;
+    title: string;
+}
+export declare function LeadershipDialog({ open, onOpenChange, leader, prefilledLeaderId, title }: LeadershipDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/leadership/components/LeadershipForm.d.ts

@@ -0,0 +1,8 @@
+import { Leader } from '../types';
+interface LeadershipFormProps {
+    leader?: Leader;
+    prefilledLeaderId?: string | null;
+    onSuccess?: () => void;
+}
+export declare function LeadershipForm({ leader, prefilledLeaderId, onSuccess }: LeadershipFormProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/leadership/components/LeadershipPage.d.ts

@@ -0,0 +1 @@
+export declare function LeadershipPage(): import("react/jsx-runtime").JSX.Element;

package/dist/leadership/hooks/useLeadershipApi.d.ts

@@ -0,0 +1,2 @@
+import { LeaderNode } from '../types';
+export declare function useLeadershipApi(): import("@tanstack/react-query").UseQueryResult<LeaderNode[], Error>;

package/dist/leadership/hooks/useLeadershipMutations.d.ts

@@ -0,0 +1,30 @@
+interface CreateLeaderData {
+    id_user: string;
+    id_leader: string | null;
+}
+interface CreateMultipleLeadersData {
+    id_leader: string | null;
+    users: Array<{
+        id_user: string;
+    }>;
+}
+interface UpdateLeaderData {
+    id: string;
+    id_leader: string | null;
+}
+export declare function useCreateLeaderMutation(): import("@tanstack/react-query").UseMutationResult<any, Error, CreateLeaderData, unknown>;
+export declare function useCreateSingleLeaderMutation(): import("@tanstack/react-query").UseMutationResult<any, Error, CreateLeaderData, unknown>;
+export declare function useCreateMultipleLeadersMutation(): import("@tanstack/react-query").UseMutationResult<any, Error, CreateMultipleLeadersData, unknown>;
+export declare function useUpdateLeaderMutation(): import("@tanstack/react-query").UseMutationResult<any, Error, UpdateLeaderData, unknown>;
+export declare function useRemoveLeaderMutation(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+export declare function useSyncSubordinatesMutation(): import("@tanstack/react-query").UseMutationResult<{
+    unlinked: number;
+    updated: number;
+    created: number;
+}, Error, {
+    leaderUserId: string;
+    selectedUsers: Array<{
+        id_user: string;
+    }>;
+}, unknown>;
+export {};

package/dist/leadership/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Leadership Module
+ *
+ * Componente hierárquico de liderança reutilizável para gerenciar
+ * relações de liderança entre usuários do Qualiex.
+ */
+export * from './types';
+export * from './utils/leadershipUtils';
+export * from './hooks/useLeadershipApi';
+export * from './hooks/useLeadershipMutations';
+export * from './components/LeadershipPage';
+export * from './components/LeaderRow';
+export * from './components/LeadershipDialog';
+export * from './components/LeadershipForm';

package/dist/leadership/types.d.ts

@@ -0,0 +1,17 @@
+export interface Leader {
+    id: string;
+    alias: string;
+    id_user: string;
+    id_leader: string | null;
+    is_removed: boolean;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+    name?: string;
+    email?: string;
+    subordinatesCount?: number;
+}
+export interface LeaderNode extends Leader {
+    children: LeaderNode[];
+    level: number;
+}

package/dist/leadership/utils/leadershipUtils.d.ts

@@ -0,0 +1,8 @@
+import { Leader, LeaderNode } from '../types';
+/**
+ * Filtra líderes inválidos (sem nome enriquecido) e promove seus filhos
+ * para o ancestral válido mais próximo ou para a raiz
+ */
+export declare function filterAndPromoteOrphans(leaders: Leader[], validUserIds: Set<string>): Leader[];
+export declare function buildHierarchy(leaders: Leader[]): LeaderNode[];
+export declare function flattenTree(nodes: LeaderNode[]): LeaderNode[];

package/dist/media/components/ImageEditor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Image Editor Component
+ *
+ * Editor genérico de imagem para forlogic-core.
+ * Suporta URL e upload de arquivos.
+ *
+ * @example
+ * ```tsx
+ * import { ImageEditor } from 'forlogic-core';
+ *
+ * <ImageEditor
+ *   value={imageData}
+ *   onChange={setImageData}
+ *   onSubmit={handleSave}
+ *   onCancel={handleCancel}
+ *   uploadFunction={myUploadFunction}
+ *   uploadOptions={{ bucket: 'images', folder: 'content' }}
+ * />
+ * ```
+ */
+import type { MediaEditorProps, ImageBlockContent } from '../types';
+export declare function ImageEditor({ value, onChange, onSubmit, onCancel, uploadFunction, deleteFunction, uploadOptions }: MediaEditorProps<ImageBlockContent>): import("react/jsx-runtime").JSX.Element;

package/dist/media/components/ImageRenderer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Image Renderer Component
+ *
+ * Renderizador genérico de imagem para forlogic-core.
+ * Suporta alinhamento, legenda, alt text e download.
+ *
+ * @example
+ * ```tsx
+ * import { ImageRenderer } from 'forlogic-core';
+ *
+ * <ImageRenderer
+ *   content={{
+ *     imageUrl: 'https://example.com/image.jpg',
+ *     caption: 'Minha imagem',
+ *     alt: 'Descrição da imagem',
+ *     alignment: 'center',
+ *     allowDownload: true
+ *   }}
+ * />
+ * ```
+ */
+import type { MediaRendererProps, ImageBlockContent } from '../types';
+export declare function ImageRenderer({ content, className, style }: MediaRendererProps<ImageBlockContent>): import("react/jsx-runtime").JSX.Element;

package/dist/media/components/VideoEditor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Video Editor Component
+ *
+ * Editor genérico de vídeo para forlogic-core.
+ * Suporta URL, upload e código embed.
+ *
+ * @example
+ * ```tsx
+ * import { VideoEditor } from 'forlogic-core';
+ *
+ * <VideoEditor
+ *   value={videoData}
+ *   onChange={setVideoData}
+ *   onSubmit={handleSave}
+ *   onCancel={handleCancel}
+ *   uploadFunction={myUploadFunction}
+ *   uploadOptions={{ bucket: 'videos', folder: 'content' }}
+ * />
+ * ```
+ */
+import type { MediaEditorProps, VideoBlockContent } from '../types';
+export declare function VideoEditor({ value, onChange, onSubmit, onCancel, uploadFunction, deleteFunction, uploadOptions }: MediaEditorProps<VideoBlockContent>): import("react/jsx-runtime").JSX.Element;

package/dist/media/components/VideoRenderer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Video Renderer Component
+ *
+ * Renderizador genérico de vídeo para forlogic-core.
+ * Suporta YouTube, Vimeo e arquivos diretos.
+ */
+import type { MediaRendererProps, VideoBlockContent } from '../types';
+export declare function VideoRenderer({ content, className, style }: MediaRendererProps<VideoBlockContent>): import("react/jsx-runtime").JSX.Element;

package/dist/media/hooks/useMediaUpload.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Generic Media Upload Hook
+ *
+ * Hook genérico para upload de mídia (imagens, vídeos, arquivos).
+ * Requer que o projeto forneça uma função de upload via props.
+ */
+import type { UploadResult, UploadFunction, UploadOptions, DeleteFunction } from '../types';
+export interface UseMediaUploadOptions {
+    uploadFunction?: UploadFunction;
+    deleteFunction?: DeleteFunction;
+    defaultOptions?: UploadOptions;
+    onSuccess?: (result: UploadResult) => void;
+    onError?: (error: Error) => void;
+}
+export declare function useMediaUpload(options?: UseMediaUploadOptions): {
+    upload: (file: File, uploadOptions?: UploadOptions) => Promise<UploadResult>;
+    deleteMedia: (path: string, bucket?: string) => Promise<void>;
+    uploading: boolean;
+    progress: number;
+};

package/dist/media/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Media Module
+ *
+ * Módulo genérico para gerenciamento de mídia (vídeo, imagem, áudio).
+ * Componentes reutilizáveis e independentes de contexto.
+ *
+ * @example Importar componentes
+ * ```tsx
+ * import { VideoEditor, VideoRenderer } from 'forlogic-core';
+ * ```
+ *
+ * @example Usar com função de upload customizada
+ * ```tsx
+ * import { VideoEditor } from 'forlogic-core';
+ * import { myUploadService } from './services/upload';
+ *
+ * function MyComponent() {
+ *   const uploadFunction = async (file, options) => {
+ *     const result = await myUploadService.upload(file, options.bucket, options.folder);
+ *     return {
+ *       url: result.publicUrl,
+ *       name: file.name,
+ *       size: file.size,
+ *       type: file.type,
+ *       path: result.path
+ *     };
+ *   };
+ *
+ *   return (
+ *     <VideoEditor
+ *       value={videoData}
+ *       uploadFunction={uploadFunction}
+ *       uploadOptions={{ bucket: 'videos', folder: 'content' }}
+ *       onSubmit={handleSave}
+ *       onCancel={handleCancel}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export type { UploadResult, UploadOptions, UploadFunction, DeleteFunction, VideoInputType, VideoProvider, VideoBlockContent, ImageBlockContent, MediaEditorProps, MediaRendererProps } from './types';
+export { VideoEditor } from './components/VideoEditor';
+export { VideoRenderer } from './components/VideoRenderer';
+export { ImageEditor } from './components/ImageEditor';
+export { ImageRenderer } from './components/ImageRenderer';
+export { useMediaUpload } from './hooks/useMediaUpload';
+export type { UseMediaUploadOptions } from './hooks/useMediaUpload';
+export { extractYouTubeId, normalizeYouTubeUrl, extractVimeoId, normalizeVimeoUrl, parseIframeSrc, detectVideoProvider, normalizeVideoUrl } from './utils/videoHelpers';
+export { calculateAspectRatio, resizeKeepingAspect, isImageUrl, extractImageFileName, formatFileSize } from './utils/imageHelpers';

package/dist/media/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Media Module Types
+ *
+ * Tipos genéricos para gerenciamento de mídia (vídeo, imagem, áudio)
+ * em aplicações que utilizam forlogic-core.
+ */
+export interface UploadResult {
+    url: string;
+    name: string;
+    size: number;
+    type: string;
+    path: string;
+    bucket?: string;
+}
+export interface UploadOptions {
+    bucket?: string;
+    folder?: string;
+    maxSize?: number;
+    allowedTypes?: string[];
+}
+export type UploadFunction = (file: File, options?: UploadOptions) => Promise<UploadResult>;
+export interface DeleteFunction {
+    (path: string, bucket?: string): Promise<void>;
+}
+export type VideoInputType = 'url' | 'upload' | 'embed';
+export type VideoProvider = 'youtube' | 'vimeo' | 'file' | 'embed';
+export interface VideoBlockContent {
+    inputType?: VideoInputType;
+    videoUrl?: string;
+    videoFile?: string;
+    videoPath?: string;
+    videoSize?: number;
+    embedCode?: string;
+    thumbnail?: string;
+    thumbnailFile?: string;
+    thumbnailPath?: string;
+    title?: string;
+    autoplay?: boolean;
+    controls?: boolean;
+}
+export interface ImageBlockContent {
+    imageUrl?: string;
+    imageFile?: string;
+    imagePath?: string;
+    imageSize?: number;
+    caption?: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+    alignment?: 'left' | 'center' | 'right';
+    allowDownload?: boolean;
+}
+export interface MediaEditorProps<T> {
+    value: T;
+    onChange: (value: T) => void;
+    onSubmit: (value: T) => void;
+    onCancel: () => void;
+    uploadFunction?: UploadFunction;
+    deleteFunction?: DeleteFunction;
+    uploadOptions?: UploadOptions;
+}
+export interface MediaRendererProps<T> {
+    content: T;
+    className?: string;
+    style?: React.CSSProperties;
+}

package/dist/media/utils/imageHelpers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Image Helpers
+ *
+ * Funções utilitárias para manipulação de imagens
+ */
+/**
+ * Calcula a proporção (aspect ratio) de uma imagem
+ */
+export declare function calculateAspectRatio(width: number, height: number): number;
+/**
+ * Redimensiona mantendo a proporção
+ */
+export declare function resizeKeepingAspect(originalWidth: number, originalHeight: number, targetWidth?: number, targetHeight?: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Verifica se uma URL é de imagem baseado na extensão
+ */
+export declare function isImageUrl(url: string): boolean;
+/**
+ * Extrai o nome do arquivo de uma URL
+ */
+export declare function extractImageFileName(url: string): string;
+/**
+ * Formata tamanho de arquivo em bytes para string legível
+ */
+export declare function formatFileSize(bytes: number): string;

package/dist/media/utils/videoHelpers.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Video Helpers
+ *
+ * Funções utilitárias para manipulação de URLs de vídeo
+ * (YouTube, Vimeo, etc.)
+ */
+import { VideoProvider } from '../types';
+/**
+ * Extrai o ID de um vídeo do YouTube a partir de várias URLs possíveis
+ */
+export declare function extractYouTubeId(url: string): string | null;
+/**
+ * Normaliza URL do YouTube para formato embed
+ */
+export declare function normalizeYouTubeUrl(urlOrId: string, autoplay?: boolean): string;
+/**
+ * Extrai o ID de um vídeo do Vimeo
+ */
+export declare function extractVimeoId(url: string): string | null;
+/**
+ * Normaliza URL do Vimeo para formato embed
+ */
+export declare function normalizeVimeoUrl(urlOrId: string, autoplay?: boolean): string;
+/**
+ * Extrai URL do src de um código iframe embed
+ */
+export declare function parseIframeSrc(embedCode?: string): string | undefined;
+/**
+ * Detecta o provider de um vídeo baseado na URL
+ */
+export declare function detectVideoProvider(url: string): VideoProvider;
+/**
+ * Normaliza URL de vídeo baseado no provider detectado
+ */
+export declare function normalizeVideoUrl(url: string, provider?: VideoProvider, autoplay?: boolean): string;

package/dist/places/components/ManageAccessModal.d.ts

@@ -0,0 +1,11 @@
+export interface ManageAccessModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    placeId: string;
+    placeName: string;
+    onMakeManager?: (userId: string, placeId: string) => void | Promise<void>;
+    onMakeMembers?: (userIds: string[], placeId: string) => void | Promise<void>;
+    currentManagerId?: string;
+    currentMemberIds?: string[];
+}
+export declare function ManageAccessModal({ open, onOpenChange, placeId, placeName, onMakeManager, onMakeMembers, currentManagerId, currentMemberIds }: ManageAccessModalProps): import("react/jsx-runtime").JSX.Element;

package/dist/places/components/PlaceCard.d.ts

@@ -0,0 +1,12 @@
+import { Place } from '../types';
+export interface PlaceCardProps {
+    place: Place;
+    level?: number;
+    manageAccessConfig?: {
+        onMakeManager?: (userId: string, placeId: string) => void | Promise<void>;
+        onMakeMembers?: (userIds: string[], placeId: string) => void | Promise<void>;
+        getCurrentManagerId?: (placeId: string) => string | undefined;
+        getCurrentMemberIds?: (placeId: string) => string[] | undefined;
+    };
+}
+export declare function PlaceCard({ place, level, manageAccessConfig }: PlaceCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/places/components/PlacesList.d.ts

@@ -0,0 +1,12 @@
+import { Place } from '../types';
+export interface PlacesListProps {
+    places: Place[];
+    isLoading: boolean;
+    manageAccessConfig?: {
+        onMakeManager?: (userId: string, placeId: string) => void | Promise<void>;
+        onMakeMembers?: (userIds: string[], placeId: string) => void | Promise<void>;
+        getCurrentManagerId?: (placeId: string) => string | undefined;
+        getCurrentMemberIds?: (placeId: string) => string[] | undefined;
+    };
+}
+export declare function PlacesList({ places, isLoading, manageAccessConfig }: PlacesListProps): import("react/jsx-runtime").JSX.Element;

package/dist/places/index.d.ts

@@ -0,0 +1,8 @@
+export { PlacesList } from './components/PlacesList';
+export { PlaceCard } from './components/PlaceCard';
+export { ManageAccessModal } from './components/ManageAccessModal';
+export { placeService } from './services/PlaceService';
+export type { Place } from './types';
+export type { ManageAccessModalProps } from './components/ManageAccessModal';
+export type { PlacesListProps } from './components/PlacesList';
+export type { PlaceCardProps } from './components/PlaceCard';

package/dist/places/services/PlaceService.d.ts

@@ -0,0 +1,9 @@
+import { Place } from '../types';
+declare class PlaceService {
+    private baseUrl;
+    private makeApiCall;
+    private buildHierarchy;
+    getPlaces(alias: string, companyId: string): Promise<Place[]>;
+}
+export declare const placeService: PlaceService;
+export {};

package/dist/places/types.d.ts

@@ -0,0 +1,10 @@
+export interface Place {
+    id: string;
+    name: string;
+    usersCount?: number;
+    hasChild?: boolean;
+    isActive?: boolean;
+    parentId?: string;
+    parentName?: string;
+    subPlaces?: Place[];
+}

package/dist/providers/CoreProviders.d.ts

@@ -0,0 +1,66 @@
+import { ReactNode } from 'react';
+import { QueryClient } from '@tanstack/react-query';
+/**
+ * Props for CoreProviders component
+ */
+export interface CoreProvidersProps {
+    /**
+     * Child components to be wrapped by providers
+     */
+    children: ReactNode;
+    /**
+     * Optional custom QueryClient instance
+     * If not provided, a default QueryClient will be created
+     */
+    queryClient?: QueryClient;
+}
+/**
+ * CoreProviders - Encapsulates all essential providers for forlogic-core applications
+ *
+ * This component wraps your application with all necessary providers:
+ * - ErrorBoundary (error handling)
+ * - I18nextProvider (internationalization)
+ * - QueryClientProvider (data fetching)
+ * - AuthProvider (authentication)
+ * - LocaleProvider (locale management)
+ * - TranslationLoader (removed - translations now loaded from local JSON)
+ *
+ * @example
+ * ```tsx
+ * import { CoreProviders } from 'forlogic-core';
+ * import { BrowserRouter } from 'react-router-dom';
+ *
+ * function App() {
+ *   return (
+ *     <CoreProviders>
+ *       <BrowserRouter>
+ *         <Routes>
+ *           {/* Your routes here *\/}
+ *         </Routes>
+ *       </BrowserRouter>
+ *     </CoreProviders>
+ *   );
+ * }
+ * ```
+ *
+ * @example With custom QueryClient
+ * ```tsx
+ * import { CoreProviders } from 'forlogic-core';
+ * import { QueryClient } from '@tanstack/react-query';
+ *
+ * const queryClient = new QueryClient({
+ *   defaultOptions: {
+ *     queries: { staleTime: 10 * 60 * 1000 },
+ *   },
+ * });
+ *
+ * function App() {
+ *   return (
+ *     <CoreProviders queryClient={queryClient}>
+ *       {/* Your app *\/}
+ *     </CoreProviders>
+ *   );
+ * }
+ * ```
+ */
+export declare function CoreProviders({ children, queryClient }: CoreProvidersProps): import("react/jsx-runtime").JSX.Element;

package/dist/providers/index.d.ts

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

package/dist/qualiex/components/QualiexUserField.d.ts

@@ -0,0 +1,125 @@
+import React from 'react';
+import { QualiexUser } from '../../types';
+/**
+ * Formato de exibição do usuário no campo
+ */
+export type QualiexUserDisplayFormat = 'name' | 'name-email' | 'name-role' | 'custom';
+/**
+ * QualiexUserField - Campo de seleção de usuários da plataforma Qualiex
+ *
+ * Este componente fornece uma interface completa para selecionar usuários cadastrados
+ * na plataforma Qualiex, com busca, loading states, tratamento de erros e suporte
+ * a múltipla seleção, display customizado e filtros.
+ *
+ * @example
+ * ```tsx
+ * // Uso básico
+ * <QualiexUserField
+ *   value={userId}
+ *   onChange={setUserId}
+ * />
+ *
+ * // Seleção múltipla com label
+ * <QualiexUserField
+ *   multiple
+ *   label="Avaliadores"
+ *   required
+ *   value={evaluatorIds}
+ *   onChange={setEvaluatorIds}
+ * />
+ *
+ * // Exibindo nome + email
+ * <QualiexUserField
+ *   displayFormat="name-email"
+ *   value={userId}
+ *   onChange={setUserId}
+ * />
+ *
+ * // Filtrando apenas admins
+ * <QualiexUserField
+ *   filterFn={(user) => user.roleName === 'Admin'}
+ *   value={adminId}
+ *   onChange={setAdminId}
+ * />
+ *
+ * // Dentro de um Dialog
+ * <QualiexUserField
+ *   popoverContainer={dialogContentRef.current}
+ *   value={userId}
+ *   onChange={setUserId}
+ * />
+ *
+ * // Display customizado
+ * <QualiexUserField
+ *   displayFormat="custom"
+ *   customDisplayFn={(user) => `${user.userName} - ${user.placeName || 'Sem local'}`}
+ *   value={userId}
+ *   onChange={setUserId}
+ * />
+ * ```
+ *
+ * @param value - ID(s) do(s) usuário(s) selecionado(s) (userId do Qualiex)
+ * @param onChange - Callback chamado quando o usuário seleciona um item
+ * @param multiple - Modo de seleção múltipla (default: false)
+ * @param label - Label do campo
+ * @param required - Adiciona asterisco ao label
+ * @param placeholder - Texto exibido quando nenhum usuário está selecionado
+ * @param disabled - Desabilita o campo (não permite interação)
+ * @param className - Classes CSS adicionais para customização
+ * @param enabled - Controla se o hook deve buscar dados da API (default: true)
+ * @param displayFormat - Formato de exibição: 'name' | 'name-email' | 'name-role' | 'custom'
+ * @param customDisplayFn - Função customizada para exibição (usado com displayFormat='custom')
+ * @param filterFn - Função para filtrar usuários antes da exibição
+ * @param icon - Ícone Lucide React para exibir no campo
+ * @param maxDisplayedBadges - Limite de badges no modo múltiplo
+ * @param popoverContainer - Container HTML para portal (útil em Dialog/Modal)
+ * @param sortOptions - Ordena usuários alfabeticamente (default: true)
+ * @param onOpen - Callback ao abrir o popover
+ * @param onClose - Callback ao fechar o popover
+ *
+ * @requires QualiexConfig configurado no projeto (apiUrl e apiToken)
+ * @see useQualiexUsers - Hook que busca os usuários da API
+ * @see Combobox - Componente base de seleção com busca
+ */
+interface QualiexUserFieldProps {
+    /** ID(s) do(s) usuário(s) selecionado(s) - string para single, string[] para multiple */
+    value?: string | string[];
+    /** Callback chamado quando a seleção muda */
+    onChange?: (value: string | string[]) => void;
+    /** Habilita seleção múltipla (default: false) */
+    multiple?: boolean;
+    /** Label do campo */
+    label?: string;
+    /** Marca campo como obrigatório (adiciona asterisco) */
+    required?: boolean;
+    /** Placeholder quando nenhum item selecionado */
+    placeholder?: string;
+    /** Ícone Lucide React para exibir no campo */
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    /** Limite de badges exibidos no modo múltiplo */
+    maxDisplayedBadges?: number;
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Desabilita o campo */
+    disabled?: boolean;
+    /** Controla se o hook deve buscar dados da API (default: true) */
+    enabled?: boolean;
+    /** Formato de exibição do usuário: 'name' | 'name-email' | 'name-role' | 'custom' */
+    displayFormat?: QualiexUserDisplayFormat;
+    /** Função customizada para exibição (requer displayFormat='custom') */
+    customDisplayFn?: (user: QualiexUser) => string;
+    /** Função para filtrar usuários antes da exibição */
+    filterFn?: (user: QualiexUser) => boolean;
+    /** Ordena usuários alfabeticamente (default: true) */
+    sortOptions?: boolean;
+    /** Container HTML para portal do popover (útil em Dialog/Modal) */
+    popoverContainer?: HTMLElement | null;
+    /** Callback ao abrir o popover */
+    onOpen?: () => void;
+    /** Callback ao fechar o popover */
+    onClose?: () => void;
+}
+export declare const QualiexUserField: React.FC<QualiexUserFieldProps>;
+export {};