import type { ReactNode } from 'react';
import type { FieldCondition } from './fieldCondition';
export type ControlType = 'text' | 'number' | 'currency' | 'percentage' | 'date' | 'select' | 'searcher' | 'autocomplete' | 'readonly' | 'textarea' | 'toggle' | 'checkbox' | 'display';
export type FieldContext = 'header' | 'line' | 'line-detail';
export type DocumentGroup = 'PURCHASES' | 'SALES' | 'INVENTORY';
export type ItemLayout = 'PRODUCTS_ONLY' | 'SERVICES_ONLY' | 'MIXED';
export type ActionVariant = 'primary' | 'secondary' | 'danger' | 'ghost';
export type ColumnFormat = 'currency' | 'number' | 'percentage' | 'text' | 'date';
export type ColumnAlign = 'left' | 'center' | 'right';
export type ColumnAggregate = 'sum' | 'count';
export type HeaderMode = 'accordion' | 'tabs';
export type Breakpoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
export type ValidationSeverity = 'error' | 'warning';
export interface LineModalSectionConfig {
    key: string;
    label: string;
    icon?: string;
    visibleWhen?: import('./fieldCondition').FieldCondition;
    hiddenWhen?: import('./fieldCondition').FieldCondition;
}
export interface SelectOption {
    label: string;
    value: string | number;
}
/**
 * Validador que el consumidor registra para las reglas `type: 'custom'`. Devuelve
 * `true` si el valor es válido. El kit no trae ninguno: una regla `custom` sin
 * validador registrado se considera cumplida (no puede bloquear por lo que no sabe
 * evaluar).
 */
export type CustomFieldValidator = (value: unknown, context: {
    fieldDef: FieldDescriptor;
    values?: Record<string, unknown>;
}) => boolean;
/** Registro de validadores `custom`, indexado por el `value` (string) de la regla. */
export type CustomFieldValidators = Record<string, CustomFieldValidator>;
export interface ValidationRule {
    type: 'required' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'custom';
    value?: unknown;
    message: string;
    severity: ValidationSeverity;
}
/**
 * Bloqueo condicional de un campo. A diferencia de `editableOn` (que decide si el
 * campo es editable por estado), un campo bloqueado permanece visible y editable
 * por estado pero se renderiza con un candado + tooltip y cursor `not-allowed`,
 * indicando que existe una condición de negocio que impide cambiarlo en este
 * momento (p.ej. ya hay líneas registradas).
 */
export interface FieldLockCondition {
    /**
     * Bloquea cuando el documento tiene >= 1 línea. El estado `hasLines` lo deriva
     * el kit internamente (`lines.length > 0`); el consumidor no lo inyecta.
     */
    hasLines?: boolean;
    /** Estados del documento en los que aplica el bloqueo. Si se omite, aplica en cualquier estado. */
    states?: string[];
}
export interface FieldDescriptor {
    key: string;
    section: string;
    span: 1 | 2 | 3 | 4;
    order: number;
    control: ControlType;
    /**
     * Formato de PRESENTACIÓN del valor, independiente del control.
     *
     * Existe porque `control` responde a «cómo se captura» y no a «qué es el dato»:
     * un importe calculado por el servidor se declara `control: 'readonly'` —no se
     * teclea— y sin este campo el kit no tenía forma de saber que era dinero, así
     * que lo pintaba crudo (`500000`) mientras el MISMO importe salía `$ 500.000,00`
     * en la grilla de líneas. Es la misma escala que ya usan las columnas
     * (`LineColumnConfig.format`), a propósito.
     *
     * Manda sobre lo que insinúe `control`. Sólo afecta a la lectura: un control
     * editable sigue capturando el número en crudo.
     */
    format?: ColumnFormat;
    label: string;
    placeholder?: string;
    required?: boolean;
    options?: SelectOption[];
    /**
     * Nombre del catálogo de entidades para cargar opciones dinámicamente.
     * Cuando está presente, el componente llama:
     *   GET /api/v1/entities/{optionsSource}/options?companyId=X&operationCenterId=Y
     * y reemplaza el array `options` estático con el resultado.
     * Si la llamada falla, se usa el array `options` como fallback.
     */
    optionsSource?: string;
    lookup?: Record<string, unknown>;
    defaultValue?: unknown;
    editableOn: string[];
    visibleOn: string[];
    visibleWhen?: FieldCondition;
    hiddenWhen?: FieldCondition;
    /** Permiso requerido para que el campo sea visible. Sin él → campo oculto. */
    permissionVisibility?: string;
    /** Permiso requerido para que el campo sea editable. Sin él → visible pero deshabilitado. */
    permissionEnable?: string;
    /**
     * Bloqueo declarativo del campo (candado visual + tooltip). El kit evalúa la
     * condición contra el estado del documento y `hasLines` (derivado de las líneas).
     */
    lockedWhen?: FieldLockCondition;
    /** Texto literal del tooltip mostrado al pasar el mouse sobre el candado. */
    lockTooltip?: string;
    /**
     * Clave i18n del tooltip del candado, resuelta con el traductor del kit
     * (`useMasterDocumentTranslation`): sirve tanto una clave `master_document.*`
     * del catálogo propio como cualquier clave que el host haya registrado.
     *
     * Tiene prioridad sobre `lockTooltip`; si no se pasa ninguna de las dos, se usa
     * el texto por defecto `master_document.field.lockTooltip`.
     */
    lockTooltipKey?: string;
    validations: ValidationRule[];
    context: FieldContext;
    hideOnBreakpoints?: Breakpoint[];
}
export interface SectionConfig {
    key: string;
    label: string;
    subtitle?: string;
    defaultOpen: boolean;
    accent?: string;
    /** docStates en los que la sección es visible. Si está vacío o ausente, siempre visible. */
    visibleOn?: string[];
    /** Condición sobre headerValues para mostrar la sección. */
    visibleWhen?: FieldCondition;
    /** Condición sobre headerValues para ocultar la sección. */
    hiddenWhen?: FieldCondition;
    /** Permiso RBAC requerido. Sin él la sección se oculta. */
    permissionVisibility?: string;
}
export interface HeaderLayoutConfig {
    mode: HeaderMode;
    columns: 1 | 2 | 3 | 4;
    sections: SectionConfig[];
}
export interface LineColumnConfig {
    key: string;
    header: string;
    width?: string;
    /**
     * Si la columna debe quedarse EXACTAMENTE en `width` y no crecer para repartirse
     * el espacio sobrante.
     *
     * Sin declararlo, se deduce del ancho: por debajo de 100px una columna es, por
     * construcción, de código, consecutivo o unidad de medida —a una columna de texto
     * nadie le pone 60px—, y estirarla dejaba el consecutivo tan ancho como la
     * descripción. Declararlo permite fijar también una columna más ancha, o forzar a
     * crecer una estrecha con `fixedWidth: false`.
     */
    fixedWidth?: boolean;
    align?: ColumnAlign;
    format?: ColumnFormat;
    aggregate?: ColumnAggregate;
    hideOn?: Breakpoint[];
    showInCard?: boolean;
    /** Condición sobre headerValues para mostrar la columna. */
    visibleWhen?: FieldCondition;
    /** Condición sobre headerValues para ocultar la columna. */
    hiddenWhen?: FieldCondition;
    /** Permiso RBAC requerido. Sin él la columna se oculta. */
    permissionVisibility?: string;
}
export interface DetailLayoutConfig {
    mode: HeaderMode;
    columns: LineColumnConfig[];
}
export interface LayoutConfig {
    header: HeaderLayoutConfig;
    detail: DetailLayoutConfig;
    itemLayout: ItemLayout;
}
export interface StateBadgeConfig {
    label: string;
    bg: string;
    color: string;
}
export interface TransitionConfig {
    to: string;
    /** Clave de la acción que origina esta transición (ej: "send_to_approval"). */
    actionKey?: string;
    label: string;
    icon?: ReactNode;
    style: ActionVariant;
    hasGuard?: boolean;
    shortcut?: string;
    disabled?: boolean;
    loading?: boolean;
}
export interface ActionConfig {
    key: string;
    label: string;
    icon?: ReactNode;
    variant?: ActionVariant;
    onClick: () => void;
    disabled?: boolean;
    /**
     * Texto del tooltip (atributo nativo `title`) que explica por qué la acción
     * está deshabilitada. Solo se muestra cuando `disabled` es true.
     */
    disabledReason?: string;
    /**
     * La acción está ejecutándose: su botón muestra un indicador en lugar del
     * icono. Espejo de `TransitionConfig.loading`, que ya existía.
     *
     * Va aparte de `disabled` a propósito: durante una mutación TODAS las
     * acciones se deshabilitan (gating in-flight), pero solo la que el usuario
     * pulsó debe girar.
     */
    loading?: boolean;
    visibleOn?: string[];
    position?: 'toolbar' | 'actionBar' | 'moreMenu';
    requiresConfirmation?: boolean;
    confirmationMessage?: string;
    /** Permiso RBAC requerido. Sin él la acción se oculta. */
    permissionVisibility?: string;
}
export interface FactBoxSectionConfig {
    key: string;
    label: string;
    defaultOpen: boolean;
    badge?: ReactNode;
    children: ReactNode;
}
export interface TotalItem {
    key: string;
    label: string;
    value: string | number;
    highlight?: boolean;
    color?: string;
}
export type CfdeStatus = 'PENDING' | 'SENT' | 'ACCEPTED' | 'REJECTED' | 'ERROR';
export interface CfdeData {
    status: CfdeStatus;
    number?: string;
    cufe?: string;
    issueDate?: string;
    qrUrl?: string;
    printCount?: number;
    isTransmitted?: boolean;
}
export type PeriodMode = 'days' | 'months' | 'custom';
export interface PaymentTermsData {
    code: string;
    name: string;
    installmentCount: number;
    periodMode: PeriodMode;
    dueDays: number;
    earlyPaymentEnabled?: boolean;
    earlyPaymentDays?: number;
    earlyPaymentDiscountPct?: number;
    advancePaymentPct?: number;
    advancePaymentAmount?: number;
}
export interface FinancialData {
    receivableAmount?: number;
    payableAmount?: number;
    advanceAmount?: number;
    cashAmount?: number;
    receivableAmountLocal?: number;
    payableAmountLocal?: number;
    currencyCode?: string;
}
export type DiscountMode = 'percentage' | 'amount';
export interface GlobalDiscountData {
    mode: DiscountMode;
    percentage?: number;
    amount?: number;
}
export interface DocumentHeaderData {
    [key: string]: unknown;
}
export interface DocumentLineData {
    id: string;
    line_number: number;
    [key: string]: unknown;
}
export interface ComputedRule {
    targetField: string;
    watch: string[];
    compute: (formData: Record<string, unknown>) => unknown;
}
export interface FieldError {
    message: string;
    severity: ValidationSeverity;
}
export type FieldErrorMap = Record<string, FieldError>;
export interface EmptyStateConfig {
    icon?: ReactNode;
    title: string;
    description?: string;
    action?: {
        label: string;
        onClick: () => void;
    };
}
export interface ContextStripItem {
    label: string;
    value: string;
    mono?: boolean;
    accent?: boolean;
    /**
     * Breakpoints en los que el item se oculta (análogo a `FieldDescriptor.hideOnBreakpoints`).
     * Útil para esconder campos secundarios en anchos reducidos y evitar que la franja
     * se sature. La franja completa sólo es visible en `md+`, por lo que `xs`/`sm` rara
     * vez aplican. Ej: `['md', 'lg']` oculta el item en ventanas de ~768–1279px y lo
     * muestra de nuevo en `xl+`. El ocultamiento es puramente CSS (responde al resize
     * sin recalcular en JS).
     */
    hideOnBreakpoints?: Breakpoint[];
}
export interface DocumentListColumn {
    key: string;
    /** Campo real en la fila. Si omitido, se usa `key`. */
    dataKey?: string;
    header: string;
    align?: ColumnAlign;
    render?: (row: Record<string, unknown>) => ReactNode;
    mono?: boolean;
    width?: string;
    /**
     * Filtro propio de la columna: pinta un embudo en su encabezado que despliega
     * el control. Requiere `onColumnFilterChange` en el listado; sin él la columna
     * no ofrece embudo (un afordance sin destino no se muestra).
     */
    filter?: DocumentListColumnFilter;
}
/**
 * Filtro de una columna de la grilla (el embudo del encabezado).
 *
 * `'lookup'` es el caso de una columna FORÁNEA: despliega el mismo searcher que
 * usa el formulario del documento y filtra por el id del registro elegido, en
 * vez de obligar a teclear el código. Es el motivo por el que existe esta
 * capacidad: una columna foránea muestra un nombre pero filtra por un id.
 */
