import { type ReactNode } from 'react';
import type { IMasterDocumentAdapter, DocumentState } from '../adapter/MasterDocumentAdapter.types';
import type { ApiService } from '../adapter/ApiService.types';
import type { MasterDocumentTemplate } from '../template/MasterDocumentTemplate.types';
import { type IconComponent } from './iconRegistry';
import type { MasterDocumentPrintConfig } from '../printing/MasterDocumentPrinting.types';
import type { AuditHistoryProps } from '../../../audit/types/audit.types';
/**
 * Contexto en vivo que recibe un widget FactBox custom (`type: 'custom'`)
 * cuando se registra como función. Permite acceder al estado del documento y
 * al adapter para cablear widgets que dependen de datos en runtime
 * (ej: AdvanceApplicationsPanel necesita documentId, docState, headerValues).
 */
export interface FactBoxWidgetRenderContext {
    documentId: string;
    docState: string;
    mode: DocumentState['mode'];
    headerValues: Record<string, unknown>;
    /** Datos resueltos de la sección (según `dataSource`). */
    data: Record<string, unknown>;
    adapter: IMasterDocumentAdapter;
    /**
     * Resincroniza el documento contra el servidor (encabezado, líneas, totales,
     * `row_version`). Invócalo DESPUÉS de persistir por tu cuenta: el kit solo
     * mergea lo que guarda él, así que un widget que escribe contra su propio
     * endpoint —cruzar una OC, aplicar un anticipo— deja la grilla de Líneas y el
     * widget de Totales mostrando los valores previos hasta que alguien recarga la
     * página.
     *
     * Es el mismo `reload` que devuelve {@link useMasterDocumentReload}: usa el
     * hook si tu widget es un componente y prefieres no cablearlo por props.
     */
    reload: () => Promise<void>;
    /**
     * Sube tras cada mutación del kit. Úsalo como dependencia del fetch propio del
     * widget para que su vista se reconsulte cuando el documento cambió por fuera
     * de él —el caso típico es una grilla de cantidades pendientes que quedaría
     * stale tras un cruce.
     */
    refreshToken: number;
}
/**
 * Valor registrable en `factBoxWidgets`. Puede ser un nodo estático o una
 * función que recibe el contexto en vivo del documento y retorna el nodo.
 */
export type FactBoxWidget = ReactNode | ((ctx: FactBoxWidgetRenderContext) => ReactNode);
/**
 * Renderer de una pestaña de detalle, referido por clave desde el template
 * (`layout.detail.tabs[].renderKey`).
 *
 * Mismo mecanismo que `factBoxWidgets` y por la misma razón: el componente es del
 * host —una consulta FlexQuery, un panel propio— y el template solo transporta su
 * clave. Así el kit no importa nada del host ni el host tiene que reconstruir el
 * estado del documento: lo recibe resuelto en el contexto.
 *
 * @see LineTabRenderContext - Lo que recibe el renderer
 * @see DetailTabTemplate - La declaración en el template
 */
export type LineTabRenderer = (ctx: import('../MasterDocument.types').LineTabRenderContext) => ReactNode;
export declare function useMasterDocumentAdapter(): IMasterDocumentAdapter;
export declare function useMasterDocumentTemplate(): MasterDocumentTemplate;
export declare function useIconRegistry(): Record<string, IconComponent>;
export declare function useFactBoxWidgets(): Record<string, FactBoxWidget>;
/**
 * Renderers de pestañas de detalle registrados por el host. Vacío = ninguno, y
 * entonces una pestaña Tipo 2 o Tipo 3 del template queda sin contenido: es un
 * error de cableado del consumidor, no del kit, y se avisa por consola.
 */
export declare function useLineTabRenderers(): Record<string, LineTabRenderer>;
/**
 * Retorna los permisos del usuario activo, o `null` si el sistema de permisos
 * no está configurado en el provider (fallback permisivo: todo visible y editable).
 */
export declare function useUserPermissions(): string[] | null;
interface BaseProviderProps {
    template: MasterDocumentTemplate;
    icons?: Record<string, IconComponent>;
    factBoxWidgets?: Record<string, FactBoxWidget>;
    /**
     * Renderers de las pestañas de detalle Tipo 2 (FlexQuery) y Tipo 3 (Render),
     * indexados por la `renderKey` que declara `template.layout.detail.tabs`.
     *
     * Ausente ⇒ el documento solo puede tener pestañas de tipo `lines`, que es el
     * comportamiento de siempre. El kit no trae ninguna consulta FlexQuery propia:
     * ese componente vive en la app host y entra por aquí.
     *
     * @example
     * ```tsx
     * <MasterDocumentProvider
     *   template={template}
     *   adapter={adapter}
     *   lineTabRenderers={{
     *     flexQuery: (ctx) => (
     *       <FlexQueryGrid
     *         queryCode={ctx.flexQuery!.queryCode}
     *         filters={ctx.filters}
     *         refreshToken={ctx.refreshToken}
     *         rowActions={ctx.rowActions}
     *       />
     *     ),
     *   }}
     * >
     * ```
     */
    lineTabRenderers?: Record<string, LineTabRenderer>;
    /**
     * Permisos del usuario activo. Cada string es una clave de permiso
     * (e.g. "view.cedula", "edit.precio").
     *
     * - Ausente / null → sistema de permisos no activo: todos los campos visibles y editables.
     * - [] → sistema activo pero sin permisos: campos restringidos quedan ocultos/deshabilitados.
     */
    userPermissions?: string[] | null;
    /**
     * Configuración de impresión nativa (opcional). Cuando se provee, el kit
     * muestra "Imprimir" en el menú de cada fila del listado y como botón en la
     * cabecera del detalle, abriendo un modal de vista previa con el visor que el
     * host inyecta. Sin esta prop, el comportamiento es idéntico al actual
     * (sin impresión) → retrocompatibilidad total.
     *
     * @see MasterDocumentPrintConfig
     */
    printing?: MasterDocumentPrintConfig;
    /**
     * Configuración de historial de auditoría (opcional). Mismo contrato que MasterCrud.
     * Cuando se provee y `enabled` es true, el detalle del documento muestra una acción
     * ⏱ que abre el historial de cambios (campo por campo) del documento guardado. Sin
     * esta prop, el comportamiento es idéntico al actual (sin auditoría) →
     * retrocompatibilidad total. La evaluación del permiso es responsabilidad del
     * consumidor, comunicada vía `enabled`.
     *
     * @see AuditHistoryProps
     */
    auditHistory?: AuditHistoryProps;
    children: ReactNode;
}
/**
 * Modo manual: el consumidor provee su propio adapter.
 */
interface ManualAdapterProps extends BaseProviderProps {
    endpointAuto?: false;
    adapter: IMasterDocumentAdapter;
    apiService?: never;
}
/**
 * Modo auto: usa los endpoints estándar del contrato.
 * El consumidor solo entrega un apiService con baseUrl y headers.
 */
interface AutoEndpointProps extends BaseProviderProps {
    endpointAuto: true;
    apiService: ApiService;
    adapter?: never;
}
export type MasterDocumentProviderProps = ManualAdapterProps | AutoEndpointProps;
export declare function MasterDocumentProvider(props: MasterDocumentProviderProps): import("react/jsx-runtime").JSX.Element;
export {};
//# sourceMappingURL=MasterDocumentProvider.d.ts.map