forlogic-core 1.15.2 → 1.15.4

package/dist/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/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/contexts/PageMetadataContext.d.ts

@@ -0,0 +1,43 @@
+import { ReactNode } from 'react';
+interface PageMetadata {
+    title?: string;
+    subtitle?: string;
+}
+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: 'Fluxos de Importação',
+ *     subtitle: 'Gerencie seus fluxos de importação'
+ *   });
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ *
+ * @param metadata - Objeto com title e/ou subtitle customizados
+ */
+export declare function usePageMetadata(metadata: PageMetadata): void;
+export {};

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

@@ -0,0 +1,17 @@
+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';
+}
+export declare const ActionMenuItems: React.FC<ActionMenuItemsProps>;
+export {};

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

@@ -0,0 +1,6 @@
+import type { BaseFormProps } from '../../types';
+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;

package/dist/crud/components/ContextMenu.d.ts

@@ -0,0 +1,21 @@
+import type { BaseEntity } from '../../types';
+interface ContextMenuProps<T extends BaseEntity> {
+    contextMenu: {
+        x: number;
+        y: number;
+        item: T;
+    } | null;
+    onClose: () => void;
+    onEdit?: (item: T) => void;
+    onDelete?: (item: T) => void;
+    onToggleStatus?: (item: T) => void;
+    customActions?: (item: T) => Array<{
+        icon: any;
+        label: string;
+        onClick: () => void;
+    }>;
+}
+export declare const ContextMenu: <T extends BaseEntity & {
+    is_actived?: boolean;
+}>({ contextMenu, onClose, onEdit, onDelete, onToggleStatus, customActions, }: ContextMenuProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/crud/components/CrudActionBar.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import type { BaseEntity, BulkAction } from '../../types';
+export interface CustomAction {
+    label: string;
+    icon?: React.ComponentType<{
+        size?: number;
+        className?: string;
+    }>;
+    action: () => void;
+    variant?: 'default' | 'outline' | 'ghost';
+    disabled?: boolean;
+    disabledReason?: string;
+}
+export type ViewMode = 'table' | 'list' | 'grid';
+export interface CrudActionBarProps<T extends BaseEntity = BaseEntity> {
+    onNew?: () => void;
+    newButtonLabel?: string;
+    showNewButton?: boolean;
+    showSearch?: boolean;
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    searchPlaceholder?: string;
+    showBulkActions?: boolean;
+    selectedCount?: number;
+    bulkActions?: BulkAction<T>[];
+    onBulkDelete?: () => void;
+    onClearSelection?: () => void;
+    customActions?: CustomAction[];
+    filters?: React.ReactNode;
+    viewMode?: ViewMode;
+    onViewModeChange?: (mode: ViewMode) => void;
+    showViewToggle?: boolean;
+    availableViewModes?: ViewMode[];
+    className?: string;
+}
+declare function CrudActionBarComponent<T extends BaseEntity = BaseEntity>({ onNew, newButtonLabel, showNewButton, showSearch, searchValue, onSearchChange, searchPlaceholder, showBulkActions, selectedCount, bulkActions, onBulkDelete, onClearSelection, customActions, filters, viewMode, onViewModeChange, showViewToggle, availableViewModes, className, }: CrudActionBarProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare const CrudActionBar: typeof CrudActionBarComponent;
+export default CrudActionBar;

package/dist/crud/components/CrudGrid.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import type { CrudColumn, CrudManager, BaseEntity, BulkAction } from '../../types';
+import { type CustomAction, type ViewMode } from './CrudActionBar';
+export interface CrudGridProps<T extends BaseEntity & {
+    is_actived?: boolean;
+}> {
+    manager: CrudManager<T>;
+    columns: CrudColumn<T>[];
+    onEdit?: (item: T) => void;
+    onView?: (item: T) => void;
+    onToggleStatus?: (item: T) => void;
+    onDelete?: (item: T) => void;
+    renderActions?: (item: T) => React.ReactNode;
+    customRowActions?: (item: T) => Array<{
+        icon: any;
+        label: string;
+        onClick: () => void;
+    }>;
+    enableBulkActions?: boolean;
+    onNew?: () => void;
+    newButtonLabel?: string;
+    showNewButton?: boolean;
+    customActions?: CustomAction[];
+    /** @deprecated Use showActionBar={false} instead */
+    hideActionBar?: boolean;
+    showActionBar?: boolean;
+    showSearch?: boolean;
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    searchPlaceholder?: string;
+    bulkActions?: BulkAction<T>[];
+    onBulkDelete?: () => void;
+    filters?: React.ReactNode;
+    gridColumns?: 1 | 2 | 3 | 4;
+    renderCard?: (item: T) => React.ReactNode;
+    viewMode?: ViewMode;
+    onViewModeChange?: (mode: ViewMode) => void;
+    listCardRenderer?: (item: T) => React.ReactNode;
+    gridCardRenderer?: (item: T) => React.ReactNode;
+    showViewToggle?: boolean;
+}
+export declare const CrudGrid: <T extends BaseEntity>({ manager, columns, onEdit, onView, onToggleStatus, onDelete, renderActions, customRowActions, enableBulkActions, onNew, newButtonLabel, showNewButton, customActions, hideActionBar, showActionBar, showSearch, searchValue, onSearchChange, searchPlaceholder, bulkActions, onBulkDelete, filters, gridColumns, renderCard, viewMode, onViewModeChange, listCardRenderer, gridCardRenderer, showViewToggle }: CrudGridProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default CrudGrid;

package/dist/crud/components/CrudPagination.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CrudPagination - Paginação CRUD com integração ao CrudManager
+ *
+ * Usa o primitivo Pagination com lógica de CRUD injetada.
+ * Antigo nome: TableFooter
+ */
+import type { CrudManager, BaseEntity } from '../../types';
+interface CrudPaginationProps<T extends BaseEntity> {
+    manager: Pick<CrudManager<T>, 'pagination' | 'handlePageChange' | 'handleItemsPerPageChange'>;
+}
+export declare function CrudPagination<T extends BaseEntity>({ manager }: CrudPaginationProps<T>): import("react/jsx-runtime").JSX.Element;
+export { CrudPagination as TableFooter };

package/dist/crud/components/CrudTable.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+import type { CrudColumn, CrudManager, BaseEntity, BulkAction } from '../../types';
+import { type CustomAction, type ViewMode } from './CrudActionBar';
+export interface CrudTableProps<T extends BaseEntity & {
+    is_actived?: boolean;
+}> {
+    manager: CrudManager<T>;
+    columns: CrudColumn<T>[];
+    onEdit?: (item: T) => void;
+    onView?: (item: T) => void;
+    onToggleStatus?: (item: T) => void;
+    onDelete?: (item: T) => void;
+    renderActions?: (item: T) => React.ReactNode;
+    customRowActions?: (item: T) => Array<{
+        icon: any;
+        label: string;
+        onClick: () => void;
+    }>;
+    enableBulkActions?: boolean;
+    onNew?: () => void;
+    newButtonLabel?: string;
+    showNewButton?: boolean;
+    customActions?: CustomAction[];
+    /** @deprecated Use showActionBar={false} instead */
+    hideActionBar?: boolean;
+    showActionBar?: boolean;
+    showSearch?: boolean;
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    searchPlaceholder?: string;
+    bulkActions?: BulkAction<T>[];
+    onBulkDelete?: () => void;
+    filters?: React.ReactNode;
+    viewMode?: ViewMode;
+    onViewModeChange?: (mode: ViewMode) => void;
+    showViewToggle?: boolean;
+    enableColumnResize?: boolean;
+    resizeStorageKey?: string;
+}
+export declare const CrudTable: <T extends BaseEntity>({ manager, columns, onEdit, onView, onToggleStatus, onDelete, renderActions, customRowActions, enableBulkActions, onNew, newButtonLabel, showNewButton, customActions, hideActionBar, showActionBar, showSearch, searchValue, onSearchChange, searchPlaceholder, bulkActions, onBulkDelete, filters, viewMode, onViewModeChange, showViewToggle, enableColumnResize, resizeStorageKey }: CrudTableProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default CrudTable;

package/dist/crud/components/FilterBar.d.ts

@@ -0,0 +1,136 @@
+import type { CrudManager, CrudFilter, CrudEntity } from '../../types';
+/**
+ * Props do FilterBar
+ */
+interface FilterBarProps<T extends CrudEntity> {
+    /** Manager de CRUD com métodos de busca e limpeza de filtros */
+    manager: Pick<CrudManager<T>, 'searchTerm' | 'handleSearch' | 'clearFilters'>;
+    /** Array de filtros (busca e customizados) */
+    filters: CrudFilter[];
+    /**
+     * Se true, renderiza filtros inline (sem wrapper Stack).
+     * Usado na Action Bar para alinhar filtros horizontalmente com botões.
+     * @default false
+     */
+    inline?: boolean;
+}
+/**
+ * Barra de filtros para páginas CRUD
+ *
+ * Renderiza filtros de busca e customizados (Select, Checkbox, etc) para
+ * filtrar dados em páginas CRUD. Suporta dois modos de renderização:
+ * - **Standalone** (inline=false): Filtros em Stack vertical/horizontal
+ * - **Inline** (inline=true): Filtros sem wrapper, usados na Action Bar
+ *
+ * **Tipos de filtro suportados:**
+ * - `type: 'search'`: Campo de busca integrado com `manager.searchTerm`
+ * - `type: 'custom'`: Componente React customizado (Select, Checkbox, etc)
+ *
+ * **Botão "Limpar Filtros":**
+ * - Aparece quando `manager.searchTerm` tem valor
+ * - Chama `manager.clearFilters()` ao clicar
+ * - Para limpar filtros customizados, sobrescreva `clearFilters` no manager
+ *
+ * @example
+ * ```typescript
+ * // Filtro de busca simples
+ * <FilterBar
+ *   manager={manager}
+ *   filters={[{ type: 'search' }]}
+ * />
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Filtros customizados com Select
+ * import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from 'forlogic-core';
+ *
+ * function ProcessesPage() {
+ *   const manager = useProcessCrud();
+ *   const [statusFilter, setStatusFilter] = useState('all');
+ *   const [departmentFilter, setDepartmentFilter] = useState('all');
+ *
+ *   const filters: CrudFilter[] = [
+ *     { type: 'search' },
+ *     {
+ *       type: 'custom',
+ *       component: ({ value, onChange }) => (
+ *         <Select value={value} onValueChange={onChange}>
+ *           <SelectTrigger className="w-[180px]">
+ *             <SelectValue placeholder="Status" />
+ *           </SelectTrigger>
+ *           <SelectContent>
+ *             <SelectItem value="all">Todos</SelectItem>
+ *             <SelectItem value="active">Ativos</SelectItem>
+ *             <SelectItem value="inactive">Inativos</SelectItem>
+ *           </SelectContent>
+ *         </Select>
+ *       ),
+ *       props: { value: statusFilter, onChange: setStatusFilter }
+ *     }
+ *   ];
+ *
+ *   return <FilterBar manager={manager} filters={filters} />;
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Filtrar dados com useMemo
+ * function ProcessesPage() {
+ *   const manager = useProcessCrud();
+ *   const [statusFilter, setStatusFilter] = useState('all');
+ *
+ *   // Aplicar filtro customizado aos dados
+ *   const filteredData = useMemo(() => {
+ *     if (statusFilter === 'all') return manager.entities;
+ *     return manager.entities.filter(item => item.status === statusFilter);
+ *   }, [manager.entities, statusFilter]);
+ *
+ *   // Passar dados filtrados para a tabela
+ *   return <CrudTable manager={{ ...manager, entities: filteredData }} />;
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Implementar "Limpar Filtros" customizado
+ * function ProcessesPage() {
+ *   const baseManager = useProcessCrud();
+ *   const [statusFilter, setStatusFilter] = useState('all');
+ *
+ *   // Sobrescrever clearFilters para resetar filtros customizados
+ *   const manager = {
+ *     ...baseManager,
+ *     clearFilters: () => {
+ *       baseManager.clearFilters(); // Limpa busca padrão
+ *       setStatusFilter('all');     // Reseta filtro customizado
+ *     }
+ *   };
+ *
+ *   return <FilterBar manager={manager} filters={[...]} />;
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Modo inline (usado na Action Bar)
+ * <div className="flex items-center gap-4">
+ *   <Button>Novo</Button>
+ *   <FilterBar
+ *     manager={manager}
+ *     filters={filters}
+ *     inline={true}  // Sem wrapper Stack
+ *   />
+ * </div>
+ * ```
+ *
+ * @param props.manager Manager de CRUD com searchTerm, handleSearch, clearFilters
+ * @param props.filters Array de filtros (busca e customizados)
+ * @param props.inline Se true, renderiza sem wrapper Stack (para Action Bar)
+ *
+ * @see {@link CrudFilter} - Interface de configuração de filtros
+ * @see {@link createCrudPage} - Gerador de página CRUD que usa FilterBar
+ */
+export declare function FilterBar<T extends CrudEntity>({ manager, filters, inline, }: FilterBarProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/crud/components/TableFooter.d.ts

@@ -0,0 +1,14 @@
+interface TableFooterProps {
+    manager: {
+        pagination?: {
+            totalItems?: number;
+            totalPages?: number;
+        };
+        currentPage?: number;
+        itemsPerPage?: number;
+        handlePageChange?: (page: number) => void;
+        handleItemsPerPageChange?: (itemsPerPage: number) => void;
+    };
+}
+export declare const TableFooter: ({ manager }: TableFooterProps) => import("react/jsx-runtime").JSX.Element;
+export default TableFooter;

package/dist/crud/components/TableRowActions.d.ts

@@ -0,0 +1,14 @@
+interface TableRowActionsProps {
+    onEdit?: () => void;
+    onDelete?: () => void;
+    canDelete?: boolean;
+    onToggleStatus?: () => void;
+    isActive?: boolean;
+    customActions?: Array<{
+        icon: any;
+        label: string;
+        onClick: () => void;
+    }>;
+}
+export declare const TableRowActions: React.FC<TableRowActionsProps>;
+export {};

package/dist/crud/createCrudPage.d.ts

@@ -0,0 +1,99 @@
+import React from "react";
+import type { CrudPageConfig, CrudEntity, FormSection, CrudFilter, BulkAction } from "../types";
+interface SimpleCrudPageConfig<T extends CrudEntity> {
+    entityName: string;
+    entityNamePlural: string;
+    columns: any[];
+    formSections: FormSection[];
+    cardFields?: any[];
+    filters?: CrudFilter[];
+    defaultSort?: {
+        column: string;
+        direction: "asc" | "desc";
+    };
+    enableBulkActions?: boolean;
+    bulkActions?: BulkAction<T>[];
+    customActions?: Array<{
+        label: string;
+        icon?: React.ComponentType<{
+            size?: number;
+            className?: string;
+        }>;
+        variant?: "default" | "destructive" | "outline" | "ghost";
+        action: () => void;
+        disabled?: boolean;
+        disabledReason?: string;
+    }>;
+    customRowActions?: (item: T) => Array<{
+        icon: any;
+        label: string;
+        onClick: () => void;
+    }>;
+    customListView?: (items: T[], manager?: any) => React.ReactNode;
+    onEdit?: (entity: T) => T | void;
+    /** Handler customizado para o botão "Novo" (abre wizard/modal customizado) */
+    onNew?: () => void;
+    /** Usar roteamento customizado (desabilita BaseForm padrão) */
+    useCustomRouting?: boolean;
+    /** @deprecated Use showNewButton={false} instead */
+    hideNewButton?: boolean;
+    /** Exibir botão "Novo" (default: true) */
+    showNewButton?: boolean;
+    /** Texto customizado para o botão "Novo" */
+    newButtonLabel?: string;
+    /** Exibir busca integrada na Action Bar (default: false - usa busca global) */
+    showSearch?: boolean;
+    /** Placeholder para busca integrada */
+    searchPlaceholder?: string;
+    /** Exibir Action Bar (default: true) */
+    showActionBar?: boolean;
+}
+interface CrudPageGeneratorConfig<T extends CrudEntity> {
+    manager: any;
+    config: SimpleCrudPageConfig<T>;
+    onSave: (data: any) => void;
+    onEdit?: (entity: T) => T | void | Promise<T | void>;
+    onToggleStatus?: (item: T) => void;
+}
+declare function CrudPageInternal<T extends CrudEntity>({ manager, config, formSections, onSave, onToggleStatus, defaultSort, }: {
+    manager: any;
+    config: CrudPageConfig<T>;
+    formSections: FormSection[];
+    onSave: (data: any) => void;
+    onToggleStatus?: (item: T) => void;
+    defaultSort?: {
+        column: string;
+        direction: "asc" | "desc";
+    };
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Gera uma página CRUD completa
+ *
+ * @example
+ * ```typescript
+ * const CrudPage = createCrudPage({
+ *   manager,
+ *   config: { entityName: 'Funcionário', ... },
+ *   onSave: handleSave
+ * });
+ * ```
+ *
+ * Ver README para exemplos completos
+ */
+export declare function createCrudPage<T extends CrudEntity>(generatorConfig: CrudPageGeneratorConfig<T>): React.FC<{
+    manager?: any;
+}>;
+export { CrudPageInternal };
+/**
+ * Helper para criar handler de save (create ou update)
+ *
+ * @example
+ * ```typescript
+ * const handleSave = createSimpleSaveHandler(
+ *   manager,
+ *   (data) => ({ ...data, alias }),
+ *   (data) => ({ ...data })
+ * );
+ * ```
+ */
+export declare function createSimpleSaveHandler<T extends CrudEntity, TCreate, TUpdate>(manager: any, createTransform: (data: any) => TCreate, updateTransform: (data: any) => TUpdate): (data: any) => void;

package/dist/crud/createSimpleService.d.ts

@@ -0,0 +1,85 @@
+import { QualiexUserFieldMapping } from '../types';
+interface SimpleServiceConfig {
+    tableName: string;
+    entityName: string;
+    schemaName?: string;
+    searchFields?: string[];
+    selectFields?: string;
+    enableQualiexEnrichment?: boolean;
+    /** Lista simples de campos de ID (ex: ['target_user_id', 'evaluator_user_id']) */
+    userIdFields?: string[];
+    /** Mapeamento granular de campos (sobrescreve userIdFields se presente) */
+    userFieldsMapping?: QualiexUserFieldMapping[];
+}
+/**
+ * Cria um serviço CRUD completo com hook React Query
+ *
+ * Gera automaticamente service + hook integrado com cache, soft delete e RLS.
+ *
+ * @example
+ * ```typescript
+ * const { service, useCrudHook } = createSimpleService<Example>({
+ *   tableName: 'examples',
+ *   entityName: 'exemplo',
+ *   searchFields: ['title', 'description'],
+ *   enableQualiexEnrichment: true
+ * });
+ * ```
+ *
+ * Ver README para documentação completa sobre RLS policies e estrutura de tabela
+ */
+export declare function createSimpleService<T extends {
+    id: string;
+    id_user?: string | null;
+}, TInsert = any, TUpdate = any>(config: SimpleServiceConfig): {
+    service: {
+        getAll(params?: import("..").QueryParams): Promise<import("..").PaginatedResponse<T & {
+            responsible_name?: string;
+        }>>;
+        getById(id: string): Promise<T>;
+        create(payload: TInsert): Promise<T>;
+        update(id: string, payload: TUpdate): Promise<T>;
+        delete(id: string): Promise<void>;
+    };
+    useCrudHook: (additionalFilters?: Record<string, any>, onSuccess?: () => void) => {
+        entities: any;
+        pagination: {
+            data: any;
+            currentPage: any;
+            totalPages: any;
+            totalItems: any;
+            itemsPerPage: any;
+            hasNextPage: any;
+            hasPreviousPage: any;
+        };
+        isLoading: boolean;
+        isCreating: boolean;
+        isUpdating: boolean;
+        isDeleting: boolean;
+        error: Error;
+        searchTerm: string;
+        sortField: string;
+        sortDirection: "desc" | "asc";
+        currentPage: number;
+        itemsPerPage: number;
+        queryKey: string;
+        createEntity: import("@tanstack/react-query").UseMutateFunction<T, any, TInsert, unknown>;
+        updateEntity: (id: string, data: TUpdate) => void;
+        deleteEntity: import("@tanstack/react-query").UseMutateFunction<void, any, string, unknown>;
+        save: (data: any, transform?: (data: any) => any) => void;
+        handleSearch: (search: string) => void;
+        handleSort: (field: string) => void;
+        handlePageChange: (newPage: number) => void;
+        handleItemsPerPageChange: (newLimit: number) => void;
+        clearFilters: () => void;
+        refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<any, Error>>;
+        selectedIds: string[];
+        selectItem: (id: string) => void;
+        selectAll: () => void;
+        clearSelection: () => void;
+        isAllSelected: boolean;
+        bulkDelete: (ids: string[]) => Promise<void>;
+        isBulkDeleting: boolean;
+    };
+};
+export {};