export interface DocumentListColumnFilter {
    type: 'text' | 'date' | 'select' | 'lookup';
    /**
     * Campo por el que se filtra en el backend. Por defecto `dataKey ?? key` de la
     * columna, que sirve para las columnas de valor simple; una columna foránea
     * suele mostrar `cliente_nombre` y filtrar por `cliente_id`.
     */
    field?: string;
    options?: SelectOption[];
    placeholder?: string;
    /** Config del searcher para `type: 'lookup'` (la misma que usan los campos del detalle). */
    searcher?: LookupFieldConfig;
}
export interface FilterPill {
    key: string;
    label: string;
    count?: number;
    active?: boolean;
    bg?: string;
    color?: string;
}
export interface SearchField {
    key: string;
    label: string;
    type: 'text' | 'date' | 'select';
    options?: SelectOption[];
    placeholder?: string;
}
export interface DocumentListCompany {
    uuid: string | number;
    code: string | number;
    name: string;
    isSelectedByDefault?: boolean;
}
export interface WizardOption {
    id: string;
    label: string;
    description?: string;
    icon?: ReactNode;
    color?: string;
}
export interface ApprovalStep {
    label: string;
    status: 'completed' | 'current' | 'pending';
}
export interface ActionBarProps {
    breadcrumbLabel: string;
    /**
     * Título de la cabecera: el rótulo de la CLASE de documento
     * (`identity.label`, p.ej. «Devolución de Venta»), que es el análogo del
     * nombre del maestro en MasterCrud. Ausente ⇒ cae a `breadcrumbLabel`.
     */
    documentTitle?: string;
    /**
     * Nombre de la compañía, pintado como badge bajo el título. Ausente ⇒ no se
     * pinta: no toda plantilla lo declara.
     */
    companyName?: string;
    onBreadcrumbClick: () => void;
    /** UUID interno del documento. Se usa para navegación/refetch, NO para display. */
    documentId?: string;
    /**
     * Número de documento legible (p.ej. "PV-2026-004821" o una etiqueta
     * "pendiente"). Es lo que se muestra como título en negrita; cae a
     * `documentId` solo si no hay número disponible.
     */
    documentNumber?: string;
    stateBadge?: StateBadgeConfig;
    docTypeBadge?: string;
    transitions: TransitionConfig[];
    onTransition: (to: string) => void;
    actions: ActionConfig[];
    onToggleFactBox?: () => void;
    factBoxOpen?: boolean;
    className?: string;
}
export interface ContextStripProps {
    items: ContextStripItem[];
    currencyPanel?: ReactNode;
    className?: string;
}
export interface HeaderRendererProps {
    mode: HeaderMode;
    columns: 1 | 2 | 3 | 4;
    sections: SectionConfig[];
    fieldsBySection: Record<string, FieldDescriptor[]>;
    values: DocumentHeaderData;
    errors?: FieldErrorMap;
    onFieldChange: (key: string, value: unknown) => void;
    docState: string;
    mode_form: 'create' | 'edit' | 'view';
    /**
     * Si el documento tiene al menos una línea. Lo deriva el kit (`lines.length > 0`)
     * y se usa para evaluar `FieldDescriptor.lockedWhen.hasLines`.
     */
    hasLines?: boolean;
    className?: string;
    /** Mapa de configs LookupField por key de campo searcher. */
    lookupConfigs?: Record<string, LookupFieldConfig>;
    /** Fetcher del adapter para campos searcher. */
    fetcher?: unknown;
    /** Callback cuando un LookupField selecciona un registro (para bindFields). */
    onRecordSelect?: (fieldKey: string, record: Record<string, unknown> | null) => void;
}
export interface LinesSectionProps {
    title: string;
    lines: DocumentLineData[];
    columns: LineColumnConfig[];
    lineFields: FieldDescriptor[];
    alerts?: Array<{
        label: string;
        bg: string;
        color: string;
    }>;
    canAddLine: boolean;
    onAddLine: () => void;
    onEditLine: (lineId: string) => void;
    /** Opcional desde que existe `lineDeletable`: un documento que no borra no debería
     *  verse obligado a inventar un callback muerto para satisfacer el tipo. */
    onDeleteLine?: (lineId: string) => void;
    onDuplicateLine?: (lineId: string) => void;
    /**
     * Indica si las líneas son editables. Por defecto `true`.
     *
     * Cuando es `false`, no se renderiza el botón lápiz (`aria-label="Editar línea"`)
     * ni el ítem "Editar" del menú contextual. En su lugar, si se provee
     * `onViewLine`, se muestra la acción "Ver" (icono ojo) que abre la línea en
     * solo-lectura. No afecta agregar, eliminar ni duplicar líneas.
     */
    lineEditable?: boolean;
    /**
     * Indica si las líneas se pueden ELIMINAR. Por defecto `true`.
     *
     * Cuando es `false`, la afordancia de borrado por línea NO SE RENDERIZA: ni el
     * botón de la fila ni el ítem del menú de más opciones. Simétrico a
     * `lineEditable`.
     *
     * Existe porque eliminar era la única de las cuatro operaciones de línea sin
     * gobierno —agregar tiene `canAddLine`, editar `lineEditable` y duplicar es
     * opcional—, así que un documento de sólo consulta no tenía forma de declarar
     * que no borra. Y desde 1.0.333 el botón salió del menú a la fila, con lo que
     * el hueco pasó de invisible a estar a la vista.
     */
    lineDeletable?: boolean;
    /**
     * Abre la línea en modo solo-lectura ("Ver"). Solo se usa cuando
     * `lineEditable === false`: la acción "Ver" (icono ojo) reemplaza a "Editar"
     * en el lápiz inline, el ítem del menú kebab y la tarjeta móvil.
     */
    onViewLine?: (lineId: string) => void;
    activeLineId?: string | null;
    /**
     * Id de la línea con una mutación en vuelo (guardar, borrar o duplicar).
     * Esa fila sustituye su grupo de acciones por un indicador y lo mantiene
     * visible, en vez de esconderlo hasta el hover como en reposo.
     *
     * Es UNA línea y no una lista: a diferencia de las acciones de fila del
     * listado, las del documento sí están serializadas por `state.saving`, que
     * deshabilita la barra mientras dure la mutación.
     */
    busyLineId?: string | null;
    currentBreakpoint?: Breakpoint;
    className?: string;
    /** Activates checkbox column and fulfillment badge column. */
    selectionMode?: boolean;
    /** IDs of currently selected lines (controlled). */
    selectedLineIds?: string[];
    /** Called when the user toggles a line checkbox. */
    onLineSelect?: (lineId: string, selected: boolean) => void;
    /**
     * Fulfillment status per line ID.
     * Lines with Fulfilled or Closed status get a disabled checkbox.
     */
    lineStatuses?: Record<string, LineFulfillmentStatus>;
    /**
     * Inline error message per line ID shown when user attempts
     * to select a Fulfilled or Closed line.
     */
    lineSelectionErrors?: Record<string, string>;
    /** Opens the close/reopen modal for a specific line. */
    onOpenLineCloseModal?: (lineId: string, description: string, mode: 'close' | 'reopen') => void;
    /** Which line-level actions are available (from template.crossing.lineActions). */
    lineActions?: {
        close?: boolean;
        reopen?: boolean;
    };
    /**
     * Acciones de línea ADICIONALES (declarativas) a ANEXAR al menú de fila, junto
     * a las acciones quemadas. Las construye `SmartMasterDocument` desde
     * `template.lineActionRegistry` (gateadas por estado de línea/documento). Si se
     * omite, el menú es idéntico al actual. No reemplaza a `onOpenLineCloseModal`
     * ni a `lineActions` (mecanismo de las acciones quemadas).
     */
    getLineActions?: (line: DocumentLineData) => RowAction[];
    /**
     * Oculta el título de la sección (no las alertas ni el botón "Nueva línea").
     * Lo usa el contenedor de pestañas: la barra ya nombra la pestaña activa y el
     * título quedaría duplicado. Ausente ⇒ `false` (comportamiento sin cambios).
     */
    hideTitle?: boolean;
}
/**
 * Pestaña del área de detalle, YA RESUELTA para el nivel presentacional.
 *
 * `MasterDocument` es tonto por diseño: no conoce el template, los permisos ni el
 * registro de renderers del host. El contenedor smart resuelve todo eso y entrega
 * cada pestaña con su etiqueta ya traducida y, para los tipos 2 y 3, un `render`
 * que ya cerró sobre el contexto del documento.
 *
 * @see DetailTabTemplate — la forma declarativa en el template
 * @see LineTabRenderContext — lo que recibe el renderer del host
 */
export interface LineTabConfig {
    /** Identificador único dentro del documento. */
    key: string;
    /** Etiqueta visible, ya resuelta (`labelKey` → catálogo → `label` → default). */
    label: string;
    /** Icono ya resuelto a nodo. */
    icon?: ReactNode;
    /** Tipo de contenido. `'lines'` monta la grilla nativa; el resto usa `render`. */
    type: 'lines' | 'flexQuery' | 'render';
    /**
     * Contenido de la pestaña. Requerido para `flexQuery` y `render`; ignorado para
     * `lines`, que monta `LinesSection` con todos los props del documento.
     *
     * Se invoca solo mientras la pestaña está activa: al cambiar de pestaña el
     * contenido se DESMONTA en vez de ocultarse, porque la grilla nativa mide su
     * contenedor de scroll para virtualizar y con `display:none` mediría cero.
     *
     * Recibe los ayudantes que solo el nivel presentacional puede dar, porque es
     * quien tiene el estado: hoy, abrir el modal de una línea.
     */
    render?: (helpers: LineTabHelpers) => ReactNode;
}
/**
 * Ayudantes que `MasterDocument` inyecta al contenido de una pestaña.
 *
 * Existen porque el modal de línea es estado interno del componente
 * presentacional: el contenedor smart construye el contexto del renderer, pero no
 * puede abrir un modal que no controla. `LineTabsRegion` hace de correa.
 */
export interface LineTabHelpers {
    /** Abre la línea en el modal de solo lectura del kit. */
    openLineDetail: (lineId: string) => void;
}
/**
 * Filtro externo resuelto, listo para la prop `externalFilters` de
 * `<FlexQuery>`. Misma forma que su `FlexFilter`, declarada aquí porque el kit no
 * depende del paquete.
 */
export interface LineTabExternalFilter {
    /** Columna del modelo EF; admite navegación con puntos. */
    column: string;
    /** Operador ya resuelto (el template omite `op` para decir `'eq'`). */
    op: import('./template/MasterDocumentTemplate.types').DetailTabFilterOp;
    /** Valor de la comparación. Irrelevante para `isNull`/`isNotNull`. */
    value: unknown;
}
/**
 * Contexto que el kit inyecta en el renderer del host de una pestaña Tipo 2 o
 * Tipo 3. Es el contrato real de la capacidad: todo lo que el host necesita para
 * pintar su listado sin re-derivar estado del documento ni duplicar el gateo de
 * acciones.
 *
 * Los nombres siguen los de las props de `<FlexQuery>`
 * (`@SiesaTeams/flex-query` npm 0.4.0) para que el cableado del host sea un
 * paso-a-través y no una traducción.
 */
export interface LineTabRenderContext {
    /** Pestaña que se está renderizando. */
    tabKey: string;
    documentId: string;
    documentClass?: string;
    docState: string;
    mode: 'create' | 'edit' | 'view';
    headerValues: DocumentHeaderData;
    /**
     * Locale BCP 47 del idioma activo (`'es-CO'`, `'en-US'`), resuelto por el kit.
     * Son exactamente los valores que acepta la prop `locale` de `<FlexQuery>`:
     * pásalo tal cual en vez de fijar un idioma, o la consulta quedará en español
     * dentro de un documento en inglés.
     */
    locale: string;
    /**
     * Tipo 2: el descriptor declarado en el template, sin interpretar por el kit.
     * Sus nombres son los de las props de `<FlexQuery>`. Ausente en Tipo 3.
     */
    flexQuery?: {
        reportCode: string;
        contractBaseUrl?: string;
        labelNamespace?: string;
        /** Presentación y modo de vista: pivot, árbol, virtual, autoLoad, selección. */
        view?: import('./template/MasterDocumentTemplate.types').DetailTabFlexQueryView;
        params?: Record<string, unknown>;
    };
    /**
     * Qué declaró el template para el clic en fila. `'openLineDetail'` significa
     * que debes cablear `onRowClick` a `openLineDetail(row.id)`.
     */
    rowClick?: import('./template/MasterDocumentTemplate.types').DetailTabRowClick;
    /**
     * Abre una línea del documento en el modal de solo lectura del kit, con las
     * secciones y campos que el template ya declara. Si el id no corresponde a
     * ninguna línea cargada, no hace nada.
     *
     * Es la contrapartida de `rowClick: 'openLineDetail'`: la consulta lista, y el
     * detalle de la línea lo sigue pintando el kit — sin que el host tenga que
     * reconstruir un formulario que ya existe.
     */
    openLineDetail: (lineId: string) => void;
    /**
     * Filtros externos ya resueltos contra el documento, con la forma exacta de la
     * prop `externalFilters` de `<FlexQuery>` (`FlexFilter[]`). Los filtros cuyo
     * `headerField` no tiene valor no aparecen. Vacío o ausente ⇒ no pases la prop.
     */
    externalFilters?: LineTabExternalFilter[];
    /** Columnas del template ya filtradas por permiso y condición. */
    columns: LineColumnConfig[];
    /**
     * Acciones de fila ya gateadas por estado de línea, `docState` y permisos.
     * Construidas por el kit desde `template.lineActionRegistry`: ejecutarlas por
     * aquí conserva el manejo de `ActionResult`, refetch y toast, y el round-trip
     * de `row_version`. Devuelve `[]` cuando el documento no declara acciones.
     */
    rowActions: (row: Record<string, unknown>) => RowAction[];
    /**
     * Se incrementa tras cada mutación de línea del kit. Úsalo como dependencia
     * del fetch para refrescar la consulta sin exponer un ref imperativo.
     */
    refreshToken: number;
    /** Hay una mutación del documento en vuelo: deshabilita tus acciones. */
    busy: boolean;
    formatCurrency: (value: number) => string;
    formatDate?: (value: string) => string;
    formatNumber?: (value: number) => string;
}
export interface LineTabsBarProps {
    tabs: LineTabConfig[];
    activeKey: string;
    onChange: (key: string) => void;
    className?: string;
}
export interface FactBoxProps {
    sections: FactBoxSectionConfig[];
    className?: string;
    /**
     * @deprecated DEPRECADO y sin efecto. El FactBox dejó de ser un cajón modal por
     * debajo de `xl`: los widgets van en el flujo del documento (ver `FactBoxInline`),
     * así que no hay nada que abrir ni cerrar. Se conservan para no romper la
     * compilación de los hosts que aún los pasan; se retiran en el próximo major.
     */
    open?: boolean;
    /** @deprecated Sin efecto. Ver `open`. */
    onClose?: () => void;
}
export interface FactBoxTotalsProps {
    grandTotal: {
        label: string;
        value: string;
        subtitle?: string;
    };
    kpis: Array<{
        label: string;
        value: string;
        color?: string;
    }>;
    breakdown: Array<{
        label: string;
        value: string;
        color?: string;
        isSummary?: boolean;
    }>;
    className?: string;
}
/**
 * Acción de fila del listado (DEF-4).
 *
 * Describe una acción contextual (ej: Borrar, Anular) disponible para una fila
 * concreta del listado según su estado. La construye el contenedor smart a
 * partir del `actionRegistry` + la disponibilidad por estado, y la consume
 * `DocumentList` para renderizar el ítem en el menú de la fila.
 */
export interface RowAction {
    /** Clave de la acción (ej: 'delete', 'cancel'). */
    key: string;
    /** Etiqueta visible en el menú. */
    label: string;
    /** Ícono opcional ya resuelto a ReactNode. */
    icon?: ReactNode;
    /** Variante visual; `danger` se renderiza en rojo. */
    variant?: ActionVariant;
    /** Ejecuta la acción sobre la fila. El error se propaga vía el contenedor smart. */
    onClick: (row: Record<string, unknown>) => void;
    /** Si true, `DocumentList` pide confirmación con `ConfirmDialog` antes de ejecutar. */
    requiresConfirmation?: boolean;
    /** Mensaje mostrado en el `ConfirmDialog` cuando `requiresConfirmation` es true. */
    confirmationMessage?: string;
    /**
     * Si true, la acción se muestra VISIBLE pero DESHABILITADA (no ejecutable). Lo
     * usan las acciones de línea declarativas para el gateo "visible pero
     * deshabilitada" (D2). `DocumentList` no lo lee; el menú de fila de
     * `LinesSection` sí. Ausente ⇒ habilitada (comportamiento sin cambios).
     */
    disabled?: boolean;
}
export interface DocumentListProps {
    title: string;
    subtitle?: string;
    /** Lista de compañías para el selector desplegable. Si se provee, muestra un dropdown. */
    companies?: DocumentListCompany[];
    /** Compañía seleccionada actualmente. */
    selectedCompany?: DocumentListCompany;
    /** Texto de la compañía como fallback cuando no se usa el array `companies`. */
    companyName?: string;
    onCompanyChange?: (company: DocumentListCompany) => void;
    onExport?: () => void;
    /**
     * Acción de crear. Omitirla deja el botón "+ Nuevo" **ausente**: un listado de
     * solo consulta no tiene por qué inventar un afordance sin destino.
     */
    onCreateNew?: () => void;
    createNewLabel?: string;
    /**
     * ¿Se ofrece la acción de crear? Ausente ⇒ `true` (comportamiento sin cambios).
     *
     * `false` deja el botón "+ Nuevo" **ausente**, no deshabilitado. El listado es
     * presentacional y no resuelve permisos por su cuenta: el contenedor smart
     * (`MasterDocumentPage`) calcula este booleano a partir de
     * `template.list.canCreate` y `template.list.createPermission` contra los
     * permisos del usuario.
     */
    canCreate?: boolean;
    pills: FilterPill[];
    onPillClick: (key: string) => void;
    searchFields: SearchField[];
    searchValues: Record<string, unknown>;
    onSearchChange: (key: string, value: unknown) => void;
    /**
     * Fetcher del adapter (`Fetcher` de LookupField). Lo necesita el embudo de una
     * columna FORÁNEA (`filter.type: 'lookup'`); sin él ese embudo degrada al
     * input de texto con lupa.
     */
    fetcher?: unknown;
    /**
     * Valores activos de los filtros por columna, indexados por el campo que
     * filtra cada uno (`filter.field ?? dataKey ?? key`).
     */
    columnFilters?: Record<string, unknown>;
    /**
     * Cambio de un filtro de columna. Sin este callback las columnas NO pintan el
     * embudo. El valor llega `undefined` cuando el filtro se limpia.
     *
     * El listado es presentacional: no acumula estado ni decide cuándo recargar;
     * eso vive en el contenedor, que ya recarga desde la página 1.
     */
    onColumnFilterChange?: (field: string, value: unknown) => void;
    onSearch: () => void;
    onClearSearch: () => void;
    searchOpen?: boolean;
    onToggleSearch?: () => void;
    columns: DocumentListColumn[];
    rows: Record<string, unknown>[];
    totalCount: number;
    /**
     * Destino de un clic en la fila. **Opcional a propósito**: sin él la fila NO es un
     * enlace, que es el canon de MasterCrud (`tabindex: null`, `cursor: auto`). Sólo
     * los listados con un destino de fila distinto del botón «Editar» lo declaran.
     */
    onRowClick?: (row: Record<string, unknown>) => void;
    /**
     * Acción «Ver» de la fila. **Opcional a propósito**: sólo aparece si el host la
     * declara, porque resuelta por defecto llevaba al mismo detalle que «Editar».
     */
    onViewRow?: (row: Record<string, unknown>) => void;
    onEditRow?: (row: Record<string, unknown>) => void;
    /**
     * URL del detalle de una fila, para que «Ver»/«Editar» se pinten como ENLACE
     * (`<a href>`) en vez de botón.
     *
     * Es lo que devuelve al usuario los gestos que el navegador ya trae: Ctrl/⌘ +
     * clic y clic con la rueda abren el detalle en otra pestaña, el menú contextual
     * ofrece «Abrir en pestaña nueva» y la barra de estado muestra el destino. Un
     * `<button onClick>` no puede dar nada de eso —no tiene semántica de
     * navegación—, y emular la pestaña nueva interceptando `ctrlKey`/`auxclick`
     * para llamar a `window.open` deja fuera el menú contextual, el teclado y los
     * lectores de pantalla, además de topar con el bloqueador de popups.
     *
     * El clic normal (botón primario, sin modificadores) NO navega por el
     * navegador: se cancela con `preventDefault` y corre `onViewRow`/`onEditRow`,
     * así que la navegación de la SPA no cambia.
     *
     * **Opcional a propósito.** Sin él las acciones siguen siendo botones y el
     * comportamiento es idéntico al anterior. Se declara según quién gobierne la
     * navegación: cuando la resuelve `MasterDocumentPage` en línea, la calcula él
     * mismo (`?doc=<id>`); cuando el host navega con su router (`onEditRow`), sólo
     * el host conoce la ruta y es él quien debe construir el `href` —con su router,
     * NUNCA a mano, para no perder el basepath del microfrontend.
     *
     * Devolver `undefined` para una fila la deja como botón: es la degradación
     * correcta cuando falta el id y no hay destino al que enlazar.
     */
    getRowHref?: (row: Record<string, unknown>, action: 'view' | 'edit') => string | undefined;
    onDeleteRow?: (row: Record<string, unknown>) => void;
    /**
     * Acciones de fila gateadas por el estado de cada documento (DEF-4).
     *
     * Se invoca por fila y devuelve las acciones disponibles para el `docState` de
     * esa fila (ej: `delete` solo en DRAFT, `cancel` solo en estados posteriores).
     * Reutiliza el mismo `actionRegistry` que el action bar del detalle.
     *
     * Cuando se provee, TOMA PRECEDENCIA sobre `onDeleteRow`: el menú de fila
     * renderiza exactamente las acciones devueltas (puede ser un array vacío, en
     * cuyo caso la fila no ofrece acciones destructivas). Si una acción declara
     * `requiresConfirmation`, el `DocumentList` muestra el `ConfirmDialog` del kit
     * antes de ejecutar `onClick`.
     *
     * Retrocompatibilidad: si no se provee, se mantiene el comportamiento previo
     * gobernado por `onDeleteRow`.
     */
    getRowActions?: (row: Record<string, unknown>) => RowAction[];
    /**
     * Ids (según `getRowId`) de las filas con una acción destructiva en vuelo.
     * Cada una sustituye su menú por un indicador y deja de aceptar clics, para
     * que "anular" o "eliminar" no se disparen dos veces en una red lenta.
     *
     * Es una lista y no un solo id porque el contenedor no serializa las acciones
     * de fila: puede haber dos en vuelo sobre filas distintas.
     */
    busyRowIds?: string[];
    /**
     * Impresión nativa (acción de presentación). Cuando se provee, el menú de cada
     * fila incluye "Imprimir". El contenedor (`MasterDocumentPage`) lo cablea desde
     * la config `printing` del `MasterDocumentProvider`; no pasa por el adapter.
     */
    onPrintRow?: (row: Record<string, unknown>) => void;
    /** Filtra por fila si "Imprimir" debe mostrarse. Default: visible si `onPrintRow`. */
    isPrintRowAvailable?: (row: Record<string, unknown>) => boolean;
    /** Etiqueta del ítem de impresión. Default: "Imprimir". */
    printLabel?: string;
    bulkMode?: boolean;
    selectedRowIds?: string[];
    onRowSelect?: (rowId: string, selected: boolean) => void;
    getRowId?: (row: Record<string, unknown>) => string;
    bulkConvertOptions?: CrossingClassOption[];
    onBulkConvert?: (classId: string, selectedIds: string[], headerValues?: Record<string, unknown>) => void;
    emptyState?: EmptyStateConfig;
    page: number;
    pageSize: number;
    onPageChange: (page: number) => void;
    /**
     * Registros por página. Presente ⇒ el paginador ofrece el selector de tamaño,
     * igual que el de MasterCrud. Ausente ⇒ el selector no se muestra y el tamaño
     * queda fijo (comportamiento previo, sin cambios para quien no lo pase).
     */
    onPageSizeChange?: (size: number) => void;
    /**
     * Búsqueda básica (la caja visible de la barra, con el embudo del panel
     * avanzado dentro). Es **opt-in**: viaja como `request.search` del
     * `DocumentListRequest`, y ese campo lo honra el adapter de cada superficie —
     * de los adapters de core solo una parte lo mapea. Encenderla donde no se
     * mapea pintaría una caja que no filtra nada, así que la decide la plantilla
     * (`template.list.quickSearch`) y no el kit.
     */
    quickSearchEnabled?: boolean;
    quickSearchPlaceholder?: string;
    quickSearchValue?: string;
    onQuickSearchChange?: (value: string) => void;
    loading?: boolean;
    error?: string;
    onRetry?: () => void;
    className?: string;
}
export interface DocumentCreationWizardProps {
    open: boolean;
    onClose: () => void;
    companies: WizardOption[];
    selectedCompany?: string;
    onSelectCompany: (id: string) => void;
    /**
     * Paso OPCIONAL de clase de documento, renderizado ENTRE compañía y centro de
     * operación. Ausente o vacío ⇒ el wizard se comporta exactamente como sin él:
     * los mismos tres pasos, el mismo `canConfirm` y la misma numeración de
     * `loadingStep` / `errorStep.step`.
     *
     * Existe porque la clase del documento no se puede derivar del tipo: la relación
     * clase ↔ tipo es N:M. Cuando una misma superficie sirve a más de una clase
     * (p.ej. nota crédito de venta y nota crédito de solo valor), la clase deja de
     * estar implícita en el menú y pasa a ser un dato que captura el usuario.
     *
     * De cada `WizardOption` se usan `id` y `label`: el paso se renderiza como
     * `select` —las etiquetas de clase son frases largas— así que `description`,
     * `icon` y `color` no aplican aquí (sí en el paso de tipo, que son tarjetas).
     *
     * Una sola opción + `selectedDocumentClass` + SIN `onSelectDocumentClass` es el
     * caso "el usuario solo puede crear una clase": el `select` queda informativo y
     * sin efecto, que es justo lo que se quiere. Con varias opciones, el handler es
     * indispensable — sin él no hay forma de elegir y el wizard no puede confirmar.
     */
    documentClasses?: WizardOption[];
    selectedDocumentClass?: string;
    onSelectDocumentClass?: (id: string) => void;
    operationCenters: WizardOption[];
    selectedCO?: string;
    onSelectCO: (id: string) => void;
    documentTypes: WizardOption[];
    selectedType?: string;
    onSelectType: (id: string) => void;
    onConfirm: () => void;
    /**
     * Paso cuyo contenido está cargando. Los índices son POSICIONALES, así que el
     * paso de clase los corre cuando está activo:
     *
     * | Índice | Sin `documentClasses` | Con `documentClasses`  |
     * |--------|-----------------------|------------------------|
     * | `1`    | compañía              | compañía               |
     * | `2`    | centro de operación   | **clase de documento** |
     * | `3`    | tipo de documento     | centro de operación    |
     * | `4`    | —                     | tipo de documento      |
     */
    loadingStep?: 1 | 2 | 3 | 4;
    /** Error + reintento de un paso. Misma numeración posicional que `loadingStep`. */
    errorStep?: {
        step: 1 | 2 | 3 | 4;
        message: string;
        onRetry: () => void;
    };
    className?: string;
}
export interface ApprovalBannerProps {
    steps: ApprovalStep[];
    message: string;
    onApprove: () => void;
    approveLabel?: string;
    onReject: () => void;
    rejectLabel?: string;
    className?: string;
}
export interface LookupFieldConfig {
    entity: string;
    displayFields: string[];
    searchFields?: string[];
    displayTemplate?: string;
    valueField?: string;
    pageSize?: number;
    filters?: Record<string, unknown> | unknown[][];
    /** Mapeo de campos del registro seleccionado a campos del formulario. */
    bindFields?: Record<string, string>;
    /**
     * Cascading lookups: filtra este searcher según el valor de otros campos del
     * formulario. Clave = nombre del campo de filtro que espera el backend;
     * valor = key del campo del formulario cuyo valor se usa como filtro.
     * Ej: `{ storageId: "storage_id" }` → manda filtro `{ storageId: <valor del campo "storage_id"> }`.
     * Las entradas cuyo valor resuelto sea null/undefined/"" se omiten (nunca se
     * manda `{ campo: undefined }`). El searcher se deshabilita si falta un padre.
     */
    filterDependencies?: Record<string, string>;
}
export interface FieldRendererProps {
    fieldDef: FieldDescriptor;
    value: unknown;
    onChange: (value: unknown) => void;
    editable: boolean;
    error?: FieldError;
    readOnly?: boolean;
    className?: string;
    /** Config de LookupField para campos control: 'searcher'. */
    lookupConfig?: LookupFieldConfig;
    /** Fetcher del adapter para LookupField. */
    fetcher?: unknown;
    /** Callback cuando LookupField selecciona un registro (para bindFields). */
    onRecordSelect?: (record: Record<string, unknown> | null) => void;
    /**
     * getFilters dinámico para LookupField (cascading lookups). Tiene precedencia
     * sobre los `filters` estáticos del lookupConfig.
     */
    getLookupFilters?: () => unknown;
    /** Valores de los campos padre; al cambiar disparan recarga del LookupField. */
    lookupDependencies?: unknown[];
    /** Deshabilita el control (p.ej. searcher dependiente sin un padre seleccionado). */
    disabled?: boolean;
    /**
     * Bloqueo visual del campo: lo renderiza como solo-lectura con un candado inline
     * junto al label y cursor `not-allowed`. Distinto de `readOnly`/`disabled`
     * (que solo atenúan el control) — comunica una condición de negocio bloqueante.
     */
    locked?: boolean;
    /** Texto del tooltip mostrado al hover sobre el candado cuando `locked` es true. */
    lockTooltip?: string;
    /** Clave i18n del tooltip del candado. Tiene prioridad sobre `lockTooltip`. */
    lockTooltipKey?: string; /**
     * Validadores para las reglas `type: 'custom'` de `validations`, indexados por el
     * `value` de la regla. Sin él, esas reglas se omiten.
     */
    customValidators?: CustomFieldValidators;
}
export interface LineFormModalProps {
    open: boolean;
    onClose: () => void;
    onConfirm: (data: Record<string, unknown>) => void;
    /**
     * Si se provee, muestra el botón "Guardar y agregar otra".
     * Guarda la línea actual, limpia el formulario y mantiene el modal abierto.
     * Solo tiene sentido en modo creación (lineId === null).
     */
    onConfirmAndAddAnother?: (data: Record<string, unknown>) => Promise<FieldErrorMap | undefined> | void;
    fields: FieldDescriptor[];
    initialData?: Record<string, unknown>;
    /** Estado actual del documento — usado para evaluar editableOn de cada campo. */
    docState?: string;
    computedRules?: ComputedRule[];
    serverRules?: import('./template/MasterDocumentTemplate.types').ServerRuleConfig[];
    onEvaluateServerRule?: (ruleId: string, formData: Record<string, unknown>) => Promise<Partial<Record<string, unknown>>>;
    /** Panel lateral informativo. Cuando está presente el modal se ensancha a max-w-[1000px]. */
    widgetSlot?: ReactNode;
    /**
     * Campos adicionales (EAV) de la línea. Se pintan al final del CUERPO del
     * formulario —no en `widgetSlot`, que es informativo y se oculta en móvil—
     * porque son campos de captura y tienen que existir en toda pantalla.
     */
    dynamicEntitiesSlot?: ReactNode;
    /** Notifica al padre los valores actuales del formulario para que actualice el widgetSlot. */
    onFormValuesChange?: (values: Record<string, unknown>) => void;
    errors?: FieldErrorMap;
    /**
     * Mutación en curso: deshabilita los botones de confirmación ("Guardar" /
     * "Guardar y agregar otra") mientras una línea/cabecera se está persistiendo,
     * para reducir la ventana de doble disparo (Caso B).
     */
    busy?: boolean;
    title: string;
    confirmLabel?: string;
    cancelLabel?: string;
    /**
     * Modo solo-lectura. Por defecto `false`.
     *
     * Cuando es `true`, todos los campos se renderizan deshabilitados
     * independientemente de `editableOn`/`docState`, se fuerza el panel de
     * seriales a solo-lectura (`serialReadOnly`) y se ocultan los botones de
     * confirmación (`onConfirm` / `onConfirmAndAddAnother`), dejando únicamente
     * "Cerrar" (`cancelLabel`). Se usa para "Ver línea" en documentos cuyas
     * líneas no son editables (`lineModal.editable === false`).
     */
    readOnly?: boolean;
    columns?: 1 | 2;
    sections?: LineModalSectionConfig[];
    /** Mapa de configs LookupField por key de campo searcher (incluye bindFields). */
    lookupConfigs?: Record<string, LookupFieldConfig>;
    /** Fetcher del adapter para campos searcher. */
    fetcher?: unknown;
    /**
     * Valores actuales de la cabecera. Permiten que un searcher de LÍNEA dependa
     * (vía `filterDependencies`) de un campo de CABECERA: cada form-key se resuelve
     * contra el merge `{ ...cabecera, ...línea }` (línea tiene precedencia).
     */
    headerValues?: Record<string, unknown>;
    /**
     * Configuración del panel de seriales (`layout.detail.serialSupport`). Cuando
     * está presente y el ítem de la línea es serializado, el modal renderiza el
     * `SerialPanel` y bloquea Guardar hasta capturar/seleccionar la cantidad
     * requerida. Omitir deja el comportamiento actual sin cambios.
     */
    serialSupport?: import('./template/MasterDocumentTemplate.types').SerialSupportConfig;
    /** Solo lectura del panel de seriales (documento fuera del estado editable). */
    serialReadOnly?: boolean;
    /** `adapter.validateSerial` — requerido en `serialSupport.mode === 'capture'`. */
    validateSerial?: import('./adapter/MasterDocumentAdapter.types').IMasterDocumentAdapter['validateSerial'];
    /** `adapter.fetchAvailableSerials` — requerido en `serialSupport.mode === 'select'`. */
    fetchAvailableSerials?: import('./adapter/MasterDocumentAdapter.types').IMasterDocumentAdapter['fetchAvailableSerials'];
    className?: string;
}
export interface MasterDocumentFormModalSection {
    key: string;
    label: string;
    /** Si false (default), la sección es un bloque flat sin toggle. */
    collapsible?: boolean;
    /** Estado inicial cuando collapsible es true. Default true. */
    defaultOpen?: boolean;
}
export interface MasterDocumentFormModalProps {
    open: boolean;
    onClose: () => void;
    onConfirm: (data: Record<string, unknown>) => void;
    onConfirmAndAddAnother?: (data: Record<string, unknown>) => void;
    fields: FieldDescriptor[];
    initialData?: Record<string, unknown>;
    docState?: string;
    computedRules?: ComputedRule[];
    serverRules?: import('./template/MasterDocumentTemplate.types').ServerRuleConfig[];
    onEvaluateServerRule?: (ruleId: string, formData: Record<string, unknown>) => Promise<Partial<Record<string, unknown>>>;
    widgetSlot?: ReactNode;
    onFormValuesChange?: (values: Record<string, unknown>) => void;
    errors?: FieldErrorMap;
    title: string;
    confirmLabel?: string;
    cancelLabel?: string;
    columns?: 1 | 2;
    sections?: MasterDocumentFormModalSection[];
    className?: string;
}
export interface SkeletonDocumentProps {
    className?: string;
}
export interface SkeletonListProps {
    rows?: number;
    className?: string;
}
export interface ConflictModalProps {
    open: boolean;
    modifiedBy?: string;
    modifiedAgo?: string;
    onReload: () => void;
    /** Acción "Seguir con mis cambios". Solo se invoca/renderiza si `dismissable`. */
    onKeepEditing?: () => void;
    /**
     * `true` (default) ⇒ aviso blando: modal descartable con "Seguir con mis cambios",
     * botón de cerrar y Escape. `false` ⇒ conflicto DURO del servidor (409): la única
     * acción es "Recargar documento" (sin cerrar, sin Escape, sin seguir editando).
     */
    dismissable?: boolean;
    /** Mensaje principal para el modo duro. Default: copy de "cambios no guardados". */
    message?: string;
    className?: string;
}
export interface StateBadgeProps {
    label: string;
    bg: string;
    color: string;
    className?: string;
}
export interface ContentLayoutProps {
    children: ReactNode;
    factBox?: ReactNode;
    factBoxOpen?: boolean;
    onFactBoxClose?: () => void;
    className?: string;
}
export interface LineContextMenuProps {
    open: boolean;
    position: {
        x: number;
        y: number;
    };
    onClose: () => void;
    items: Array<{
        label: string;
        icon?: ReactNode;
        onClick: () => void;
        danger?: boolean;
        separator?: boolean;
        /** Si true, el ítem se renderiza visible pero deshabilitado (no ejecutable). */
        disabled?: boolean;
    }>;
    className?: string;
}
export interface FactBoxCfdeProps {
    data: CfdeData;
    onRetransmit?: () => void;
    onDownloadPdf?: () => void;
    className?: string;
}
export interface FactBoxPaymentTermsProps {
    data: PaymentTermsData;
    className?: string;
}
export interface FactBoxFinancialProps {
    data: FinancialData;
    formatCurrency: (value: number) => string;
    className?: string;
}
export interface FactBoxStatusHistoryProps {
    entries: import('./adapter/MasterDocumentAdapter.types').StatusHistoryEntry[];
    formatDate?: (value: string) => string;
    className?: string;
}
export interface GlobalDiscountControlProps {
    data: GlobalDiscountData;
    onChange: (data: GlobalDiscountData) => void;
    subtotal: number;
    formatCurrency: (value: number) => string;
    editable?: boolean;
    className?: string;
}
export interface MasterDocumentProps {
    /** Título de la cabecera del detalle (`identity.label`). */
    documentTitle?: string;
    /** Compañía del documento, pintada como badge bajo el título. */
    companyName?: string;
    /** UUID interno del documento. Se usa para navegación/refetch, NO para display. */
    documentId?: string;
    /**
     * Número de documento legible que se muestra como título en negrita en la
     * ActionBar. Cae a `documentId` solo si no hay número disponible.
     */
    documentNumber?: string;
    docTypeBadge?: string;
    breadcrumbLabel: string;
    onBreadcrumbClick: () => void;
    docState: string;
    stateBadge?: StateBadgeConfig;
    transitions: TransitionConfig[];
    onTransition: (to: string) => void;
    mode: 'create' | 'edit' | 'view';
    actions: ActionConfig[];
    contextItems: ContextStripItem[];
    currencyPanel?: ReactNode;
    headerLayout: HeaderLayoutConfig;
    headerFields: FieldDescriptor[];
    headerValues: DocumentHeaderData;
    headerErrors?: FieldErrorMap;
    onHeaderFieldChange: (key: string, value: unknown) => void;
    /**
     * Bloque de campos adicionales (EAV) del ENCABEZADO, ya construido por el
     * contenedor smart a partir de `template.dynamicEntities.header`.
     *
     * Se pinta debajo del encabezado y encima del área de detalle: es información
     * del documento, no de sus líneas, y ese es el sitio donde el usuario la busca.
     * Ausente ⇒ no se pinta nada, que es el comportamiento de siempre.
     */
    dynamicEntitiesSlot?: ReactNode;
    lookupConfigs?: Record<string, LookupFieldConfig>;
    fetcher?: unknown;
    onRecordSelect?: (fieldKey: string, record: Record<string, unknown> | null) => void;
    linesTitle?: string;
    lines: DocumentLineData[];
    lineColumns: LineColumnConfig[];
    lineFields: FieldDescriptor[];
    lineComputedRules?: ComputedRule[];
    lineServerRules?: import('./template/MasterDocumentTemplate.types').ServerRuleConfig[];
    onEvaluateServerRule?: (ruleId: string, formData: Record<string, unknown>) => Promise<Partial<Record<string, unknown>>>;
    lineWidgetSlot?: ReactNode;
    /**
     * Bloque de campos adicionales (EAV) de la LÍNEA, construido por el contenedor
     * smart a partir de `template.dynamicEntities.line`.
     *
     * Es una FUNCIÓN y no un nodo porque el bloque necesita saber qué línea está
     * abierta, y esa es la única pieza de estado que el contenedor smart no tiene:
     * el modal de línea lo gobierna `MasterDocument`. Recibe `lineId: null` cuando
     * la línea es nueva —todavía no hay id al que colgar valores— y el bloque se
     * captura igual: se persiste cuando el backend devuelve el id.
     *
     * Va dentro del modal, en el CUERPO del formulario y no en `lineWidgetSlot`:
     * ese panel lateral es informativo y está oculto en pantallas pequeñas
     * (`max-sm:hidden`), así que un campo de captura ahí desaparecería en móvil sin
     * que nada lo advierta.
     */
    lineDynamicEntitiesSlot?: (ctx: {
        lineId: string | null;
    }) => ReactNode;
    onLineFormValuesChange?: (values: Record<string, unknown>) => void;
    lineModalSections?: LineModalSectionConfig[];
    /**
     * Soporte nativo de seriales (`layout.detail.serialSupport`). Cuando está
     * presente y el ítem de la línea es serializado, el modal de línea muestra el
     * `SerialPanel` y bloquea Guardar hasta completar la cantidad requerida.
     */
    serialSupport?: import('./template/MasterDocumentTemplate.types').SerialSupportConfig;
    /** Solo lectura del panel de seriales (documento fuera del estado editable). */
    serialReadOnly?: boolean;
    /** `adapter.validateSerial` — modo `capture`. */
    validateSerial?: import('./adapter/MasterDocumentAdapter.types').IMasterDocumentAdapter['validateSerial'];
    /** `adapter.fetchAvailableSerials` — modo `select`. */
    fetchAvailableSerials?: import('./adapter/MasterDocumentAdapter.types').IMasterDocumentAdapter['fetchAvailableSerials'];
    lineAlerts?: Array<{
        label: string;
        bg: string;
        color: string;
    }>;
    canAddLine?: boolean;
    onAddLine: () => void;
    onEditLine: (lineId: string) => void;
    /** Opcional desde que existe `lineDeletable`: un documento que no borra no debería
     *  verse obligado a inventar un callback muerto para satisfacer el tipo. */
    onDeleteLine?: (lineId: string) => void;
    onDuplicateLine?: (lineId: string) => void;
    /**
     * Acciones de línea ADICIONALES (declarativas) a ANEXAR al menú de fila, junto
     * a las quemadas. Se propaga tal cual a `LinesSection`. Ausente ⇒ menú idéntico
     * al actual.
     */
    getLineActions?: (line: DocumentLineData) => RowAction[];
    /**
     * Indica si las líneas son editables. Por defecto `true`.
     *
     * Cuando es `false`, la acción "Editar" por línea (lápiz inline + ítem del
     * menú kebab) se reemplaza por "Ver" (icono ojo), que abre la línea en
     * solo-lectura mediante el handler interno `handleViewLine`. No afecta
     * agregar, eliminar ni duplicar líneas, ni el modo creación de líneas nuevas.
     *
     * `MasterDocument` lo cruza con el modo: en `view` queda apagado, igual que
     * `canAddLine` y `lineDeletable`. `SmartMasterDocument` lo deriva del template
     * cruzando `lineModal.editable` con `lineModal.editableOn` y el `docState`.
     */
    lineEditable?: boolean;
    /**
     * Indica si las líneas se pueden ELIMINAR. Por defecto `true`.
     *
     * Cuando es `false`, la afordancia de borrado por línea NO SE RENDERIZA: ni el
     * botón de la fila ni el ítem del menú de más opciones. Simétrico a
     * `lineEditable`.
     *
     * Existe porque eliminar era la única de las cuatro operaciones de línea sin
     * gobierno —agregar tiene `canAddLine`, editar `lineEditable` y duplicar es
     * opcional—, así que un documento de sólo consulta no tenía forma de declarar
     * que no borra. Y desde 1.0.333 el botón salió del menú a la fila, con lo que
     * el hueco pasó de invisible a estar a la vista.
     */
    lineDeletable?: boolean;
    /**
     * Callback opcional invocado cuando el usuario abre una línea en modo "Ver"
     * (solo cuando `lineEditable === false`). El modal de solo-lectura lo gestiona
     * `MasterDocument` internamente; este callback es informativo para el caller.
     */
    onViewLine?: (lineId: string) => void;
    onLineSave?: (lineId: string | null, data: Record<string, unknown>) => Promise<FieldErrorMap | undefined> | void;
    /**
     * Pestañas del área de detalle, ya resueltas. **Ausente o vacío ⇒ se renderiza
     * `LinesSection` exactamente como hoy**, sin barra ni contenedor extra.
     *
     * Con una sola pestaña de tipo `lines` la barra tampoco se dibuja: una pestaña
     * sola no es navegación. Cuando además llega `crossing`, la pestaña de
     * trazabilidad se anexa a esta misma barra en vez de abrir una segunda tira.
     */
    lineTabs?: LineTabConfig[];
    /**
     * Pestaña activa (modo controlado). Ausente ⇒ `MasterDocument` gestiona la
     * selección internamente arrancando en la primera pestaña.
     */
    activeLineTabKey?: string;
    /** Notifica el cambio de pestaña. Requerido en modo controlado. */
    onLineTabChange?: (key: string) => void;
    factBoxSections?: FactBoxSectionConfig[];
    conflict?: {
        modifiedBy?: string;
        modifiedAgo?: string;
        onReload: () => void;
        onKeepEditing?: () => void;
        /** `false` ⇒ conflicto duro del servidor (409): modal no descartable. */
        dismissable?: boolean;
        /** Mensaje principal para el modo duro. */
        message?: string;
    };
    /**
     * Banner de acceso denegado (403). Disparado, por ejemplo, cuando `saveHeader`
     * devuelve la clave reservada `_forbidden` en sus errores.
     */
    forbidden?: {
        message: string;
        onDismiss?: () => void;
    };
    crossing?: {
        sourceSelector?: {
            selectedDocuments: CrossingSourceDocument[];
            onAdd: (doc: CrossingSourceDocument) => void;
            onRemove: (docId: string) => void;
            locked: boolean;
            searchDocuments: (query: string) => Promise<CrossingSourceDocument[]>;
        };
        selectionMode: boolean;
        selectedLineIds: string[];
        onLineSelect: (lineId: string, selected: boolean) => void;
        onTrySelectTerminalLine: (lineId: string) => void;
        lineStatuses: Record<string, LineFulfillmentStatus>;
        lineSelectionErrors: Record<string, string>;
        /** Líneas pendientes de los documentos origen seleccionados (FE-02). */
        pendingLines: PendingLine[];
        /** Cantidad a cruzar por línea (lineId → cantidad). */
        quantitiesToCross: Record<string, number>;
        onQuantityChange: (lineId: string, quantity: number) => void;
        /** Formateador numérico (locale-aware) para las cantidades del panel de pendientes. */
        formatNumber?: (value: number) => string;
        pendingLinesFetchedAt: string | null;
        pendingLinesLoading: boolean;
        onRefreshPendingLines: () => void;
        activeTab: 'lines' | 'traceability';
        onTabChange: (tab: 'lines' | 'traceability') => void;
        traceabilityLabel: string;
        traceabilityTree: TraceabilityTreeNode | null;
        traceabilityLoading: boolean;
        traceabilityError: string | undefined;
        onRetryTraceability: () => void;
        onTraceabilityNodeClick: (nodeId: string) => void;
        classMenuOptions: CrossingClassOption[];
        onSelectClass: (classId: string) => void;
        canGenerate: boolean;
        lineCloseModal: {
            open: boolean;
            mode: 'close' | 'reopen';
            lineDescription: string;
            isLoading: boolean;
            error: string | undefined;
        };
        onOpenLineCloseModal: (lineId: string, description: string, mode: 'close' | 'reopen') => void;
        onCloseLineCloseModal: () => void;
        onConfirmLineClose: (reason?: string) => void;
        lineActions?: {
            close?: boolean;
            reopen?: boolean;
        };
        generateModal: {
            open: boolean;
            classId: string;
            classLabel: string;
            isLoading: boolean;
            error: string | undefined;
        };
        onOpenGenerateModal: (classId: string, classLabel: string) => void;
        onCancelGenerateModal: () => void;
        onConfirmGenerate: (headerValues: Record<string, unknown>) => void;
        generateError: string | undefined;
        onClearGenerateError: () => void;
        generateHeaderFields?: import('./template/MasterDocumentTemplate.types').CrossingGenerateField[];
        /** Errores a nivel de documento (BR-11, BR-13, BR-15, BR-16) mostrados como banners de página */
        pageErrors?: string[];
        onDismissPageError?: (index: number) => void;
    };
    loading?: boolean;
    error?: string;
    onRetry?: () => void;
    /**
     * Mutación en curso (saveHeader/saveLine/transición/acción). Deshabilita el
     * botón de guardar línea para reducir la ventana de doble disparo (Caso B).
     */
    busy?: boolean;
    /**
     * Id de la línea con una mutación en vuelo. `busy` dice que HAY una mutación,
     * no CUÁL: esto añade la identidad para que solo esa fila muestre el
     * indicador. Se propaga a `LinesSection`.
     */
    busyLineId?: string | null;
    className?: string;
}
export type LineFulfillmentStatus = 'Pending' | 'Partial' | 'Fulfilled' | 'Closed';
export interface LineFulfillmentBadgeProps {
    status: LineFulfillmentStatus;
    className?: string;
}
export interface StaleDataBannerProps {
    fetchedAt: string;
    staleThresholdSeconds?: number;
    onRefresh: () => void;
    isRefreshing?: boolean;
    className?: string;
}
export interface CrossingClassOption {
    id: string;
    label: string;
    description?: string;
}
export interface CrossingClassMenuProps {
    options: CrossingClassOption[];
    onSelect: (classId: string) => void;
    disabled?: boolean;
    className?: string;
}
export interface CrossingSourceDocument {
    id: string;
    number: string;
    classLabel: string;
}
export interface CrossingSourceSelectorProps {
    selectedDocuments: CrossingSourceDocument[];
    onAdd: (document: CrossingSourceDocument) => void;
    onRemove: (documentId: string) => void;
    locked?: boolean;
    /** Async search function wired to backend. When omitted, falls back to manual entry. */
    searchDocuments?: (query: string) => Promise<CrossingSourceDocument[]>;
    className?: string;
}
export interface LineCloseModalProps {
    open: boolean;
    onClose: () => void;
    onConfirm: (closeReason?: string) => void;
    mode: 'close' | 'reopen';
    lineDescription?: string;
    isLoading?: boolean;
    error?: string;
    className?: string;
}
/**
 * Línea pendiente de un documento ORIGEN, candidata a cruzarse (FE-02).
 * Espeja `PendingLineDto` del backend (FEAT-094). El frontend renderiza
 * `lineStatus` tal cual lo devuelve el backend (no lo recalcula).
 */
export interface PendingLine {
    lineId: string;
    sourceDocumentId: string;
    documentNumber?: string;
    itemCode?: string;
    itemDescription?: string;
    quantityOrdered?: number;
    quantityFulfilled?: number;
    quantityPending: number;
    unitOfMeasure?: string;
    unitPrice?: number | null;
    lineStatus: LineFulfillmentStatus;
}
export interface PendingLinesPanelProps {
    lines: PendingLine[];
    selectedLineIds: string[];
    /** Cantidad a cruzar por línea (lineId → cantidad). */
    quantities: Record<string, number>;
    /** Errores de validación inline por línea (lineId → mensaje). */
    errors?: Record<string, string>;
    loading?: boolean;
    onLineSelect: (lineId: string, selected: boolean) => void;
    onTrySelectTerminalLine?: (lineId: string) => void;
    onQuantityChange: (lineId: string, quantity: number) => void;
    formatNumber?: (value: number) => string;
    className?: string;
}
export interface CrossingGenerateModalProps {
    open: boolean;
    classLabel: string;
    fields: import('./template/MasterDocumentTemplate.types').CrossingGenerateField[];
    onConfirm: (headerValues: Record<string, unknown>) => void;
    onCancel: () => void;
    isLoading?: boolean;
    error?: string;
}
/** Tipo de documento origen en el modelo whole-document. ECD suma (+1), DCD resta (−1). */
export type CrossingDocumentType = 'ECD' | 'DCD';
/**
 * Documento origen ENTERO candidato a cruzarse (Épica 105-5, AC-E105-5.1).
 * Espeja `AvailableSourceDocumentDto` del backend (FEAT-094 Epic 94-16). Los
 * montos viajan SIEMPRE positivos; el signo (`crossingSign`) solo agrega al
 * subtotal — no se remultiplica el monto.
 */
export interface AvailableSourceDocument {
    id: string;
    /** Número visible del documento (prefijo + consecutivo). */
    number: string;
    /** ECD / DCD. Si el backend no lo envía, se deriva del `crossingSign`. */
    type: CrossingDocumentType;
    classLabel: string;
    /** Signo de cruce: +1 para ECD (suma), −1 para DCD (resta). */
    crossingSign: 1 | -1;
    /** Total neto del documento (positivo). */
    netTotal: number;
    date?: string;
    /** Nº de líneas del documento origen (AC-E105-5.1). Opcional: el DTO puede no traerlo. */
    lineCount?: number;
    /** Estado del documento origen (p. ej. POSTED). */
    state?: string;
}
/**
 * Documento origen YA cruzado a este documento (Épica 105-5, AC-E105-5.3/5.4).
 * Alimenta el widget FactBox "Documentos origen" y muestra la transición
 * POSTED→INVOICED del padre tras APPROVE.
 */
export interface CrossedSourceDocument {
    id: string;
    number: string;
    type: CrossingDocumentType;
    classLabel: string;
    crossingSign: 1 | -1;
    netTotal: number;
    /** Estado del padre cruzado (p. ej. 'POSTED' | 'INVOICED'). */
    state?: string;
    date?: string;
}
/** Textos (i18n) sobreescribibles del panel whole-document. Defaults en español. */
export interface CrossDocumentsMessagesConfig {
    title?: string;
    emptyAvailable?: string;
    subtotalLabel?: string;
    crossButton?: string;
    uncross?: string;
    lineCountLabel?: string;
    crossedTitle?: string;
    emptyCrossed?: string;
}
export interface CrossDocumentPanelProps {
    /** Documentos origen disponibles para cruzar (no cruzados aún). */
    available: AvailableSourceDocument[];
    /** Ids seleccionados del set `available`. */
    selectedIds: string[];
    /** Subtotal corrido `Σ(ECDs.net) − Σ(DCDs.net)` de la selección. */
    subtotal: number;
    loading?: boolean;
    /** Operación cross/uncross en vuelo. */
    busy?: boolean;
    /**
     * Si `false`, el panel se muestra en modo histórico (read-only): sin checkboxes,
     * sin botón Cruzar, sin "Desvincular". Gateado por estado + permiso.
     */
    editable?: boolean;
    error?: string;
    onToggleSelect: (id: string, selected: boolean) => void;
    onCross: () => void;
    onRefresh?: () => void;
    /** Formato de moneda. Default: `Intl.NumberFormat('es-CO')`. */
    formatCurrency?: (value: number) => string;
    messages?: CrossDocumentsMessagesConfig;
    className?: string;
}
export interface SourceDocumentsFactBoxProps {
    /** Documentos padre ya cruzados a este documento. */
    documents: CrossedSourceDocument[];
    /** Subtotal consolidado opcional. */
    subtotal?: number;
    /** Si `true`, muestra "Desvincular" por documento (gateado por estado + permiso). */
    editable?: boolean;
    /** Operación uncross en vuelo. */
    busy?: boolean;
    onUncross?: (sourceDocumentId: string) => void;
    formatCurrency?: (value: number) => string;
    messages?: CrossDocumentsMessagesConfig;
    className?: string;
}
export interface TraceabilityTreeNode {
    id: string;
    number: string;
    classLabel: string;
    status: string;
    quantityOrdered?: number;
    quantityFulfilled?: number;
    isCurrent?: boolean;
    parents: TraceabilityTreeNode[];
    children: TraceabilityTreeNode[];
}
export interface DocumentTraceabilityTreeProps {
    /** Pre-fetched tree data. Pass null to show empty state. */
    tree: TraceabilityTreeNode | null;
    onNodeClick?: (nodeId: string) => void;
    loading?: boolean;
    error?: string;
    onRetry?: () => void;
    className?: string;
}
/** Estado por documento del bulk N→N (FE-07): ✅ success / ⚠️ partial / ❌ failed. */
export type BulkConversionResultStatus = 'success' | 'partial' | 'failed';
export interface BulkConversionResult {
    sourceDocumentId: string;
    sourceDocumentNumber?: string;
    status: BulkConversionResultStatus;
    childDocumentId?: string;
    childDocumentNumber?: string;
    /** Líneas que no pudieron cruzarse (resultado 'partial'). */
    blockedLines?: string[];
    errorCode?: string;
    errorMessage?: string;
}
/** Estado del job de bulk: Pending → Running → Completed/Failed (o Cancelled). */
export type BulkConversionJobStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
export interface BulkConversionJob {
    jobId: string;
    status: BulkConversionJobStatus;
    total: number;
    processed: number;
    results: BulkConversionResult[];
}
export interface BulkConversionProgressProps {
    job: BulkConversionJob;
    onCancel: () => void;
    onClose: () => void;
    onViewResults: () => void;
    className?: string;
}
export interface BulkResultsSummaryProps {
    open: boolean;
    results: BulkConversionResult[];
    onRetryFailed: (failedIds: string[]) => void;
    onClose: () => void;
    className?: string;
}
//# sourceMappingURL=MasterDocument.types.d.ts.map