@tinya-code/gas-admin-ui 0.2.0-alpha.12 → 0.2.0-alpha.15

package/types/tinya-code-gas-admin-ui.d.ts

@@ -1,3632 +0,0 @@
-import * as i0 from "@angular/core";
-import { EnvironmentProviders, InjectionToken, Provider, Signal, TemplateRef, Type } from "@angular/core";
-import { CanActivateFn, Route, Router, Routes } from "@angular/router";
-import { Observable } from "rxjs";
-import { HttpClient, HttpEvent, HttpHeaders, HttpInterceptorFn, HttpParams } from "@angular/common/http";
-import { CdkDragDrop } from "@angular/cdk/drag-drop";
-import { LucideIcon } from "@lucide/angular";
-import { FieldTree, PathKind, SchemaFn, SchemaPath, SchemaPathRules } from "@angular/forms/signals";
-/**
- * Modelos del schema de recursos — única fuente de verdad de la UI.
- * Especificación: doc/base.md §3–§7 y §9.
- *
- * Contrato de imágenes (decisión api.md §1): `image_url` en todo el JSON.
- */
-/** Anchos de columna dentro de una fila del layout (base.md §4: 1–12). */
-export type GridWidth = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
-/** Operadores de `visibleWhen` / `readonlyWhen` (base.md §4). */
-export type ConditionOperator = 'eq' | 'ne' | 'empty' | 'contains';
-/**
- * Condición simple sobre otro campo del mismo nivel o del registro raíz.
- * Ej.: `{ field: 'availability', operator: 'eq', value: 'PreOrder' }`.
- */
-export interface FieldCondition {
-  field: string;
-  operator: ConditionOperator;
-  /** Valor de comparación; no aplica para `empty`. */
-  value?: string | number | boolean;
-}
-/**
- * Reglas de validación comunes (base.md §4).
- * Nota: algunas se solapan con opciones propias del tipo (§5); el motor de
- * validación (Fase 10) los fusiona y `validators` tiene prioridad.
- */
-export interface FieldValidators {
-  minLength?: number;
-  maxLength?: number;
-  pattern?: string;
-  min?: number;
-  max?: number;
-  minWords?: number;
-  maxWords?: number;
-  /** El valor debe ser único en el recurso (validación asíncrona). */
-  unique?: boolean;
-}
-/** Propiedades comunes a todo campo (base.md §4). */
-export interface FieldBase<T> {
-  /** Nombre de la propiedad en el JSON que envía/recibe el back. */
-  key: string;
-  /** Rótulo visible para el usuario en el formulario y la ficha. */
-  label: string;
-  /** Texto corto de ayuda que se muestra debajo del campo. */
-  help?: string;
-  /** Texto sugerente que se muestra dentro del input cuando está vacío. */
-  placeholder?: string;
-  /** Si es obligatorio. El back también lo valida (R7.4). */
-  required?: boolean;
-  /** Valor por defecto si el registro no trae este campo (ej. `default: 'none'` en un `select`/`dropdown`). */
-  default?: T;
-  /** Si el campo es solo lectura (no editable en el formulario). */
-  readonly?: boolean;
-  /** Bloquea el campo solo en creación, solo en edición o siempre. */
-  readonlyOn?: 'create' | 'update' | 'always';
-  /** Condición bajo la cual el campo es solo lectura (expresión sobre otros campos). */
-  readonlyWhen?: FieldCondition;
-  /** Condición bajo la cual el campo se muestra u oculta. */
-  visibleWhen?: FieldCondition;
-  /**
-   * Ciclo de vida de la VISIBILIDAD: oculta el campo en creación, en edición
-   * o siempre. Símétrico a `readonlyOn`, pero NO lo mismo que `visibleWhen`,
-   * que expresa una condición sobre el valor de otro campo.
-   *
-   * Vale para los campos que LLENA EL BACK (`ref`, `pin`): en alta no existen
-   * aún, así que mostrarlos vacíos y solo-lectura con un `help` que dice "se
-   * genera solo al guardar" es ruido ocupando la sección. `hidden()` de Signal
-   * Forms además los deja FUERA de la validación y del payload
-   * (field-host:311 no los dibuja, form-model:52 los salta).
-   */
-  hiddenOn?: 'create' | 'update' | 'always';
-  /**
-   * Selección dependiente (guía §1: país → ciudad). Clave del campo padre
-   * del MISMO nivel: mientras el padre esté vacío este campo queda
-   * `disabled`, y si el padre cambia el hijo se reinicia a su valor por
-   * defecto (plan 6.6).
-   */
-  dependsOn?: string;
-  /** Reglas de validación (mínimo, máximo, patrón, unicidad, etc.). */
-  validators?: FieldValidators;
-  /** Ancho en la grilla del formulario (1–12), igual que un widget del dashboard. */
-  width?: GridWidth;
-  /** Id de la sección/pestaña del layout a la que pertenece (base.md §4). */
-  section?: string;
-  /**
-   * R7.5: acceso por campo (B8 · R7.4b) — sólo UX; el back vuelve a
-   * verificar en cada petición.
-   */
-  access?: {
-    /** Código de nivel de acceso requerido para leer el campo. */
-    read?: string;
-    /** Código de nivel de acceso requerido para escribir el campo. */
-    write?: string;
-  };
-  /**
-   * Descripción corta de para qué sirve este campo. Se muestra como tooltip
-   * al pasar el cursor sobre el rótulo en el formulario y la ficha.
-   */
-  description?: string;
-  /** URL de documentación externa para este campo (se abre al hacer clic en el tooltip). */
-  docLink?: string;
-}
-export interface SelectOption {
-  value: string;
-  label: string;
-  disabled?: boolean;
-}
-export interface TextField extends FieldBase<string> {
-  type: 'text';
-  maxLength?: number;
-  pattern?: string;
-}
-export interface ColorField extends FieldBase<string> {
-  type: 'color';
-}
-export interface TextareaField extends FieldBase<string> {
-  type: 'textarea';
-  rows?: number;
-  minWords?: number;
-  maxWords?: number;
-  /**
-   * Marcadores insertables como chips bajo el área (plantillas de mensaje).
-   * Cada chip escribe `{key}` en la posición del cursor, no al final: el
-   * operador escribe, apreta, sigue escribiendo. El motor back no se entera —
-   * recibe el string final y lo interpola (`interpolateTemplate`).
-   *
-   * `label` es el rótulo humano del botón ("PIN"); `key` es la clave que se
-   * inserta y que el back resuelve contra `config + registro`.
-   */
-  tokens?: readonly TemplateToken[];
-}
-/** Chip insertable en un `textarea` de plantilla. */
-export interface TemplateToken {
-  /** Clave insertada como `{key}` y resuelta por el motor. */
-  key: string;
-  /** Rótulo visible en el chip (el token va como tooltip). */
-  label: string;
-}
-export interface SlugField extends FieldBase<string> {
-  type: 'slug';
-  /** Campo del que se autogenera el slug (ej. `name`). */
-  from: string;
-  /** Bloquea el campo una vez creado el registro (por defecto: sí). */
-  lockAfterCreate?: boolean;
-}
-export interface NumberField extends FieldBase<number> {
-  type: 'number';
-  min?: number;
-  max?: number;
-  step?: number;
-  decimals?: number;
-}
-export interface CurrencyField extends FieldBase<number> {
-  type: 'currency';
-  /** Campo del registro del que se toma la moneda (ej. `currency`). */
-  currencyFrom?: string;
-}
-export interface BooleanField extends FieldBase<boolean> {
-  type: 'boolean';
-  trueLabel?: string;
-  falseLabel?: string;
-}
-/**
- * De dónde salen las opciones de un desplegable: **exactamente una** de las
- * dos formas (XOR en el tipo, D62).
- *
- * - `options` — estáticas en el schema (el caso de las enums: `status`).
- * - `source` — pedidas al fetcher declarado (F8 · R6.5) para listados que
- *   viven en otro recurso.
- *
- * Ninguna ⇒ un desplegable mudo; las dos ⇒ dos verdades para el mismo campo.
- * Ambas reglas viven en este tipo, no en un chequeo en runtime.
- */
-type SelectData = {
-  options: SelectOption[];
-  source?: never;
-} | {
-  options?: never;
-  source: DataSource;
-};
-export type SelectField = FieldBase<string> & {
-  type: 'select';
-} & SelectData;
-export type MultiselectField = FieldBase<string[]> & {
-  type: 'multiselect';
-} & SelectData;
-/**
- * Desplegable nativo (`<select>`) que SIEMPRE se renderiza como lista
- * desplegable, independientemente de cuántas opciones tenga.
- *
- * A diferencia de `select` (que usa radio buttons para 2–4 opciones
- * estáticas por la guía de control §1), este tipo nunca muta a radios.
- * Úsalo cuando necesites un dropdown verdadero aunque tenga pocas opciones.
- */
-export interface DropdownField extends FieldBase<string> {
-  type: 'dropdown';
-  options: SelectOption[];
-}
-/**
- * Opción de un selector visual enriquecido (`rich-select`).
- *
- * Además de `value`/`label`, cada opción puede declarar una `preview` con
- * HTML seguro que el motor renderiza como tarjeta visual (badge, chip con
- * icono, color swatch, etc.). El HTML viaja en el schema y el motor lo
- * pinta tal cual tras pasar por el sanitizador de Angular.
- */
-export interface RichSelectOption {
-  value: string;
-  label: string;
-  disabled?: boolean;
-  /** HTML seguro para pintar como preview de la opción (ej. `<span class="chip">…</span>`). */
-  preview?: string;
-}
-/**
- * Selector visual enriquecido: cada opción se renderiza como tarjeta con su
- * `preview` HTML en vez de un `<select>` nativo o radio buttons planos.
- * Sólo opciones estáticas (sin `source`).
- */
-export interface RichSelectField extends FieldBase<string> {
-  type: 'rich-select';
-  options: RichSelectOption[];
-  /**
-   * Ancho de cada tarjeta de opción en la grilla (1–12), igual que `width`
-   * de un campo. Por defecto `4` (3 tarjetas por fila en escritorio).
-   * Úsalo para opciones con preview larga (menos tarjetas por fila) o
-   * preview corta (más tarjetas).
-   */
-  cardWidth?: GridWidth;
-  /**
-   * Cuántas tarjetas mostrar por fila en el punto de ruptura `lg`.
-   * Sobrescribe el cálculo automático basado en `cardWidth`.
-   * Ejemplo: `2` obliga a 2 columnas grandes sin importar el ancho.
-   */
-  cardCols?: 1 | 2 | 3 | 4 | 5 | 6;
-}
-export interface UrlField extends FieldBase<string> {
-  type: 'url';
-}
-export interface EmailField extends FieldBase<string> {
-  type: 'email';
-}
-export interface PhoneField extends FieldBase<string> {
-  type: 'phone';
-  /** Normalización del valor guardado. */
-  format?: 'e164' | 'digits';
-}
-export interface DateField extends FieldBase<string> {
-  type: 'date';
-  /** Fecha ISO `YYYY-MM-DD` permitida. */
-  min?: string;
-  max?: string;
-}
-export interface TimeField extends FieldBase<string> {
-  type: 'time';
-}
-export interface ReadonlyTextField extends FieldBase<string> {
-  type: 'readonly-text';
-  /** Formato de presentación (texto, fecha, moneda…). */
-  format?: string;
-}
-/**
- * Fuente de datos declarada (F8 · R6.5): UN vocabulario para relations,
- * selects y widgets en lugar de tres. El fetcher es único
- * (`DataSourceService`) y la clave de su caché es `resource+view+params`.
- *
- * `params` son valores interpolados `{campo}` que el front resuelve contra su
- * contexto (el registro del formulario o la fila del widget) y manda como
- * `payload.params`; el back los inyecta en el ctx de las vistas, donde una
- * condición los lee con el operando `param: '<nombre>'`. Una vista que no
- * referencia ese parámetro no se ve afectada por él — sólo cambia la clave
- * de caché.
- *
- * Los parámetros llegan del navegador, así que son ENTRADA: sólo filtran
- * dentro del recurso que la ruta ya autoriza a leer (nunca ensanchan el
- * acceso) y una vista que pide un parámetro ausente queda fail-closed.
- */
-export interface DataSource {
-  /** Recurso declarado (`resource.id`): su listado es el de las opciones. */
-  resource: string;
-  /** Vista declarada en `resource.views` (opcional): filtra en el back. */
-  view?: string;
-  /** Valores interpolados para la vista (`{campo}` ← contexto). */
-  params?: Record<string, string>;
-  /** Etiqueta por defecto de las filas (si no, `titleField` del recurso). */
-  labelField?: string;
-  /** Valor por defecto de las filas (si no, `keyField` del recurso). */
-  valueField?: string;
-}
-export interface RelationField extends FieldBase<string> {
-  type: 'relation';
-  /**
-   * De dónde salen las opciones (F8 · R6.5): `{ resource, view?, params?, … }`.
-   * Antes eran tres claves planas (`resource`/`labelField`/`valueField`);
-   * D62 las unifica con el resto de consumidores.
-   */
-  source: DataSource;
-  /**
-   * Segundo dato a mostrar junto a la etiqueta (guía §1: «Juan Pérez ·
-   * DNI 123»). Se concatena con « · » y forma parte de la opción, así que
-   * también se busca sobre él.
-   */
-  secondaryField?: string;
-  /** Cargar solo registros activos (lo exige además la FK en el back). */
-  onlyActive?: boolean;
-}
-export interface ImageField extends FieldBase<string> {
-  type: 'image';
-  /** Tipos aceptados (ej. `image/*`, `image/png,image/jpeg`). */
-  accept?: string;
-  maxSizeMB?: number;
-  /** Relación de aspecto de la vista previa (ej. `16/9`). */
-  aspectRatio?: string;
-  previewSize?: string;
-}
-export interface FileField extends FieldBase<string> {
-  type: 'file';
-  /** Formatos aceptados (ej. `image/*`, `pdf,docx`). Si falta, usa los del backend. */
-  accept?: string;
-  maxSizeMB?: number;
-}
-export interface GroupField extends FieldBase<Record<string, unknown>> {
-  type: 'group';
-  fields: FieldSchema[];
-  /** Presentación del grupo (base.md §5.4). */
-  display?: 'card' | 'collapsible' | 'inline';
-}
-/** Propiedades comunes a las listas (base.md §6). */
-export interface ListOptions {
-  min?: number;
-  max?: number;
-  /** Si se puede reordenar (por defecto: sí). */
-  sortable?: boolean;
-  /** Campo donde se guarda el orden dentro de cada item (`position`). */
-  positionField?: string;
-  addLabel?: string;
-  emptyText?: string;
-  itemDisplay?: 'card' | 'row' | 'accordion';
-}
-export interface ListField extends FieldBase<Record<string, unknown>[]>, ListOptions {
-  type: 'list';
-  /** Campos de cada item (cualquier tipo, incluso `group` o `list`). */
-  itemFields: FieldSchema[];
-  /** Campo del item usado como título cuando está colapsado. */
-  itemTitle?: string;
-  /** El primer item tiene significado especial (ej. imagen principal). */
-  primaryFirst?: boolean;
-}
-export interface StringListField extends FieldBase<string[]>, ListOptions {
-  type: 'string-list';
-  /** Tipo permitido de cada item (base.md §9: solo text, url o email). */
-  itemType?: 'text' | 'url' | 'email';
-}
-export interface KeyValueItem {
-  key: string;
-  value: string;
-}
-export interface KeyValueField extends FieldBase<KeyValueItem[]>, ListOptions {
-  type: 'key-value';
-}
-/**
- * Base de un widget de panel. Se declara en `ResourceSchema.widgets` — no
- * en `fields`, porque un KPI no es un campo: no se valida, no se envía y
- * `field-host` no lo renderiza. Sólo un recurso `kind: 'dashboard'` los
- * dibuja, y agregar un widget es tocar el schema, no el template.
- *
- * Su `key` es además la clave del dato en la respuesta del endpoint del
- * dashboard (`{ key: 'pendientes' }` ↔ `{ pendientes: 3 }`), salvo que el
- * widget declare otra fuente (F8 · R6.5).
- */
-/**
- * Fuente de datos de un widget: el mismo vocabulario declarado de F8 que usan
- * relations y selects (D62), más el caso «payload del panel».
- *
- * - `DataSource` (`{ resource, view?, params? }`): el widget pide sus filas o
- *   su agregado al recurso declarado vía `DataSourceService`; deja de depender
- *   de que un handler haya armado `data[widget.key]`.
- * - `{ kind: 'payload' }`: lee la respuesta COMPLETA del endpoint del
- *   dashboard (varias claves a la vez).
- */
-export type WidgetSource = DataSource | {
-  kind: 'payload';
-};
-export interface WidgetBase {
-  key: string;
-  label: string;
-  help?: string;
-  /** Ancho en la grilla del panel (1–12), igual que un campo. */
-  width?: GridWidth;
-  /**
-   * Ancho en la grilla en mobile (1–12). Por defecto `12` (ancho completo,
-   * apilado). Declararlo permite controlar el layout responsive en pantallas
-   * chicas sin tocar el ancho de escritorio (`width`).
-   */
-  mobileWidth?: GridWidth;
-  /**
-   * De dónde saca sus datos (F8 · R6.5).
-   *
-   * - **ausente** (por defecto): `data[widget.key]`. Es el contrato normal y
-   *   el que usan los KPI (`{ key: 'pendientes' }` ↔ `{ pendientes: 3 }`).
-   * - **`{ kind: 'payload' }`**: la respuesta COMPLETA, para widgets que se
-   *   componen de varias claves (`status-progress` leyendo `pendientes` +
-   *   `entregados` + `cancelados`) sin que el orquestador tenga que saber
-   *   qué tipo de widget es.
-   * - **`DataSource`**: las filas salen del recurso declarado (vista
-   *   incluida), pedidas al fetcher común.
-   */
-  source?: WidgetSource;
-}
-/** KPI de una cifra suelta («3 pendientes»). */
-export interface MetricCardWidget extends WidgetBase {
-  type: 'metric-card';
-  /** Texto secundario bajo la cifra (estático, va en el schema). */
-  hint?: string;
-}
-/** Barras por categoría con CSS/SVG — sin librería. */
-export interface BarChartWidget extends WidgetBase {
-  type: 'bar-chart';
-  /** Sufijo de las cifras del eje («unidades», «S/»). */
-  unit?: string;
-}
-/**
- * Serie temporal con Chart.js.
- *
- * La librería (61,4 K gz medidos) vive en el chunk que abre el descriptor
- * (`import('./chart-line')`), así que **no entra en el bundle inicial**; el
- * `@defer (on viewport)` que el propio componente dibuja tarda además la
- * creación del lienzo hasta que el gráfico se ve. Ver
- * `widgets/chart-line/chart-line.ts`.
- */
-export interface ChartLineWidget extends WidgetBase {
-  type: 'chart-line';
-  /** Sufijo de las cifras del eje («unidades», «S/»). */
-  unit?: string;
-}
-/** Tabla embebida de registros operativos (ej. pedidos que requieren atención). */
-export interface RecordListWidget extends WidgetBase {
-  type: 'record-list';
-  /**
-   * Claves de columnas a mostrar en la tabla compacta.
-   *
-   * No lleva `resource`: si las filas vienen declaradas, ese recurso ya está
-   * en `source.resource` (D63 retira la clave duplicada — estaba declarada y
-   * nadie la leía).
-   */
-  columns: string[];
-  /** Acción de navegación por fila. */
-  action?: {
-    label: string;
-    routeTemplate: string;
-  };
-}
-/** Grid de botones de accesos directos operativos. */
-export interface QuickActionsWidget extends WidgetBase {
-  type: 'quick-actions';
-  actions: {
-    label: string;
-    icon?: string;
-    navigateTo: string;
-    variant?: 'primary' | 'secondary' | 'outline';
-  }[];
-}
-/** Barra de distribución porcentual de estados o categorías. */
-export interface StatusProgressWidget extends WidgetBase {
-  type: 'status-progress';
-  segments: {
-    key: string;
-    label: string;
-    color: 'success' | 'warning' | 'danger' | 'neutral';
-  }[];
-}
-export type WidgetSchema = MetricCardWidget | BarChartWidget | ChartLineWidget | RecordListWidget | QuickActionsWidget | StatusProgressWidget;
-export type WidgetType = WidgetSchema['type'];
-export type FieldSchema = TextField | TextareaField | SlugField | NumberField | CurrencyField | BooleanField | SelectField | MultiselectField | RichSelectField | DropdownField | UrlField | EmailField | PhoneField | DateField | TimeField | ReadonlyTextField | RelationField | ImageField | FileField | GroupField | ListField | StringListField | KeyValueField | ColorField;
-export type FieldType = FieldSchema['type'];
-export type ListColumnFormat = 'text' | 'badge' | 'thumbnail' | 'boolean' | 'number' | 'currency' | 'date';
-export interface ListColumn {
-  key: string;
-  label: string;
-  /**
-   * Sólo para sobreescribir: sin él manda la tabla de
-   * `columns/column-defaults` (`FORMATO_POR_DEFECTO`) según el `type` del
-   * campo con esta `key` (R4.4).
-   */
-  format?: ListColumnFormat;
-}
-export interface ListFilter {
-  key: string;
-  label: string;
-  type?: 'text' | 'select' | 'boolean';
-  options?: SelectOption[];
-}
-export interface LayoutSection {
-  /** Coincide con `field.section`. */
-  id: string;
-  label: string;
-}
-export type LayoutMode = 'grid' | 'tabs' | 'sections' | 'steps' | 'columns';
-export interface ResourceLayout {
-  /** Presentación del formulario. */
-  mode?: LayoutMode;
-  sections?: LayoutSection[];
-  /** Número de columnas para `mode: 'columns'` (por defecto 2). */
-  columns?: 2 | 3;
-}
-export interface ResourceActionBase {
-  id: string;
-  label: string;
-  icon?: string;
-  variant?: 'primary' | 'secondary' | 'outline' | 'danger';
-  visibleWhen?: {
-    field: string;
-    op: 'eq' | 'neq' | 'in';
-    value: unknown;
-  }[];
-}
-export interface CopyShareAction extends ResourceActionBase {
-  type: 'copy-share';
-  urlTemplate: string;
-  shareTextTemplate?: string;
-}
-export interface NavigateAction extends ResourceActionBase {
-  type?: 'navigate';
-  /** Plantilla con marcadores, ej. `/products/{slug}` o `/admin/orders?id={ref}`. */
-  urlTemplate: string;
-}
-export interface TriggerAction extends ResourceActionBase {
-  /**
-   * Acción de dominio **declarada en el back** (B3 `actions.<name>`,
-   * publicada como `POST /admin/<recurso>/:id/actions/<name>` — R5.4).
-   * El destino no se declara acá: la ruta lógica se deriva en R3.12.
-   */
-  type: 'trigger';
-  /** Nombre de la acción en el back si difiere del `id` de esta declaración. */
-  name?: string;
-  confirmMessage?: string;
-}
-/** Acciones extra de registro o listado (duplicar, compartir, navegar…). */
-export type ResourceAction = CopyShareAction | NavigateAction | TriggerAction;
-/** Configuración de diálogo/modal o acción tras crear un registro con éxito. */
-export interface PostCreateSchema {
-  mode: 'modal' | 'toast' | 'redirect_detail' | 'stay';
-  title?: string;
-  description?: string;
-  summaryFields?: string[];
-  actions?: ResourceAction[];
-}
-/** Configuración de Ficha de Detalle (modo lectura estructurado). */
-export interface DetailViewSchema {
-  enabled: boolean;
-  headerFields?: string[];
-  sections?: {
-    id: string;
-    label: string;
-    fields: string[];
-  }[];
-  actions?: ResourceAction[];
-  allowEdit?: boolean;
-  allowDelete?: boolean;
-}
-/** Operaciones permitidas (base.md §3). `undefined` = permitido. */
-export interface ResourcePermissions {
-  create?: boolean;
-  update?: boolean;
-  remove?: boolean;
-  reorder?: boolean;
-}
-/**
- * Rutas de la API relativas a `API_URL` (base.md §3, api.md §6 Opción A).
- *
- * Marcadores que un path acepta — se resuelven ANTES de despachar la petición
- * (y para ambos drivers):
- *
- * - `{key}` — clave del registro actual; sólo aplica a las operaciones con
- *   clave (`get`, `update`, `remove`). Si llega sin resolver, es error.
- * - `{<fuente>}` / `{<fuente>.<ruta.anidada>}` — valor de una fuente de
- *   contexto: las construidas `auth` (sesión) y `config` (config global), o
- *   cualquier fuente registrada en `provideGasAdmin({ valueSources })`.
- *
- * El valor se codifica como segmento de URL. Un marcador sin valor, o con una
- * fuente no registrada, lanza un error que nombra el path y el marcador: nunca
- * se envía un segmento vacío. Los singleton solo usan `get` / `update`.
- */
-export interface ResourceEndpoints {
-  list?: string;
-  get?: string;
-  create?: string;
-  update?: string;
-  remove?: string;
-  /**
-   * Declaración opcional de cómo unwrappear la respuesta de esta operación.
-   * Cuando se declara, el motor extrae el contenido de `dataKey` antes de
-   * devolverlo al consumidor (ej.: `{ data: [...] }` → `[...]`).
-   * Si no se declara, el motor mantiene el comportamiento actual:
-   * respuesta pasada tal cual (array plano, `{ items }`, o objeto crudo).
-   * Esta declaración es por operación; si se desea un valor global, usarlo
-   * en cada operación o considerar un default a nivel de config en futuro.
-   */
-  responseUnwrap?: ResponseUnwrap;
-}
-/**
- * Cómo el motor debe desempaquetar la respuesta HTTP antes de entregarla.
- * Opcional y opt-in: schemas sin este campo siguen el contrato actual.
- *
- * - `dataKey`: clave en el body que contiene el payload real (ej. `data`,
- *   `items`, `result`). Si el body no tiene esta clave, se devuelve `undefined`
- *   para lista / objeto vacío según corresponda, y se lanza error en modo
- *   estricto si se configura.
- * - `metaKey`: clave con metadatos (paginación, total, etc.). Se ignora en
- *   el valor devuelto al consumidor pero puede leerse si el motor la expone
- *   en futuro.
- * - `apply`: `'list' | 'get' | 'create' | 'update' | 'remove' | 'all'`.
- *   Qué operaciones aplican el unwrap. Por defecto `'all'` cuando se declara.
- */
-export interface ResponseUnwrap {
-  dataKey: string;
-  metaKey?: string;
-  apply?: 'list' | 'get' | 'create' | 'update' | 'remove' | 'all';
-  /**
-   * Claves de metadata de paginación dentro del sobre. Usadas por
-   * `ApiService.listPage()` para armar `PageResult<T>`. Opcional: sin
-   * declaración, el motor intenta auto-detectar claves comunes
-   * (`nextCursor`, `total`, `hasMore`) y, si no hay, `hasMore = false`.
-   */
-  pagination?: {
-    /** Clave del cursor siguiente dentro de `meta` (o del body si no hay `metaKey`). */
-    cursorKey?: string;
-    /** Clave del total de registros. */
-    totalKey?: string;
-    /** Clave del flag booleano "hay más páginas". */
-    hasMoreKey?: string;
-  };
-}
-/**
- * Método HTTP soportado por endpoints personalizados.
- * Declarado aquí (y no en api.service.ts) para evitar ciclos de importación
- * entre modelos y servicios.
- */
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-/**
- * Definición de un endpoint personalizado más allá de los cinco estándar
- * (list/get/create/update/remove). Permite al consumidor declarar rutas con
- * verbos arbitrarios, segmentos extra, payloads JSON o multipart, y unwrap de
- * respuesta propio.
- *
- * Ejemplo:
- *   name: 'recalculate-ranks'
- *   method: 'POST'
- *   path: '/admin/businesses/{businessId}/ranks/recalculate'
- *   payloadMode: 'json'
- */
-export interface CustomEndpointDefinition {
-  /** Nombre único del endpoint dentro del recurso. Se usa para invocarlo. */
-  name: string;
-  /** Método HTTP de la petición. */
-  method: HttpMethod;
-  /** Ruta relativa a `API_URL`. Puede incluir marcadores {key}, {auth.user.id}, etc. */
-  path: string;
-  /** Modo de payload: 'json' (default) o 'multipart' para FormData. */
-  payloadMode?: 'json' | 'multipart';
-  /** Unwrap de respuesta override para este endpoint. Si no se declara, se usa el del recurso. */
-  responseUnwrap?: ResponseUnwrap;
-}
-export interface ResourceSchema {
-  /** Identificador interno (`categories`). */
-  id: string;
-  label: string;
-  labelPlural: string;
-  /**
-   * `collection` → listado, `singleton` → formulario directo,
-   * `dashboard` → panel de sólo lectura (refactormotor.md F4; sus datos llegan
-   * un endpoint declarativo, no de CRUD).
-   */
-  kind: 'collection' | 'singleton' | 'dashboard';
-  endpoint: ResourceEndpoints;
-  /** Campo que identifica el registro (`slug`). */
-  keyField: string;
-  /** Campo que se muestra como nombre del registro. */
-  titleField: string;
-  /** Endpoints personalizados más allá de list/get/create/update/remove. */
-  customEndpoints?: Record<string, CustomEndpointDefinition>;
-  /** Si el listado se reordena (requiere `positionField`). */
-  sortable?: boolean;
-  positionField?: string;
-  listColumns: ListColumn[];
-  filters?: ListFilter[];
-  /** Campos buscables en el listado. */
-  search?: string[];
-  /** Árbol de campos del formulario (base.md §4–§6). */
-  fields: FieldSchema[];
-  /**
-   * Widgets del panel — sólo `kind: 'dashboard'` (refactormotor.md F4).
-   *
-   * Van aparte de `fields`: un KPI no es un campo y no comparte `FieldBase`
-   * (`required`/`visibleWhen`/`validators`…). Decisión tomada tras medir el
-   * ripple de unirlos a `FieldSchema`: 18+ errores de tipos en 4 ficheros.
-   * `contract-check` sólo recorre `fields`, así que esta propiedad no se
-   * compara back↔front — el widget es config de UI, no dato almacenado.
-   */
-  widgets?: WidgetSchema[];
-  layout?: ResourceLayout;
-  actions?: ResourceAction[];
-  /** Configuración de Ficha de Detalle estructurada para el recurso. */
-  detail?: DetailViewSchema;
-  /** Configuración de diálogo/modal post-creación. */
-  postCreate?: PostCreateSchema;
-  permissions?: ResourcePermissions;
-  /**
-   * Acceso declarado por recurso (auth.md §5.3) — **sólo UX**: oculta
-   * ruta, entrada de menú y botones. Aunque el front se manipule, el back
-   * vuelve a verificar en cada petición: esto nunca es una barrera.
-   *
-   * No lo declara ningún schema mientras sólo exista el rol `admin`
-   * (§9.4): sin declaración el efecto es «sesión», que es lo correcto hoy.
-   * Aparece el día que haya un segundo rol.
-   */
-  access?: ResourceAccess;
-  /**
-   * Claves de `fields` que el listado edita en un drawer sin navegar
-   * (plan 6.5, guía §5: «edición rápida de pocos campos, panel lateral en
-   * lugar de pantalla nueva»). 1–3 campos; si no se declara, no hay atajo.
-   */
-  quickEdit?: string[];
-  /** Rutas efectivas por operación, con la forma pública si la declara. */
-  operations?: ResourceOperations;
-  /** Vistas declaradas como metadatos (sin operandos internos). */
-  views?: Record<string, ViewDescriptor>;
-  /** Páginas y rutas del frontend; separado de `views` del backend. */
-  uiViews?: Record<string, UiViewDescriptor>;
-  /** Lo mínimo del backend para menú/acciones: `access` normalizado. */
-  policies?: ResourcePolicies;
-}
-/** Forma pública de la respuesta de una operación (declaración `shape`). */
-export interface OperationShape {
-  pick?: 'full' | 'list' | string[];
-  include?: string[];
-  rename?: Record<string, string>;
-  nest?: Record<string, string[]>;
-  envelope?: 'plain' | 'list';
-}
-/** Ruta efectiva de una operación: método + path (con `{key}` si aplica). */
-export interface OperationDescriptor {
-  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-  path: string;
-  shape?: OperationShape;
-}
-/** Operaciones CRUD efectivas (derivadas de la misma ruta que el router). */
-export interface ResourceOperations {
-  list?: OperationDescriptor;
-  get?: OperationDescriptor;
-  create?: OperationDescriptor;
-  update?: OperationDescriptor;
-  remove?: OperationDescriptor;
-}
-/**
- * Condición de vista como metadato público: el literal `value` y el `ref`
- * (metadato de relación) viajan; el operando interno `from: '$item.x'` no.
- */
-export interface ViewCondition {
-  field: string;
-  op: string;
-  not?: boolean;
-  value?: unknown;
-  ref?: string;
-}
-/** Vista declarada publicada como metadato (F7-1). */
-export interface ViewDescriptor {
-  where?: ViewCondition[];
-  sort?: {
-    field: string;
-    dir?: 'asc' | 'desc';
-  }[];
-  limit?: number;
-  extends?: string;
-  /** Vista con handler propio (escape hatch): su existencia, nada más. */
-  custom?: boolean;
-}
-/** Config para una `uiView` de tipo `calendar`. */
-export interface CalendarViewConfig {
-  /** Campo `date` (o `datetime` futuro): inicio del evento. Obligatorio. */
-  startField: string;
-  /** Campo `date`/`time`: fin. Ausente ⇒ evento de 1 día sobre `startField`. */
-  endField?: string;
-  /** Campo `text`/`relation`: rótulo del evento. Obligatorio. */
-  titleField: string;
-  /** Campo `select`/`text`: color/estado (token de paleta o valor crudo). */
-  colorField?: string;
-  /** Vista por defecto al abrir. Por defecto `month`. */
-  defaultView?: 'month' | 'week' | 'day' | 'agenda';
-  /** Origen de filas; ausente ⇒ la propia instancia del recurso (su listado). */
-  source?: DataSource;
-}
-/** Config para una `uiView` de tipo `kanban`. */
-export interface KanbanViewConfig {
-  /** Campo `select`/`relation`: columna por valor. Obligatorio. */
-  groupField: string;
-  /** Orden estable de columnas. Valores no declarados ⇒ columna extra al final. */
-  columns: KanbanColumn[];
-  /** Rótulo de la tarjeta; ausente ⇒ `keyField` del recurso. */
-  titleField?: string;
-  /** Segundo renglón de la tarjeta (opcional). */
-  subtitleField?: string;
-  /** Origen de filas; ausente ⇒ la propia instancia del recurso. */
-  source?: DataSource;
-}
-/** Una columna del tablero Kanban. */
-export interface KanbanColumn {
-  /** Valor del `groupField` que agrupa esta columna. */
-  value: string;
-  /** Etiqueta visible de la columna. */
-  label: string;
-}
-/**
- * Evento que dispara un `select` declarado (R9.9.4): `open`, `select` o una
- * acción con nombre (`open-detail`). El string libre cubre las acciones con
- * nombre sin perder autocompletado para los dos literales fijos.
- */
-export type SelectionTrigger = 'open' | 'select' | (string & {});
-/**
- * Destino de navegación declarado (R9.9.4 · spec view-navigation): recurso +
- * `uiView` declarada + params de ruta permitidos. Las URLs crudas o
- * externas NO son destinos válidos — el validador las rechaza pre-render.
- */
-export interface NavigationTarget {
-  /** Recurso declarado (`schema.id` del front). */
-  resource: string;
-  /** Clave de `uiViews` en ese recurso. */
-  view: string;
-  /** Nombres de params de la ruta del destino (`:key` ⇒ `['key']`). */
-  params?: string[];
-}
-/**
- * Vinculación selección ⇒ transición declarada en una `uiView` o en un hijo
- * de composición (R9.9.4). `route` exige un `NavigationTarget` declarado;
- * `inline` selecciona en local y `none` es un no-op explícito.
- */
-export type SelectionBinding = {
-  on: SelectionTrigger;
-  mode: 'none' | 'inline';
-} | {
-  on: SelectionTrigger;
-  mode: 'route';
-  target: NavigationTarget;
-};
-/** Base común de todo hijo de una composición embebida (R9.9.2). */
-export interface ViewChildBase {
-  /** Identificador estable y único entre hermanos del mismo contenedor. */
-  id: string;
-  /** Etiqueta visible (rótulo de la pestaña). */
-  label: string;
-  /** Conserva el estado al cambiar de pestaña; ausente ⇒ destruir (R9.9.5). */
-  retain?: boolean;
-  /** Visibilidad declarativa (condiciones sobre campos del formulario). */
-  visibleWhen?: FieldCondition[];
-}
-/**
- * Hijo declarado inline (`type` + `config`) o por referencia a una `uiView`
- * del mismo schema (`ref`). Los `ref` hacen posible que un contenedor
- * contenga —directa o transitivamente— a sí mismo: por eso el
- * `composition-validator` es obligatorio antes del render (D2).
- */
-export type ViewChildNode = (ViewChildBase & UiViewDescriptor) | (ViewChildBase & {
-  ref: string;
-});
-/** Config de una `uiView` contenedora `tabs` (R9.9.2). */
-export interface TabsConfig {
-  /** Lista ordenada de hijos; el orden declarado es el orden de render. */
-  children: ViewChildNode[];
-  /** `id` del hijo seleccionado al montar; ausente ⇒ el primero. */
-  initial?: string;
-}
-/** Vista `tabs` declarada en el schema local del frontend. */
-export interface UiViewTabs extends UiViewBase {
-  type: 'tabs';
-  config: TabsConfig;
-}
-/** Base común de toda `uiView`: tipo + ruta relativa al recurso. */
-export interface UiViewBase {
-  /** Tipo resuelto por `kind: 'view'` en el registro de render. */
-  type: string;
-  /** Ruta relativa al recurso; ausente o vacía significa la ruta raíz. */
-  path?: string;
-  /**
-   * Binding de selección declarado (R9.9.4). Ausente ⇒ la hoja conserva su
-   * comportamiento local y NO navega; una URL cruda nunca es un destino
-   * válido (el `composition-validator` la rechaza antes del render, D2).
-   */
-  select?: SelectionBinding;
-}
-/** Vista `calendar` declarada en el schema local del frontend. */
-export interface UiViewCalendar extends UiViewBase {
-  type: 'calendar';
-  config: CalendarViewConfig;
-}
-/** Vista `kanban` declarada en el schema local del frontend. */
-export interface UiViewKanban extends UiViewBase {
-  type: 'kanban';
-  config: KanbanViewConfig;
-}
-/**
- * Una página/ruta declarada en el schema local del frontend, discriminada
- * por `type`. Los tipos base (`list`/`detail`/`form`/`dashboard`) conservan
- * la forma plana sin `config`; `calendar` y `kanban` llevan su config tipada.
- */
-export type UiViewDescriptor = UiViewBase | UiViewCalendar | UiViewKanban | UiViewTabs;
-/** Políticas públicas: sólo `access`, lo mínimo para menú/acciones. */
-export interface ResourcePolicies {
-  access: {
-    read: string;
-    write: string;
-    /** R7.5: override por operación (B8 · R7.4a) */
-    operations?: Record<string, string>;
-  };
-}
-/** §5.3 — `access` de un recurso. `requires` usa el vocabulario de §4.4. */
-export interface ResourceAccess {
-  requires?: string;
-  roles?: string[];
-}
-/** Un campo de la pantalla de login (auth.md §5.1). */
-export interface AuthFieldDeclaration {
-  key: string;
-  /** `email` | `password` — tipos primitivos; el registro de render los
-   *  absorberá en Fase 3 (R3.3), cuando exista el descriptor `password`. */
-  type: string;
-  required?: boolean;
-}
-/** Supported auth providers. Extensible without breaking existing schemas. */
-export type AuthProvider = 'password' | 'google' | (string & {});
-/** Firebase config block — present only when at least one Firebase provider is listed. */
-export interface FirebaseAuthConfig {
-  /**
-   * The backend endpoint that exchanges a Firebase ID token for the app token.
-   * Defaults to '/auth/firebase' when omitted.
-   */
-  exchangeEndpoint?: string;
-}
-/**
- * Pantalla de login declarada (auth.md §5.1): **vive sólo en el schema del
- * front** — el back no conoce estas etiquetas ni este layout, sólo declara
- * el `input` de `/auth/login`. El `contract-check` (R2.11) verifica que las
- * claves de `loginFields` existan en ese `input`.
- */
-export interface AuthSchema {
-  /** Proveedores disponibles: 'password' | 'google' u otros federados. */
-  providers: AuthProvider[];
-  loginFields: AuthFieldDeclaration[];
-  redirectAfterLogin: string;
-  /**
-   * D10-3 → **`false` siempre.** La opción «recordarme» con `localStorage`
-   * quedó denegada (§9.3): el token vive en `sessionStorage` y muere con la
-   * pestaña. Declarar `true` prometería un storage que nadie usa.
-   */
-  rememberMe: boolean;
-  /** Configuración de Firebase cuando se usan proveedores federados o Firebase Auth. */
-  firebase?: FirebaseAuthConfig;
-}
-/**
- * URL base de la API (baseapi §2.3): es la URL directa del Web App de Apps
- * Script; ahí se hace el `POST` del envelope `{ token, method, path, payload }`.
- * OBLIGATORIO proporcionarlo en `app.config.ts`:
- * `{ provide: API_URL, useValue: 'https://…' }` (Fase 3). Vacío = mismo origen.
- */
-export declare const API_URL: InjectionToken<string>;
-/**
- * Superficie mínima que `gas-admin-ui` usa de Firebase Auth.
- * Implementada por la aplicación consumidora; inyectada vía `FIREBASE_AUTH_ADAPTER`.
- * Mantener la interfaz fina evita acoplar la librería a una versión específica de Firebase.
- */
-interface FirebaseAuthAdapter {
-  /**
-   * Abre un popup de Google sign-in y resuelve al ID token de Firebase.
-   * Rechaza si el usuario cancela o hay error.
-   */
-  signInWithGoogle(): Promise<string>;
-  /**
-   * Inicia sesión con email y contraseña vía Firebase y resuelve al ID token.
-   * Se usa cuando provider === 'password' Y firebase está configurado (Firebase email auth).
-   */
-  signInWithEmailAndPassword(email: string, password: string): Promise<string>;
-  /**
-   * Cierra sesión en Firebase (llamado junto al clear de la sesión de la app).
-   */
-  signOut(): Promise<void>;
-  /**
-   * Obtiene un ID token de Firebase FRESCO para usarlo en la cabecera
-   * `Authorization: Bearer <token>` de las peticiones REST.
-   *
-   * OPCIONAL: si el adaptador no lo implementa, `gas-admin-ui` envía el token
-   * de sesión almacenado tal cual (comportamiento actual). Implementarlo
-   * permite refrescar el ID token antes de cada petición REST, evitando
-   * errores "ID token inválido" tras la expiración de Firebase (1 hora).
-   *
-   * El adaptador decide cuándo refrescar (p. ej. `getIdToken(true)` de Firebase
-   * SDK fuerza la renovación; sin argumento devuelve el cacheado si aún es válido).
-   */
-  getIdToken?(): Promise<string>;
-}
-/**
- * Token DI opcional para el adaptador de Firebase Auth.
- * Proporcionado por la aplicación consumidora cuando usa proveedores federados o Firebase Auth.
- */
-export declare const FIREBASE_AUTH_ADAPTER: InjectionToken<FirebaseAuthAdapter>;
-/**
- * Driver de transporte HTTP del motor.
- *
- * Vive acá (capa de infraestructura) y NO en `ResourceSchema` (capa de dominio)
- * porque es una decisión de red, no de modelo de datos. Cambiar el driver
- * no debería requerir tocar ningún schema de recursos.
- *
- * - `'gas'` (default): tunnel `POST text/plain` con envelope
- *   `{ token, method, path, payload }` — contrato de Google Apps Script.
- * - `'rest'`: verbos HTTP reales (`GET`, `POST`, `PUT`, `DELETE`) con
- *   `Authorization: Bearer <token>` en cabeceras y params en la URL (GET/DELETE)
- *   o en el body JSON (POST/PUT/PATCH).
- *
- * Se fija en `provideGasAdmin({ driver })`. Sin declaración explícita el
- * motor usa `'gas'` — cero impacto para consumidores existentes.
- */
-export declare const API_DRIVER: InjectionToken<"gas" | "rest">;
-/**
- * Registro de FUENTES DE CONTEXTO para marcadores en paths de endpoints.
- *
- * Cada clave es el nombre de una fuente — `{ <fuente> }` o
- * `{ <fuente>.<ruta.anidada> }` dentro de un path declarado en
- * `ResourceEndpoints` — y cada valor es un getter sin argumentos que devuelve
- * el dato ACTUAL en el momento de la petición (no al registrar).
- *
- * El motor ya aporta dos fuentes construidas y éstas NO se declaran acá:
- *
- * - `auth`  → la sesión que dueña `AuthService` (usuario y token).
- * - `config` → el mapa global que puebla `ConfigService` desde los singletons.
- *
- * Este registro es sólo para fuentes que aporta el consumidor, para que el
- * motor no conozca nombres de dominio: qué campo se lee lo decide el schema,
- * no el engine.
- *
- * Un marcador que apunte a una fuente no registrada, o a un valor ausente,
- * revienta con un error que nombra el path y el marcador — jamás se manda un
- * segmento vacío al backend.
- */
-type ValueSources = Readonly<Record<string, () => unknown>>;
-export declare const VALUE_SOURCES: InjectionToken<Readonly<Record<string, () => unknown>>>;
-/**
- * Unwrap de respuesta global por defecto (`GasAdminConfig.defaultResponseUnwrap`).
- *
- * Se fusiona con la declaración `endpoint.responseUnwrap` de cada recurso:
- * la del recurso tiene prioridad en las claves que declara. Sin token, sólo
- * aplica lo declarado por recurso — cero impacto en schemas existentes.
- */
-export declare const DEFAULT_RESPONSE_UNWRAP: InjectionToken<ResponseUnwrap>;
-/** Fija el catálogo (uso interno de `provideGasAdmin`; testable directo). */
-export declare function setSchemaCatalog(schemas: readonly ResourceSchema[], auth?: AuthSchema): void;
-/** Busca un schema por `id`; `undefined` si no existe. */
-export declare function getSchema(id: string): ResourceSchema | undefined;
-/** Catálogo completo en orden (menú lateral). */
-export declare function allSchemas(): readonly ResourceSchema[];
-/** Declaración de la pantalla de login; `undefined` sin `auth` en config. */
-export declare function getAuth(): AuthSchema | undefined;
-/** Token DI del catálogo (para inyectarlo donde un `inject()` es posible). */
-export declare const GAS_SCHEMAS: InjectionToken<readonly ResourceSchema[]>;
-/** Configuración del motor. */
-interface GasAdminConfig {
-  /** Catálogo ordenado de recursos (menú + rutas + resolución `getSchema`). */
-  schemas: readonly ResourceSchema[];
-  /** Declaración de la pantalla de login (opcional: sin ella, sin `/login`). */
-  auth?: AuthSchema;
-  /**
-   * Driver de transporte HTTP.
-   *
-   * - `'gas'` (default): tunnel `POST text/plain` con envelope Apps Script.
-   * - `'rest'`: verbos HTTP reales con `Authorization: Bearer` en cabeceras.
-   *
-   * Sin declaración el motor usa `'gas'` — cero impacto en consumidores existentes.
-   */
-  driver?: 'gas' | 'rest';
-  /**
-   * Fuentes de contexto que el consumidor aporta para marcadores en paths de
-   * endpoints: `{ <fuente> }` / `{ <fuente>.<ruta> }` se resuelven en el
-   * momento de la petición contra este registro más las fuentes construidas
-   * `auth` (sesión) y `config` (config global).
-   *
-   * Opcional: sin él, sólo existen `auth` y `config`. Declararlo no cambia
-   * ningún path que no lleve marcadores — cero impacto en schemas existentes.
-   */
-  valueSources?: ValueSources;
-  /**
-   * Unwrap de respuesta global por defecto. Se fusiona con la declaración
-   * `endpoint.responseUnwrap` de cada recurso (la del recurso tiene prioridad
-   * en claves declaradas). Opcional: sin él, sólo aplica lo declarado por
-   * recurso — cero impacto en schemas existentes (R2).
-   */
-  defaultResponseUnwrap?: ResponseUnwrap;
-}
-/**
- * Wiring completo del motor: catálogo + HTTP con el interceptor de
- * errores del envelope + loaders de config y sesión en el bootstrap
- * (antes en el `app.config` del consumidor).
- *
- * El consumidor conserva `provideRouter` y `{ provide: API_URL, ... }`
- * (su environment decide la URL del Web App).
- */
-export declare function provideGasAdmin(config: GasAdminConfig): (Provider | EnvironmentProviders)[];
-/**
- * Registra una implementación concreta de FirebaseAuthAdapter en el árbol de DI.
- * Usar junto con provideGasAdmin() en app.config.ts al configurar proveedores federados
- * (como 'google') o autenticación por Firebase.
- *
- * @example
- * // app.config.ts
- * provideGasAdmin({ schemas, auth }),
- * provideFirebaseAdapter(new MyFirebaseAuthAdapter(getAuth(firebaseApp))),
- */
-export declare function provideFirebaseAdapter(adapter: FirebaseAuthAdapter): Provider;
-/**
- * Contrato HTTP con el backend (doc/baseapi.md §8 «Errores»).
- *
- * El backend responde SIEMPRE HTTP 200; los errores viajan en el body
- * con `{ error: { status, message, errors?: [{ path, message }] } }`.
- * El interceptor (Fase 3) los convierte en `ApiError`.
- */
-/**
- * Un error con ruta del422 (auth.md §6): `path` para pintarlo en el campo y
- * `code` MAYUS_SNAKE (`VALIDATION_MIN_LENGTH`) para mapearlo sin leer texto.
- */
-export interface ApiIssue {
-  /** Ruta del campo afectado (`faq[2].answer`, `sku`). */
-  path: string;
-  /** Mensaje en español, listo para pintar. */
-  message: string;
-  /** Código estable del validador (B11); el mensaje puede cambiar, el código no. */
-  code?: string;
-}
-/** Shape del body de error (doc/baseapi.md §8 «Errores»). */
-export interface ApiErrorBody {
-  error: {
-    status: number;
-    message: string;
-    /** Ruta del campo afectado cuando el backend la envía (base.md §10). */
-    path?: string;
-    /**
-     * Código de sesión de §4.5 (R2.9): `AUTH_REQUIRED` · `AUTH_INVALID` ·
-     * `AUTH_EXPIRED` · `FORBIDDEN` · `RATE_LIMITED`. Aparece SÓLO en esas
-     * cinco respuestas — el sobre de error es aditivo (O7 / D10-5).
-     */
-    code?: string;
-    /**
-     * Errores de validación con ruta (base.md §5, guía §10): el 422 los manda
-     * ACÁ (`error.errors[]`), no en `path`. Sin modelarlos el form veía
-     * «Errores de validación» genérico y ningún campo se pintaba (D42).
-     */
-    errors?: ApiIssue[];
-  };
-}
-/** Error de API estandarizado que lanza el interceptor de errores. */
-export declare class ApiError extends Error {
-  readonly status: number;
-  /** Ruta del campo que provocó el error (ej. `faq[2].answer`), si existe. */
-  readonly fieldPath?: string;
-  /** Código de sesión de §4.5 si el backend lo envió; `undefined` en el resto. */
-  readonly code?: string;
-  /** Issues con ruta (422); vacío cuando el error no trae `errors[]`. */
-  readonly issues: readonly ApiIssue[];
-  constructor(status: number, message: string, fieldPath?: string, code?: string, issues?: readonly ApiIssue[]);
-}
-/**
- * `meta.renewedToken` (auth.md §3.2/§3.4): el back lo adjunta a la respuesta
- * cuando la vida del token bajó del umbral de renovación. Es el ÚNICO modo
- * de que el front se entere — el token nuevo no viaja en cabeceras ni en la
- * URL. Devuelve `null` cuando no hay renovación (que es lo normal).
- *
- * Vive acá y no en el `ApiService` porque lo consumen DOS servicios
- * (`ApiService` y `AuthService`) y éste modelo no importa a ninguno de los
- * dos: sin este archivo no hay ciclo de imports.
- */
-export declare function renewedTokenOf(body: unknown): string | null;
-/**
- * Resultado de una página para `ApiService.listPage()`.
- *
- * El backend envía la metadata de paginación dentro del sobre (típicamente
- * en `meta`); el motor la extrae según la declaración `responseUnwrap.pagination`
- * y la entrega en este shape. `list()` NO usa este tipo: sigue devolviendo `T[]`.
- */
-export interface PageResult<T> {
-  /** Registros de la página actual. */
-  items: T[];
-  /** Cursor para pedir la página siguiente; `null` cuando no hay más. */
-  nextCursor: string | null;
-  /** Total de registros del conjunto, si el backend lo informa; `0` si no. */
-  total: number;
-  /** `true` si hay al menos una página más. `false` sin cursor informativo. */
-  hasMore: boolean;
-}
-/**
- * Guards de sesión (auth.md §5.3).
- *
- * Dos puertas y ninguna es una barrera de seguridad: el back re-verifica
- * `accessLevel` en **cada** petición desde R2.6. Éstas sólo evitan pintar
- * una pantalla que no le toca al usuario — enseñarle un formulario que va
- * a recibir 403 es mala UX, no un agujero.
- *
- * `authGuard` va en la ruta madre (todo el shell); `roleGuard` en cada
- * `:id`, que es donde aparece el recurso que puede tener `access`.
- */
-/** Sin sesión → login. Corre ANTES que cualquier ruta del shell. */
-export declare const authGuard: CanActivateFn;
-/**
- * El recurso declara `access` y esta sesión no lo cumple → se cancela la
- * navegación. No hay pantalla de 403 (tampoco la pide §5.3) y el menú ya
- * oculta la entrada, así que queda sólo el caso de alguien tecleando la URL.
- */
-declare const roleGuard: CanActivateFn;
-/**
- * Rutas de los schemas recibidos (por defecto, la registry completa).
- * Cada schema se valida con `validateComposition` ANTES de generar rutas
- * (D3): una composición inválida revienta al arrancar, no en el render.
- */
-export declare function resourceRoutes(catalog?: readonly ResourceSchema[]): Route[];
-/**
- * Las rutas del shell salen de `uiViews`, no de `ResourceSchema.views` (que
- * conserva los metadatos de consultas del backend). Añadir o cambiar una
- * página requiere una declaración y un descriptor `kind: 'view'`.
- *
- * Los hijos se construyen DENTRO del `loadChildren` (en la primera
- * navegación), nunca en la evaluación del módulo: el consumidor importa
- * este barrel desde `app.routes.ts` ANTES de que `provideGasAdmin` siembre
- * el catálogo (corre en el cuerpo de `app.config`), y el paquete compilado
- * es eager — construir en el import congelaría `children: []` para siempre
- * y toda URL protegida renderizaría vacío (regresión: shell.routes.spec en
- * orden de producción).
- */
-export declare const shellRoutes: Routes;
-/**
- * Login (auth.md §5.1).
- *
- * **Pintada a partir de `authSchema.loginFields`**: si mañana cambian los
- * campos, éste componente no se toca — sólo se mueven claves y etiquetas.
- * No usa `FieldHost` porque el tipo `password` todavía no existe en
- * `FieldSchema` (es pieza nueva de Fase 3, R3.3); el `@switch` de abajo es
- * exactamente el reemplazo que R3.x hará por el registro de render.
- *
- * **No hay casilla «recordarme»**: D10-3 negó `localStorage` (§9.3) y el
- * token muere con la pestaña. Poner un checkbox sería prometer que la
- * sesión sobrevive a cerrar el navegador.
- */
-export declare class Login {
-  private readonly auth;
-  private readonly router;
-  readonly schema: import("@tinya-code/gas-admin-ui").AuthSchema;
-  readonly providers: import("@tinya-code/gas-admin-ui").AuthProvider[];
-  readonly error: import("@angular/core").WritableSignal<string | null>;
-  readonly loading: import("@angular/core").WritableSignal<boolean>;
-  readonly providerLoading: import("@angular/core").WritableSignal<string | null>;
-  /** Valores por clave: el set lo pinta el `@for` del schema. */
-  private readonly values;
-  label(key: string): string;
-  value(key: string): string;
-  setValue(key: string, next: string): void;
-  loginWithGoogle(): void;
-  submit(event: Event): void;
-  private goAfterLogin;
-  static ɵfac: i0.ɵɵFactoryDeclaration<Login, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<Login, "app-login", never, {}, {}, never, never, true, never>;
-}
-type ToastKind$1 = 'success' | 'error' | 'info';
-interface Toast$1 {
-  id: number;
-  kind: ToastKind$1;
-  message: string;
-}
-interface ConfirmOptions {
-  title: string;
-  message: string;
-  confirmLabel?: string;
-  cancelLabel?: string;
-}
-/**
- * Notificaciones de la app: toasts (señales, se renderizan en `app-toast`,
- * Fase 5) y un diálogo de confirmación con respuesta como `Promise`
- * (base.md §10: borrado con confirmación, aviso de cambios sin guardar).
- */
-export declare class NotificationService {
-  readonly toasts: import("@angular/core").WritableSignal<Toast$1[]>;
-  /** Confirmación en curso; `null` = sin diálogo. */
-  readonly confirmation: import("@angular/core").WritableSignal<ConfirmOptions | null>;
-  private nextId;
-  private pendingResolve;
-  success(message: string): void;
-  error(message: string): void;
-  info(message: string): void;
-  dismiss(id: number): void;
-  /** Abre el diálogo de confirmación y espera la respuesta del usuario. */
-  confirm(options: ConfirmOptions): Promise<boolean>;
-  /** Resuelve la confirmación pendiente (lo llama el componente de diálogo, Fase 5). */
-  resolveConfirmation(accepted: boolean): void;
-  private push;
-  static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
-  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
-/** Métodos que entiende el envelope del backend (baseapi §2.3). */
-type EnvelopeMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-/** Dependencias del transporte, aportadas por la fachada (no hay singleton acá). */
-interface TransportDeps {
-  http: HttpClient;
-  /** URL base (`API_URL`): el Web App de Apps Script o el origen REST. */
-  apiUrl: string;
-  /** Getter del token de SESIÓN, leído en CADA petición (R2.8). */
-  sessionToken: () => string | null;
-  /**
-   * Refresco opcional de ID token (Fase Firebase): si existe, se llama antes
-   * de armar la cabecera Authorization. Un rechazo viaja por el canal de
-   * errores — nunca se manda una petición con token inválido.
-   */
-  getIdToken?: () => Promise<string>;
-}
-/** `POST text/plain` a `apiUrl` con el envelope GAS. */
-declare function sendGas<T>(deps: TransportDeps, path: string, method: EnvelopeMethod, payload?: Record<string, unknown> | FormData, multipart?: boolean): Observable<T>;
-/**
- * Verbo HTTP real con `Authorization: Bearer`. Si el adaptador provee
- * `getIdToken()`, se resuelve el token fresco ANTES de la cabecera; si no,
- * se usa el de sesión almacenado (fallback). Cualquier error de `getIdToken()`
- * se propaga por el canal de errores.
- */
-declare function sendRest<T>(deps: TransportDeps, path: string, method: EnvelopeMethod, payload?: Record<string, unknown> | FormData, multipart?: boolean): Observable<T>;
-/** Despacho REST concreto sobre una URL ya construida. */
-declare function doRestRequest<T>(deps: TransportDeps, url: string, method: EnvelopeMethod, payload: Record<string, unknown> | FormData | undefined, headers?: HttpHeaders, multipart?: boolean): Observable<T>;
-/** `${apiUrl}${path}` normalizada: sin dobles slashes ni path sin slash inicial. */
-declare function buildUrl(apiUrl: string, path: string): string;
-/**
- * Convierte un payload en HttpParams para peticiones GET y DELETE en modo REST.
- * Si un valor es un objeto plano (ej: `{ view: 'calendar', params: { orden: 'es' } }`),
- * lo aplana un nivel para que sus claves viajen como query params reales
- * en lugar de serializarse como `params=[object Object]`.
- */
-declare function toHttpParams(payload?: Record<string, unknown>): HttpParams;
-/**
- * CRUD genérico sobre el contrato v2 (baseapi §2.3) con soporte dual-driver:
- *
- * - **`gas` (default)**: TODA llamada a la API es un `POST` a `API_URL` con cuerpo
- *   `text/plain` y el JSON `{ token, method, path, payload }`.
- * - **`rest`**: Verbos HTTP reales (`GET`, `POST`, `PUT`, `PATCH`, `DELETE`) hacia
- *   `${API_URL}${path}` con `Authorization: Bearer ${token}`. `payload` va como query
- *   params en GET/DELETE (aplanando objetos anidados como `params`) o como body JSON
- *   en POST/PUT/PATCH.
- */
-export declare class ApiService {
-  private readonly http;
-  private readonly apiUrl;
-  private readonly auth;
-  private readonly driver;
-  /** Fuentes que aporta el consumidor (`provideGasAdmin({ valueSources })`). */
-  private readonly valueSources;
-  /** Adaptador opcional de Firebase Auth para refrescar el ID token antes de peticiones REST. */
-  private readonly firebaseAuthAdapter;
-  /**
-   * Acceso PEREZOSO a `ConfigService` (R2 · plan doc/context-sources-plan.md).
-   *
-   * `config` es fuente construida del motor, pero inyectarla en el constructor
-   * formaría un ciclo: `ConfigService` inyecta `ApiService` (opcional) para
-   * cargar los singletons ⇒ NG0200 en el arranque. Se pide en el momento de la
-   * petición, cuando ambos servicios ya están vivos. Si no existe (TestBed
-   * parcial), devuelve `null` y el resolver falla ruidoso con «sin valor».
-   */
-  private readonly injector;
-  /** Unwrap global por defecto (`GasAdminConfig.defaultResponseUnwrap`); opcional. */
-  private readonly defaultUnwrap;
-  /**
-   * Declaración de unwrap EFECTIVA para un endpoint: fusión del default
-   * global con la declaración por recurso (recurso gana en las claves que
-   * declara). Sin ninguna de las dos ⇒ `undefined` (comportamiento actual).
-   */
-  private effectiveUnwrap;
-  /**
-   * Listado. El backend envuelve la respuesta cuando la operación declara
-   * `shape.envelope: 'list'` (F5) ⇒ `{ items, nextCursor, total }` (R6.4);
-   * la UI consume `T[]` en todos lados (F7-3) y este es el ÚNICO punto que
-   * habla de listas, así que el desenvolvimiento vive acá. `nextCursor` es
-   * el token de la página siguiente y `null` en la última — éste servicio
-   * lo descarta hoy porque la lista no pagina todavía (backlog-ui-ux).
-   * Un listado sin envelope (arreglo plano, el contrato histórico) pasa
-   * tal cual.
-   *
-   * `payload` sólo lo usa una fuente declarada (F8 · R6.5): `{ view, params }`
-   * pide el listado filtrado por una vista y sus parámetros. Sin él, la
-   * llamada es la de siempre — la lectura llana del recurso.
-   */
-  list<T>(endpoint: ResourceEndpoints, payload?: Record<string, unknown>): Observable<T[]>;
-  /**
-   * Listado paginado OPT-IN (plan doc/engine-refactor-plan.md · Fase 3).
-   *
-   * Misma petición que `list()` pero devuelve `PageResult<T>` con la metadata
-   * de paginación que el backend envía en el sobre (`{ items, nextCursor,
-   * total }` o dentro de `meta` con unwrap declarado). Las claves se leen
-   * según `responseUnwrap.pagination` (cursorKey/totalKey/hasMoreKey) o se
-   * auto-detectan (`nextCursor`, `total`, `hasMore`).
-   *
-   * `payload` acepta normalmente `{ cursor, limit }` para pedir la página
-   * siguiente; viaja como cualquier otro payload (query params en GET REST,
-   * campo `payload` del envelope en GAS). `list()` no cambia: sigue
-   * devolviendo `T[]` (R11).
-   */
-  listPage<T>(endpoint: ResourceEndpoints, payload?: Record<string, unknown>): Observable<PageResult<T>>;
-  /** `key` solo aplica a colecciones (`{key}` en la plantilla); los singleton no la llevan. */
-  get<T>(endpoint: ResourceEndpoints, key?: string): Observable<T>;
-  create<T>(endpoint: ResourceEndpoints, payload: Record<string, unknown>): Observable<T>;
-  update<T>(endpoint: ResourceEndpoints, key: string | undefined, payload: Record<string, unknown>): Observable<T>;
-  remove(endpoint: ResourceEndpoints, key?: string): Observable<void>;
-  /**
-   * Operación genérica sobre una ruta ya resuelta: reorder de colección
-   * (`PUT /admin/x` con `{ reorder: … }`), `/admin/schema`,
-   * `/admin/upload-signature`, etc.
-   */
-  request<T>(method: EnvelopeMethod, path: string | undefined, payload?: Record<string, unknown>): Observable<T>;
-  /**
-   * Invoca un endpoint personalizado declarado por el consumidor.
-   *
-   * Acepta bien la definición directa (`CustomEndpointDefinition`) o un schema
-   * + nombre (resuelve en `schema.customEndpoints`). El despacho respeta el
-   * método, la ruta, el modo de payload (json/multipart) y el unwrap propios
-   * de la declaración.
-   */
-  invokeCustomEndpoint<T>(definitionOrSchema: CustomEndpointDefinition | ResourceSchema, nameOrPayload?: string | Record<string, unknown> | FormData, payload?: Record<string, unknown> | FormData, key?: string): Observable<T>;
-  /** Alias corto de `invokeCustomEndpoint`. */
-  invokeCustom<T>(schemaOrDefinition: ResourceSchema | CustomEndpointDefinition, nameOrPayload?: string | Record<string, unknown> | FormData, payload?: Record<string, unknown> | FormData, key?: string): Observable<T>;
-  /** Alias adicional por compatibilidad. */
-  custom<T>(schemaOrDefinition: ResourceSchema | CustomEndpointDefinition, nameOrPayload?: string | Record<string, unknown> | FormData, payload?: Record<string, unknown> | FormData, key?: string): Observable<T>;
-  private send;
-  /**
-   * Dependencias del transporte (Fase 4): la fachada sólo arma este objeto y
-   * delega en `transport.ts`. El token de sesión y el ID token fresco se
-   * resuelven vía getters en el momento de la petición (R2.8 / refresh).
-   */
-  private transportDeps;
-  /**
-   * Fuentes de contexto de ESTA petición: getters, no valores — se evalúan
-   * sólo si el path trae marcadores.
-   *
-   * Las construidas del motor (`auth`, `config`) van ÚLTIMAS: el motor es
-   * dueño de sus fuentes y el registro del consumidor no las pisa.
-   */
-  private buildSources;
-  private withKey;
-  static ɵfac: i0.ɵɵFactoryDeclaration<ApiService, never>;
-  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
-/**
- * Sesión del admin (auth.md §5.2) — **única dueña** del token y del usuario.
- *
- * Qué vive acá y por qué:
- *
- *  - **Señales** `user` / `token` / `isAuthenticated` / `role`: el único
- *    estado que el resto de la app lee (guards, menú, interceptor).
- *  - **`login()` / `logout()` / `logoutAll()` / `restore()`**: operaciones de sesión.
- *    El `AuthService` NO inyecta `ApiService` — sólo `HttpClient` — porque
- *    `ApiService` inyecta a éste para leer el token, y un ciclo de DI en
- *    Angular es un error en tiempo de arranque, no un warning.
- *  - **`applyAuthCode()` (R2.9): EL único intérprete de la tabla de §4.5.**
- *    Ningún otro archivo decide qué pasa ante `AUTH_*` o `FORBIDDEN`.
- *  - **Almacenamiento (R2.12): `sessionStorage`, siempre.** `rememberMe`
- *    no puede usar `localStorage` porque D10-3 lo negó — ver más abajo.
- *
- * La sesión arranca desde el storage y `restore()` la revalida contra
- * `/auth/me` en el initializer: un usuario desactivado mientras la pestaña
- * estaba abierta cae al primer reload, no en mitad de una edición.
- */
-/** Usuario tal y como lo sirve `publicUser_` (lista blanca, R2.17). */
-interface SessionUser {
-  id?: string;
-  email?: string;
-  name?: string;
-  role?: string;
-  active?: boolean;
-  last_login_at?: string;
-  created_at?: string;
-}
-/** Los cinco códigos de §4.5. El resto de errores no son de sesión. */
-type AuthErrorCode = 'AUTH_REQUIRED' | 'AUTH_INVALID' | 'AUTH_EXPIRED' | 'FORBIDDEN' | 'RATE_LIMITED';
-/** Ruta de login: fuera del shell para que ningún guard la proteja. */
-declare const LOGIN_PATH = "/login";
-/**
- * Claves del `sessionStorage`. Exportadas porque **la sesión se restaura
- * desde ahí en el constructor**: un test que quiera una sesión arrancando
- * tiene que sembrarlas antes de inyectar el servicio, y el que las use con
- * otro nombre quebraría el restore en silencio.
- */
-export declare const SESSION_TOKEN_KEY = "admin.session.token";
-export declare const SESSION_USER_KEY = "admin.session.user";
-export declare class AuthService {
-  private readonly http;
-  private readonly apiUrl;
-  private readonly router;
-  private readonly firebaseAdapter;
-  private readonly driver;
-  /**
-   * D10-3: **sólo `sessionStorage`.** La opción «recordarme» con
-   * `localStorage` quedó denegada en §9.3 — muere con la pestaña ⇒ cero
-   * token legible por un XSS futuro. `authSchema.rememberMe` es `false`
-   * por la misma razón: declarar `true` sería prometer un storage que
-   * este servicio no usa.
-   *
-   * Nunca en la URL ni en el cuerpo de un GET (§5.4): el token sólo viaja
-   * dentro del envelope `{ token, method, path, payload }`.
-   */
-  private readonly storage;
-  private readonly _user;
-  private readonly _token;
-  /** Ruta previa a un `AUTH_EXPIRED`, para volver tras reloguear (§4.5). */
-  private readonly _returnUrl;
-  readonly user: import("@angular/core").Signal<SessionUser | null>;
-  readonly token: import("@angular/core").Signal<string | null>;
-  readonly returnUrl: import("@angular/core").Signal<string | null>;
-  /** Sólo hay sesión con token Y usuario: uno sin el otro es estado corrupto. */
-  readonly isAuthenticated: import("@angular/core").Signal<boolean>;
-  readonly role: import("@angular/core").Signal<string>;
-  constructor();
-  login(email: string, password: string): Observable<SessionUser>;
-  /**
-   * Inicia sesión con Google mediante el adaptador de Firebase y canjea
-   * el ID token contra el backend.
-   */
-  loginWithGoogle(): Observable<SessionUser>;
-  /**
-   * Inicia sesión con correo y contraseña en Firebase y canjea el ID token
-   * resultante contra el backend.
-   */
-  loginWithFirebasePassword(email: string, password: string): Observable<SessionUser>;
-  /**
-   * Canjea un token de identidad de Firebase por la sesión propia de la app,
-   * manteniendo idéntico el contrato del envelope y almacenamiento en sessionStorage.
-   */
-  private exchangeFirebaseToken;
-  /**
-   * Revocación best-effort (§9.7): se pide al back que ponga el `sid` en la
-   * lista de revocados, pero **la sesión local se ciere haya o no respuesta**.
-   * Un logout que «falla» por red y deja al usuario dentro es peor que uno
-   * que deja una sesión muerta en el servidor.
-   */
-  logout(): Observable<void>;
-  /** Revalida la sesión restaurada contra `/auth/me`; sin token ⇒ sin viaje. */
-  restore(): Observable<void>;
-  /**
-   * Renovación deslizante (§3.2): el back manda `meta.renewedToken` cuando
-   * la vida del token bajó del umbral. Se persiste el MISMO día que el
-   * token original — el `sid` no cambia, sólo se emite una firma nueva.
-   */
-  applyRenewedToken(token: string): void;
-  /**
-   * ÚNICO intérprete de los códigos de sesión (auth.md §4.5 / §5.2).
-   * El interceptor `apiErrorInterceptor` lo llama y nada más: cualquier
-   * archivo que decida «si ve AUTH_EXPIRED hago X» está fuera de contrato.
-   *
-   * | Código          | Qué hace                                    |
-   * | --------------- | ------------------------------------------- |
-   * | `AUTH_REQUIRED` | limpia sesión y va a login                  |
-   * | `AUTH_INVALID`  | limpia sesión y va a login                  |
-   * | `AUTH_EXPIRED`  | guarda la ruta previa, limpia, va a login   |
-   * | `FORBIDDEN`     | **no** cierra sesión (el usuario sigue dentro) |
-   * | `RATE_LIMITED`  | no hace nada: lo espera el formulario       |
-   */
-  applyAuthCode(code: string | undefined): void;
-  /** ¿El rol de la sesión cubre `required`? (mínimo: admin ≥ staff, §4.4) */
-  hasRole(required: string): boolean;
-  /**
-   * §5.3 — el ÚNICO criterio de visibilidad del front (menú, rutas y
-   * botones). `requires` viene del vocabulario de §4.4: `public` no pide
-   * sesión; todo lo demás sí; `roles` estrecha.
-   *
-   * Es **pura decisión de UI**. El back re-verifica `accessLevel` en cada
-   * petición (R2.6), así que filtrar acá no protege nada: sólo evita
-   * enseñarle a alguien un botón que le va a devolver 403.
-   */
-  canAccess(access?: {
-    requires?: string;
-    roles?: string[];
-  }): boolean;
-  /**
-   * Evalúa si el usuario puede ejecutar una operación específica según
-   * `policies.access.operations` del recurso (B8 · R7.4a).
-   *
-   * El override por operación tiene prioridad sobre el umbral del grupo.
-   * Si no hay override, se usa el umbral `policies.access.read` o
-   * `policies.access.write` según la operación.
-   *
-   * Fallback a `permissions` (legacy) si `policies` no existe: mientras
-   * los schemas locales no tengan `policies`, se mantiene compatibilidad.
-   *
-   * Es **pura decisión de UI**. El back vuelve a verificar en cada petición
-   * (24-crud), así que esto sólo evita mostrar botones que darían 403.
-   */
-  canDoOperation(schema: ResourceSchema, operation: 'list' | 'get' | 'create' | 'update' | 'remove'): boolean;
-  /**
-   * Evalúa si el usuario puede leer un campo según `field.access.read`
-   * (B8 · R7.4b).
-   *
-   * Es **pura decisión de UI**. El back vuelve a filtrar la respuesta en
-   * cada petición (24-crud), así que esto sólo evita mostrar datos que el
-   * usuario no debería ver.
-   */
-  canReadField(field: FieldSchema): boolean;
-  /**
-   * Evalúa si el usuario puede escribir un campo según `field.access.write`
-   * (B8 · R7.4b).
-   *
-   * Es **pura decisión de UI**. El back rechaza la escritura con 422 si el
-   * usuario no tiene permiso, así que esto sólo pone el campo en
-   * solo-lectura en el frontend.
-   */
-  canWriteField(field: FieldSchema): boolean;
-  /**
-   * Verifica si el rol actual cumple un nivel de acceso dado.
-   * Usa la misma jerarquía que `ACCESS_ROLE_RANK` del back (11-auth):
-   * admin ≥ staff.
-   */
-  private meetsLevel;
-  private open;
-  /**
-   * Borra token **y** usuario (§5.4) — en ese orden de importancia: un token
-   * sin usuario no autentica, pero un usuario sin token engaña al menú.
-   */
-  /**
-   * Ruta previa guardada por un `AUTH_EXPIRED` (§4.5), **consumida**: se
-   * devuelve una sola vez y se borra. Sin el consume, cada login futuro
-   * volvería a la misma URL vieja aunque el usuario hubiera llegado al
-   * login desde el menú.
-   */
-  consumeReturnUrl(): string | null;
-  private clear;
-  private goLogin;
-  private currentUrl;
-  private buildUrl;
-  private envelope;
-  /**
-   * Despacho dual-driver para peticiones de autenticación:
-   *
-   * - **`gas` (default)**: `POST` a `API_URL` con cuerpo `text/plain` y envelope
-   *   `{ token, method: 'POST', path, payload }`.
-   * - **`rest`**: llamadas REST reales:
-   *   - `/auth/me`: `GET` a `${apiUrl}/auth/me` con `Authorization: Bearer ${token}`.
-   *   - resto (`/auth/login`, `/auth/firebase`, `/auth/logout`, etc.): `POST` con
-   *     `Content-Type: application/json` y payload directo como body JSON. Si existe
-   *     token activo, se adjunta en cabecera `Authorization`.
-   */
-  private buildAuthRequest;
-  private post;
-  static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
-  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
-/** Fila cruda de un listado: el motor no impone forma a las columnas. */
-type SourceRow = Record<string, unknown>;
-/**
- * `source.params` con cada `{campo}` resuelto contra `ctx`.
- *
- * - Un valor que se resuelve **vacío se OMITE** en vez de mandar `''`: el
- *   back distingue «parámetro ausente» (fail-closed ⇒ sin filas) de un
- *   `eq ''` que podría cruzarse con filas realmente vacías.
- * - Un parámetro sin marcador `{}` es literal y viaja tal cual.
- */
-declare function interpolateParams(params: Record<string, string> | undefined, ctx?: Record<string, unknown>): Record<string, string>;
-/**
- * Clave de caché de una fuente: `resource|view|params` (F8 · R6.5).
- *
- * Los parámetros van **resueltos** y ordenados, así que dos fuentes que
- * terminan pidiendo lo mismo comparten entrada, y un `{campo}` que cambia
- * es otra entrada. Pura: es también el valor que `resource({ params })` de
- * Angular compara para decidir si vuelve a cargar.
- */
-declare function dataSourceKey(source: DataSource, ctx?: Record<string, unknown>): string;
-/**
- * Fetcher único de `source` (F8 · R6.5): relations, selects y widgets del
- * panel piden sus filas ACÁ y no cada uno desde su componente.
- *
- * - **Caché por `resource+view+params`** con TTL e invalidación explícita —
- *   es la pieza que evita que seis widgets del panel disparen seis vueltas
- *   iguales a la misma vista.
- * - **Deduplicación de vuelta en vuelo**: dos consumidores que pidan la misma
- *   clave en el mismo ciclo comparten la promesa (no la respuesta, la vuelta).
- * - Un error **no queda cacheado**: se borra la entrada para que la recarga
- *   del consumidor vuelva a intentarlo en vez de devolver siempre la misma
- *   rechazada.
- */
-export declare class DataSourceService {
-  private readonly api;
-  private readonly cache;
-  /**
-   * Filas de la fuente declarada.
-   *
-   * `fresh` salta la caché (recarga tras una escritura); `ctx` sólo se usa
-   * para resolver `{campo}` en `params` y no cambia la forma de la respuesta.
-   */
-  rows(source: DataSource, ctx?: Record<string, unknown>, fresh?: boolean): Promise<SourceRow[]>;
-  /**
-   * Vacía las filas ya pedidas. Sin argumento, todas; con un `resourceId`,
-   * sólo las de ese recurso (lo que acaba de crear el drawer de relación).
-   */
-  invalidate(resourceId?: string): void;
-  private fetch;
-  static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceService, never>;
-  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
-interface MappedError {
-  /** Errores por ruta de campo (ej. `faq[2].answer`); se pintan en el campo exacto. */
-  fields: Record<string, string>;
-  /** Mensaje general; presente cuando el error no tiene ruta de campo (base.md §10). */
-  general?: string;
-}
-/**
- * Convierte un error recibido en el formato que consume la UI:
- * rutas de campo para pintar el error donde corresponde, o mensaje general.
- *
- * Un422 trae VARIOS issues con ruta (`error.errors[]`, auth.md §6); cada uno
- * se convierte en `fields[path] = mensaje`, que es exactamente la clave que
- * después resuelve el host como `serverErrors[prefix + key]`. Si al final no
- * hay ninguna ruta pintable (error sin `errors[]`, issue sin `path`), el
- * mensaje del sobre queda en `general` como hasta ahora (base.md §10).
- */
-export declare class ErrorMapperService {
-  map(error: unknown): MappedError;
-  messageOf(error: unknown): string;
-  static ɵfac: i0.ɵɵFactoryDeclaration<ErrorMapperService, never>;
-  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
-/**
- * Subida de imágenes en DOS PASOS (baseapi §11.2, opción B):
- *  1. Firma firmada por el backend → `POST /admin/upload-signature`
- *     con `{ resource }` (mismo envelope text/plain que todo `/admin/*`).
- *  2. El navegador sube directo a Cloudinary (FormData a `upload_url`) con
- *     los parámetros que fijó y firmó el backend; el API secret jamás sale
- *     de acá (§11.1–§11.3).
- *
- * Se guarda SOLO `secure_url` (base.md §7: la URL pública es el valor del
- * campo; la imagen anterior no se borra al reemplazar — §11.6).
- *
- * Los errores (firma caducada, rate-limit 429, red) llegan por el canal de
- * error; el componente conserva la imagen anterior (§11.2 paso 6).
- */
-export declare class UploadService {
-  private readonly http;
-  private readonly api;
-  /**
-   * Misma subida con eventos de progreso (base.md §7, estado «Subiendo»):
-   * emite `UploadProgress` durante la subida a Cloudinary y termina con
-   * `Response` llevando la URL en el body. El campo sólo cambia cuando
-   * llega la respuesta.
-   */
-  uploadWithProgress(file: File, resource: string, field?: string): Observable<HttpEvent<string>>;
-  static ɵfac: i0.ɵɵFactoryDeclaration<UploadService, never>;
-  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
-/**
- * El backend responde SIEMPRE HTTP 200 y pone los errores en el body
- * (api.md §7), así que se detectan en el canal de **éxito** y se relanzan
- * como `ApiError` (con `fieldPath` cuando el backend envía `path`).
- * Los errores HTTP reales (red caída, proxy) también se normalizan.
- *
- * **R2.9 — paso dos de dos.** Éste archivo es el ÚNICO punto donde el
- * sobre de error se abre; lo que decide qué ocurre con un `AUTH_*` es
- * `AuthService.applyAuthCode` (la tabla de §4.5). Aquí sólo se le entrega
- * el código y se propaga el `ApiError` con él — un segundo sitio que
- * «interprete» el código sería una regla duplicada y, a la larga, una que
- * se contradiga con la primera.
- */
-export declare const apiErrorInterceptor: HttpInterceptorFn;
-interface MenuEntry {
-  id: string;
-  label: string;
-}
-/**
- * Menú lateral generado desde el catálogo EFECTIVO (F7-4): locales
- * fusionados + recursos sintetizados del schema remoto — un recurso nuevo
- * del backend aparece acá con 0 cambios en `src/`. Reactivo a la señal del
- * schema remoto (el initializer lo resuelve antes del primer render, pero
- * el `computed` cubre el caso de respuesta tardía).
- * `labelPlural` + `permissions`: un recurso se oculta solo si declara
- * create, update y remove explícitamente en falso (no hay permiso de
- * lectura).
- */
-export declare class Sidebar {
-  /** Estado del offcanvas (sólo relevante en mobile; ver `layout.ts`).
-   *  `model()`: el padre lo setea (abrir) y el hijo también (cerrar al
-   *  navegar) — binding de dos vías `[(open)]`. */
-  readonly open: import("@angular/core").ModelSignal<boolean>;
-  private readonly auth;
-  private readonly notifications;
-  readonly isAuthenticated: import("@angular/core").Signal<boolean>;
-  readonly loggingOut: import("@angular/core").WritableSignal<boolean>;
-  /**
-   * R2.10 — el menú se corta dos veces: `isVisible` (permisos declarados
-   * en el schema) y `canAccess` (auth.md §5.3, `access` de la sesión).
-   * Sólo UX: filtrar acá no protege nada, el back re-verifica en R2.6.
-   */
-  readonly menuItems: import("@angular/core").Signal<MenuEntry[]>;
-  closeSession(): Promise<void>;
-  static ɵfac: i0.ɵɵFactoryDeclaration<Sidebar, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<Sidebar, "app-sidebar", never, {
-    "open": {
-      "alias": "open";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {
-    "open": "openChange";
-  }, never, never, true, never>;
-}
-/**
- * Panel de métricas — tercer `kind` del registry (refactormotor.md F4).
- *
- * Sólo lectura: no hay CRUD y los datos llegan de un endpoint declarativo
- * (Etapa 2, S4). Los widgets se declaran en `widgets` del schema — no en
- * `fields`, porque un KPI no es un campo (ver `ResourceSchema.widgets`).
- *
- * Dos formas de dato, la que declare cada widget (F8 · R6.5):
- *
- * - **payload**: el `key` del widget es su clave en la respuesta del
- *   endpoint; `source: { kind: 'payload' }` lee la respuesta entera.
- * - **fuente declarada** (`source: { resource, view?, params? }`): el widget
- *   pide sus filas al `DataSourceService` y deja de depender de que un
- *   handler haya armado `data[key]`. Acá se piden TODAS juntas, así que un
- *   panel con seis fuentes iguales hace una vuelta, no seis (la caché del
- *   servicio es compartida con relations y selects).
- */
-export declare class Dashboard {
-  private readonly api;
-  private readonly ds;
-  /** Descriptor del dashboard (lo resuelve `ResourcePage` contra el registry). */
-  readonly schema: import("@angular/core").InputSignal<ResourceSchema>;
-  /**
-   * Respuesta del endpoint de métricas indexada por `key` de widget.
-   * Si se pasa explícitamente (como en tests con fixtures), se usa directamente;
-   * de lo contrario se obtienen los datos de forma reactiva desde el endpoint `get`.
-   */
-  readonly data: import("@angular/core").InputSignal<Record<string, unknown> | null>;
-  private readonly fetchedData;
-  protected readonly effectiveData: import("@angular/core").Signal<Record<string, unknown>>;
-  protected readonly widgets: import("@angular/core").Signal<WidgetSchema[]>;
-  /**
-   * Claves de los widgets con fuente declarada, en una cadena: es el
-   * `params` del `resource` y sólo cambia cuando cambia el panel. `''`
-   * (ninguna fuente) ⇒ `undefined` ⇒ el resource queda idle y no pide nada.
-   */
-  private readonly clavesFuente;
-  /**
-   * Filas de todos los widgets con `source`, pedidas de una sola vez.
-   *
-   * Cada fila queda bajo `widget.key`, que es el mismo contrato de lectura
-   * que tiene el payload: `datum()` devuelve filas cuando hay fuente y la
-   * clave de siempre cuando no, y el descriptor del widget traduce la forma
-   * que necesita.
-   */
-  private readonly fuentes;
-  /** ¿Alguna fuente del panel falló? (`status()` no tira; `value()` sí.) */
-  protected readonly falloFuentes: import("@angular/core").Signal<boolean>;
-  /**
-   * Estado de carga del panel — mientras dure, cada tarjeta reserva su
-   * espacio con skeleton (`cargar ≠ vacío`, doc/ux-ui-mobile.md §estados).
-   * Cubre LOS dos caminos de dato: el payload (`null` inicial = sin
-   * respuesta todavía) y las fuentes declaradas (`resource` en loading;
-   * con params vacíos queda idle, que NO es carga).
-   */
-  protected readonly cargando: import("@angular/core").Signal<boolean>;
-  /** `null` explícito cuando la clave no vino: el widget muestra su vacío. */
-  protected datum(widget: WidgetSchema): unknown;
-  static ɵfac: i0.ɵɵFactoryDeclaration<Dashboard, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<Dashboard, "app-dashboard", never, {
-    "schema": {
-      "alias": "schema";
-      "required": true;
-      "isSignal": true;
-    };
-    "data": {
-      "alias": "data";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {}, never, never, true, never>;
-}
-type Row$1 = Record<string, unknown>;
-/**
- * Contexto de una celda de listado (R4.3 · `kind: 'column-format'`).
- *
- * Es lo que antes cada `@case` de `list-view` pedía a la vista como
- * `row`/`column` y lo que el descriptor cuelga de `extras.data`: el
- * componente de formato no conoce a la vista, sólo a su celda.
- *
- * `fields`, `canUpdate`, `saving`, `currency` y `toggle` viajan acá porque
- * son decisiones de la vista (permisos, moneda del schema, escritura de la
- * fila); un formato nuevo no necesita tocar `list-view` para leerlas.
- */
-interface ColumnCell {
-  /** Fila completa. */
-  row: Row$1;
-  /** Columna que se pinta (`key`, `label`, `format`). */
-  column: ListColumn;
-  /** Campos del recurso: de acá salen `trueLabel`/`falseLabel`. */
-  fields: FieldSchema[];
-  /** `titleField` de la fila, para el `aria-label` del interruptor. */
-  title: string;
-  /** ¿La fila admite escritura? (`ListView.canUpdate`) */
-  canUpdate: boolean;
-  /** ¿La fila está guardando? (`ListView.savingKey === keyOf(row)`) */
-  saving: boolean;
-  /** Moneda del schema, para el formato `currency`. */
-  currency: string;
-  /** Escribe el valor en la fila. Sólo lo usa el interruptor `active`. */
-  toggle?: (checked: boolean) => void;
-}
-type Row = Record<string, unknown>;
-type Status = 'loading' | 'ready' | 'error';
-/**
- * Listado genérico de una colección (base.md §10 «Listado»): tabla desde
- * `listColumns` con los 7 formatos **resueltos por el registro** (R4.3),
- * búsqueda/filtros **en el cliente** (el
- * contrato de api.md no define parámetros de consulta: el endpoint admin
- * devuelve todos los registros), interruptor `active`, acciones de fila y
- * estados universales (skeleton, vacío, error con reintento).
- */
-export declare class ListView {
-  readonly schema: import("@angular/core").InputSignal<ResourceSchema>;
-  /** Emitido al pulsar «Editar» cuando `schema.detail.enabled === true`. */
-  readonly viewRecord: import("@angular/core").OutputEmitterRef<Row>;
-  private readonly api;
-  private readonly auth;
-  private readonly router;
-  readonly notifications: NotificationService;
-  private readonly actionService;
-  readonly status: import("@angular/core").WritableSignal<Status>;
-  readonly rows: import("@angular/core").WritableSignal<Row[]>;
-  readonly query: import("@angular/core").WritableSignal<string>;
-  readonly filterValues: import("@angular/core").WritableSignal<Record<string, string>>;
-  /** Clave del registro cuyo interruptor `active` está guardando. */
-  readonly savingKey: import("@angular/core").WritableSignal<string | null>;
-  /** Fila que se está editando en el drawer (plan 6.5); `null` = cerrado. */
-  readonly quickEditRow: import("@angular/core").WritableSignal<Row | null>;
-  /** Evita que una respuesta lenta pise el recurso ya cambiado. */
-  private loadEpoch;
-  constructor();
-  /** Búsqueda + filtros + orden `positionField` ascendente (cliente). */
-  readonly visibleRows: import("@angular/core").Signal<Row[]>;
-  readonly currencyCode: import("@angular/core").Signal<string>;
-  private readonly permissions;
-  readonly canCreate: import("@angular/core").Signal<boolean>;
-  readonly canUpdate: import("@angular/core").Signal<boolean>;
-  readonly canRemove: import("@angular/core").Signal<boolean>;
-  /** El atajo existe sólo si el schema lo declara y hay permiso de editar. */
-  readonly canQuickEdit: import("@angular/core").Signal<boolean>;
-  /** Subconjunto de campos del drawer, en el orden declarado en el schema. */
-  readonly quickEditFields: import("@angular/core").Signal<readonly FieldSchema[]>;
-  readonly hasRowActions: import("@angular/core").Signal<boolean>;
-  /** Mientras persiste un movimiento: bloquea drag y botones. */
-  readonly reordering: import("@angular/core").WritableSignal<boolean>;
-  /** Sin búsqueda ni filtros aplicados (base.md §10). */
-  private readonly hasActiveFilters;
-  /**
-   * Reordenable sólo si el schema lo declara, el permiso lo permite y no hay
-   * filtros activos: con filtros filtrados, el índice visual no corresponde a
-   * la posición real.
-   */
-  readonly canReorder: import("@angular/core").Signal<boolean>;
-  readonly dropDisabled: import("@angular/core").Signal<boolean>;
-  setQuery(value: string): void;
-  setFilter(key: string, value: string): void;
-  clearFilters(): void;
-  retry(): void;
-  isRowClickable(): boolean;
-  goView(row: Row): void;
-  onRowClick(row: Row): void;
-  goCreate(): void;
-  goEdit(row: Row): void;
-  /** Cerró con guardado: se recarga la fila (la respuesta puede venir achatada). */
-  quickEditSaved(): void;
-  toggleActive(row: Row, checked: boolean): Promise<void>;
-  /** Drop del CDK: `currentIndex` ya es el índice en la lista sin el elemento. */
-  onDrop(event: CdkDragDrop<Row[]>): void;
-  /** Botones subir/bajar (accesibilidad y móvil, base.md §13.10). */
-  moveBy(key: string, delta: -1 | 1): void;
-  /**
-   * Un movimiento → UNA intención al backend (baseapi §2.3 y §9):
-   * `{ reorder: { key, after | toStart | toEnd } }`, nunca posiciones
-   * calculadas. El índice objetivo es la posición FINAL del registro (el
-   * `currentIndex` del CDK ya es el índice de inserción en la lista sin el
-   * elemento, idéntico al índice final; subir/bajar suma/resta 1). El
-   * backend re-balancea, recalcula `position` y devuelve el listado fresco:
-   * sin escrituras optimistas — si falla, no cambió nada. `gap-sorting`
-   * quedó sólo para los campos con listas locales.
-   */
-  private moveRow;
-  removeRow(row: Row): Promise<void>;
-  /**
-   * Ejecuta una acción del schema. El comportamiento vive en el registro de
-   * acciones (R3.9–R3.11): la vista sólo aporta el registro y los puertos.
-   */
-  runAction(action: ResourceAction, row: Row): Promise<void>;
-  /** Icono que el descriptor declara para la acción; sin él, el rótulo. */
-  protected iconOf(action: ResourceAction): LucideIcon | undefined;
-  keyOf(row: Row): string;
-  titleOf(row: Row): string;
-  /**
-   * Formato efectivo de la columna (R4.4 · «declarada, no implícita»).
-   *
-   * `column.format` sólo sobreescribe; si no, manda la tabla de
-   * `column-defaults` según el `type` del campo — nunca el `?? 'text'`
-   * implícito que había.
-   */
-  formatOf(column: ListColumn): ListColumnFormat;
-  /**
-   * Contexto de la celda que recibe el formato (R4.3 · `extras.data`).
-   *
-   * Concentra aquí lo que sólo la vista sabe — permisos, moneda, guardado y
-   * la escritura de la fila — para que «añadir un formato» no la toque.
-   */
-  cellOf(row: Row, column: ListColumn): ColumnCell;
-  filterOptions(filter: ListFilter): SelectOption[];
-  inputValue(event: Event): string;
-  selectValue(event: Event): string;
-  private load;
-  static ɵfac: i0.ɵɵFactoryDeclaration<ListView, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<ListView, "app-list-view", never, {
-    "schema": {
-      "alias": "schema";
-      "required": true;
-      "isSignal": true;
-    };
-  }, {
-    "viewRecord": "viewRecord";
-  }, never, never, true, never>;
-}
-/** Pedido de «Crear nuevo» lanzado desde el dropdown de una relación. */
-interface RelationCreateRequest {
-  /** Recurso a crear (el `source.resource` de la relación). */
-  resource: string;
-  /**
-   * Se invoca con la clave recién creada. Vive en la relación porque es ella
-   * la que tiene que recargar sus opciones y preseleccionar el valor.
-   */
-  onCreated: (key: string) => void;
-}
-/**
- * Puente entre el control `relation` y el drawer que abre el formulario.
- *
- * Existe como señal inyectable y NO como un `output()` encadenado porque el
- * camino directo — `relation → DrawerForm → FieldHost → relation` — arma un
- * ciclo de imports de módulos: `field-host` se decoraría con
- * `FieldRelation === undefined` y Angular tiraría `Cannot read properties of
- * undefined (reading 'ɵcmp')`. El campo no puede importar un componente que,
- * a su vez, lo importa a él.
- *
- * Sólo hay un drawer a la vez, así que una única señal alcanza: quien lo
- * abre lo cierra con `clear()` al recibir `close`/`saved`.
- */
-declare class RelationDrawerService {
-  private readonly pending;
-  /** Pedido en curso; `null` cuando no hay panel abierto. */
-  readonly request: import("@angular/core").Signal<RelationCreateRequest | null>;
-  open(resource: string, onCreated: (key: string) => void): void;
-  clear(): void;
-  static ɵfac: i0.ɵɵFactoryDeclaration<RelationDrawerService, never>;
-  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
-type FormMode = 'create' | 'edit' | 'single';
-type FormStatus = 'loading' | 'ready' | 'error';
-interface SectionView {
-  id: string;
-  label: string;
-  fields: FieldSchema[];
-}
-/**
- * Un ítem del resumen de errores (§4.11). `id` es el que ya genera
- * `state().name()`: es a la vez el valor de `data-field` del envoltorio y el
- * `id` real del control, así que no se inventa ningún ancla nueva.
- */
-interface ErrorEntry {
-  id: string;
-  label: string;
-  message: string;
-  /** Sección/pestaña del campo raíz; `undefined` si no está en ninguna. */
-  section?: string;
-}
-/**
- * Formulario genérico: lo construye el schema del recurso (base.md §4–§6,
- * §10) con `form()` de Signal Forms sobre un modelo `Record<string, unknown>`.
- *
- * - **Acceso dinámico**: `form()[field.key]` no compila con claves
- *   arbitrarias; el modelo se tipa como `Record<string, unknown>` y el acceso
- *   vive en `fields/field-node.ts` (`childTree`) y en `form-schema.ts`
- *   (`pathAt`), que centralizan los dos casts.
- * - **Sin `debounce('blur')`**: difiere `controlValue → value` (el modelo), no
- *   la visibilidad de errores, y con controles custom (`multiselect`, que
- *   nunca emite `touch`) se perderían datos en el payload. La validación al
- *   perder foco la resuelve FieldHost (`invalid() && touched()`).
- * - `<form novalidate>`: Signal Forms expone `required` como atributo nativo,
- *   y la validación nativa del navegador bloquearía el submit sin mostrar
- *   nada (campos en `<details>` cerrados).
- */
-export declare class FormView {
-  /** Puente con el control `relation` (ver `relation-drawer.service`). */
-  readonly relationDrawer: RelationDrawerService;
-  private readonly route;
-  private readonly router;
-  private readonly nav;
-  private readonly api;
-  private readonly auth;
-  private readonly notifications;
-  private readonly errorMapper;
-  /** `form()` puede reconstruirse fuera de contexto (cambio de ruta). */
-  private readonly injector;
-  /** Estabilidad de la app: cambio de sección + carga de chunks (ver `goToError`). */
-  private readonly appRef;
-  private readonly params;
-  private readonly routeData;
-  readonly schema: import("@angular/core").Signal<ResourceSchema | undefined>;
-  /** Recurso actual (lo consumen `image` para pedir la firma, §11.2). */
-  readonly resourceId: import("@angular/core").Signal<string>;
-  /** Registro recién creado para alimentar el modal de resumen post-creación. */
-  readonly createdWithSummary: import("@angular/core").WritableSignal<Record<string, unknown> | null>;
-  readonly mode: import("@angular/core").Signal<FormMode>;
-  readonly heading: import("@angular/core").Signal<string>;
-  readonly status: import("@angular/core").WritableSignal<FormStatus>;
-  /**
-   * D4 — el error ORIGINAL de `load()` con identidad intacta (el mensaje
-   * mostrado es display-only). Se limpia cuando un reintento termina bien.
-   */
-  private errorCarga;
-  errorDeCarga(): unknown;
-  /** Estado «guardando» del botón (además del bloqueo interno de `submit`). */
-  readonly saving: import("@angular/core").WritableSignal<boolean>;
-  /** Errores del backend: rutas de campo + mensaje general (base.md §10). */
-  readonly serverErrors: import("@angular/core").WritableSignal<MappedError>;
-  /** Pestaña activa (solo `layout.mode === 'tabs'`). */
-  readonly activeSection: import("@angular/core").WritableSignal<string | null>;
-  private readonly attemptedSteps;
-  private readonly openSections;
-  private readonly formTree;
-  /** Evita que una respuesta lenta pise el formulario ya reconstruido. */
-  private loadEpoch;
-  /**
-   * Borrador (§4.6 / plan 5.4). `draftOffer` queda en `null` cuando no hay
-   * nada que ofrecer: NUNCA se restaura solo, sólo con un clic del usuario.
-   */
-  private readonly draftOffer;
-  /** Snapshot de lo que vino del servidor; sólo se guarda si el usuario cambió algo. */
-  private loadedSnapshot;
-  /** Registro original, para «Restablecer» (§5). */
-  private loadedRecord;
-  /** Snapshot de los padres de `dependsOn` y el árbol al que pertenece. */
-  private readonly dependsOnSnapshot;
-  private dependsOnTree;
-  /**
-   * Hubo un intento de guardado. Sin este guardia el resumen aparecería de
-   * entrada en cualquier formulario con `required` vacíos: `invalid()` es
-   * cierto desde el primer render, no sólo después de enviar.
-   *
-   * También gobierna el `⚠` de las pestañas y el bloqueo al cambiar de
-   * pestaña (decisión A): antes del primer Guardar un campo `required` vacío
-   * YA es inválido, y andar gritando `⚠` —o trancando la navegación— al
-   * usuario que todavía no le erró a nada es ruido, no ayuda.
-   */
-  readonly submitted: import("@angular/core").WritableSignal<boolean>;
-  constructor();
-  readonly layoutMode: import("@angular/core").Signal<LayoutMode>;
-  readonly layoutColumns: import("@angular/core").Signal<2 | 3>;
-  /** Campos que la UI sabe dibujar (los de Fase 11 se omiten, no se borran del payload). */
-  readonly renderedFields: import("@angular/core").Signal<FieldSchema[]>;
-  /**
-   * Ítems del resumen de errores (§4.11), vacío hasta que se intente guardar.
-   *
-   * Recorre el ÁRBOL, no `serverErrors.fields`: el backend sólo puede
-   * devolver un `path` por respuesta (`api.md §7`), así que ahí nunca hay más
-   * de un ítem. Los errores múltiples los produce la validación del cliente,
-   * que `submit()` deja marcados como tocados de una.
-   */
-  readonly summaryErrors: import("@angular/core").Signal<ErrorEntry[]>;
-  /** Secciones con al menos un campo dibujable. */
-  readonly sectionViews: import("@angular/core").Signal<SectionView[]>;
-  /** Campos sin sección (o con una sección inexistente): siempre visibles. */
-  readonly unsectionedFields: import("@angular/core").Signal<FieldSchema[]>;
-  /** En pestañas solo se dibuja la activa; en secciones, todas (colapsables). */
-  readonly visibleSections: import("@angular/core").Signal<SectionView[]>;
-  /** Indicador _dirty_ + aviso al salir (base.md §10). Agrega descendientes. */
-  readonly dirty: import("@angular/core").Signal<boolean>;
-  /** `slug` con `lockAfterCreate` se bloquea solo si el registro ya existe. */
-  readonly exists: import("@angular/core").Signal<boolean>;
-  readonly canSave: import("@angular/core").Signal<boolean>;
-  readonly canDelete: import("@angular/core").Signal<boolean | undefined>;
-  /** Reconstruye el formulario al cambiar de ruta o de recurso. */
-  private rebuild;
-  private load;
-  /**
-   * Siembra defaults + registro: los campos ausentes en la respuesta conservan
-   * su valor por defecto y los grupos/ítems parciales se fusionan en profundidad
-   * (si no, `childTree` no encontraría nodos y revienta al renderizar).
-   * `value.set` es programático: no marca `dirty`.
-   */
-  private applyRecord;
-  /** `draft:<recurso>:<key|nuevo>` — aislado por recurso Y registro. */
-  private draftStorageKey;
-  /** Best-effort: localStorage puede fallar (modo privado, cuota). */
-  private saveDraft;
-  /**
-   * Ofrece el borrador si es más reciente que el servidor. Si el registro no
-   * trae fecha, cualquier borrador sirve — sólo existe si el usuario cambió
-   * algo, porque `loadedSnapshot` filtra los idénticos.
-   */
-  private offerDraft;
-  /** Restaurar es una acción explícita del usuario (§4.6: nunca en silencio). */
-  restoreDraft(): void;
-  /** Descarta el borrador sin tocar lo cargado. */
-  discardDraft(): void;
-  private clearDraft;
-  /** «hace 1 min» — relativo y discreto (§4.6). */
-  draftAge(savedAt: number): string;
-  /**
-   * Botón «Restablecer» (§5): vuelve a lo que vino del servidor y limpia el
-   * borrador. Es la única vía de descartar cambios en modo edición.
-   */
-  restablecer(): void;
-  retry(): void;
-  /**
-   * D4 — «way back» desde el estado de error: en la ruta directa
-   * (`/:id/new`, `/:id/:key/edit`) no hay output que escape, así que el
-   * servicio declarado navega al origen registrado o a la raíz del recurso.
-   */
-  protected volverDeError(): void;
-  onSubmit(event: Event): Promise<void>;
-  /**
-   * create/update según el modo; nunca lanza (los errores van a `serverErrors`).
-   *
-   * **Regla de éxito por flujo** (guía §6: «toast y volver a la lista o
-   * quedarse según el flujo») — es la misma para los cuatro recursos:
-   *
-   * - **Crear** desde la pantalla completa → **vuelve a la lista** del
-   *   recurso: el registro quedó creado y no hay nada más que editar acá.
-   * - **Editar** → **se queda** y recarga lo guardado: el usuario sigue
-   *   trabajando sobre el mismo registro.
-   * - **Eliminar** → **vuelve a la lista** (`back()`).
-   * - **Desde un drawer** (crear una relación desde el dropdown, edición
-   *   rápida desde la lista) → **se queda** donde estaba: salir destruiría
-   *   el contexto que el drawer existía para conservar. Ver
-   *   `drawer-form.ts` y `relation-drawer.service.ts`.
-   *
-   * El toast se emite **antes** de navegar y el contenedor vive en el
-   * layout, así que sobrevive al cambio de ruta y el mensaje se lee igual.
-   */
-  private persist;
-  /**
-   * Errores del backend → mapa por ruta; el mensaje se queda en `general`
-   * sólo si su raíz (`address`, `faq[2]` → `faq`) no es un campo dibujado
-   * (base.md §10). Los hijos anidados se resuelven en el host con
-   * `serverErrors[prefix + key]`.
-   */
-  private applyServerErrors;
-  private hasServerErrors;
-  /** Muestra todos los errores: abre secciones, activa la pestaña con problemas. */
-  private revealErrors;
-  /** Scroll + focus al primer campo visible con mensaje de error. */
-  private scrollToFirstError;
-  remove(): Promise<void>;
-  /** Consultado por `unsavedChangesGuard` al salir de la ruta. */
-  canDeactivate(): Promise<boolean>;
-  back(): void;
-  onPostCreateClosed(): void;
-  colSpan(field: FieldSchema): string;
-  /** Id estable de una pestaña: ancla del foco programático. */
-  tabId(sectionId: string): string;
-  /**
-   * `role="tab"` exige moverse con `ArrowLeft`/`ArrowRight`/`Home`/`End`
-   * (WAI-ARIA APG). El foco se reengancha al que quedó ACTIVO, no al que se
-   * pidió: si `selectSection()` bloquea el cambio por validación (§4.9,
-   * decisión A) la selección no se mueve y el foco se queda donde estaba.
-   *
-   * Este handler es también lo que hace correcto el `Tab`: con el roving
-   * `tabindex` sólo la pestaña activa entra en el orden de tabulación, así
-   * que `Tab` va del tablist al primer campo de la sección en lugar de
-   * recorrer las pestañas apagadas.
-   */
-  onTablistKeydown(event: KeyboardEvent): void;
-  tabClass(section: SectionView): string;
-  isFirstStep(): boolean;
-  isLastStep(): boolean;
-  previousStep(): void;
-  nextStep(): void;
-  private unsectionedHasLocalErrors;
-  private revealUnsectionedErrors;
-  private scrollToStep;
-  selectSection(id: string): void;
-  /** Sólo validación local: los errores del backend no bloquean navegar. */
-  private sectionHasLocalErrors;
-  /**
-   * Marca la sección como tocada (los mensajes sólo aparecen una vez tocado)
-   * y devuelve el foco al primer campo con problema, sin cambiar de pestaña.
-   */
-  private revealSectionErrors;
-  isSectionOpen(id: string): boolean;
-  setSectionOpen(id: string, event: Event): void;
-  /**
-   * Índice lateral (§5.3) → sección. Abre el `<details>` primero: si estaba
-   * plegado, saltar antes daría con un elemento sin altura. El foco va al
-   * `<summary>` para que el teclado siga teniendo dónde continuar.
-   */
-  goToSection(id: string): void;
-  /** Invalido (propio, anidado o del backend): marca la pestaña/sección. */
-  fieldHasProblem(field: FieldSchema): boolean;
-  sectionHasProblem(section: SectionView): boolean;
-  /**
-   * Estado de progreso de una sección (§4.3 / decisión A).
-   *
-   * - `complete`: sin problemas → `✓` siempre, es progreso positivo.
-   * - `problem`: con problemas **después** del primer envío → `⚠`.
-   * - `pending`: con problemas pero todavía no se envió → sin marca, para
-   *   no amedrentar a quien recién abrió el formulario.
-   */
-  sectionProgress(section: SectionView): 'problem' | 'complete' | 'pending';
-  /**
-   * Un ítem por campo con problema, recorriendo el árbol. Los `group` se
-   * descienden para quedar en la hoja (ahí está el mensaje real); los
-   * compuestos (`list`, `key-value`, `string-list`) se listan como uno,
-   * porque el envoltorio es el único ancla a la que se puede saltar.
-   */
-  private collectErrors;
-  /** Mensaje del backend para una ruta raíz (`faq` cubre `faq[2].answer`). */
-  private serverMessageFor;
-  /**
-   * Enlace del resumen → campo. Cambia de pestaña/sección si hace falta y
-   * sólo después salta: en modo tabs el campo de otra pestaña todavía no
-   * existe en el DOM en este punto.
-   *
-   * Esperar la estabilidad sustituye al `setTimeout` anterior: cubre de una
-   * vez la pasada de change detection del cambio de sección **y** la carga
-   * del chunk perezoso del descriptor (`load()`, R3.4). Sin esa espera el
-   * foco se pierde sobre el envoltorio, que sí existe pero todavía no tiene
-   * control dentro.
-   */
-  goToError(entry: ErrorEntry, event: Event): Promise<void>;
-  /** Scroll + focus al campo con `data-field="id"` (mismo selector que `scrollToFirstError`). */
-  private focusField;
-  /**
-   * Con 2+ errores el foco va al resumen: es la única forma de que el usuario
-   * sepa que hay varios. Con uno solo se lo roba el campo, que ya está a la
-   * vista — por eso el resumen ni se pinta entonces.
-   */
-  private focusSummary;
-  private title;
-  private recordKey;
-  /** Schema destino del panel «Crear nuevo»; `undefined` si no existe. */
-  drawerSchema(resource: string): ResourceSchema | undefined;
-  /**
-   * Cerró el panel con un registro nuevo: se cierra, y si vino con clave se
-   * le pasa a la relación que lo pidió (recarga sus opciones y lo selecciona).
-   */
-  relationCreated(record: Record<string, unknown>, request: RelationCreateRequest): void;
-  static ɵfac: i0.ɵɵFactoryDeclaration<FormView, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<FormView, "app-form-view", never, {}, {}, never, never, true, never>;
-}
-/**
- * Reglas del formulario desde el schema (base.md §4, §6, §9, §10).
- *
- * Hay DOS clases de reglas y viven en sitios distintos:
- *
- * 1. **Ciclo de vida** — `visibleWhen`, `readonlyOn`, `hiddenOn`, `dependsOn`:
- *   decides si el campo se toca, se ve o se manda. Vive acá, con la
- *   estructura del formulario.
- * 2. **Validadores** — obligatoriedad, longitud, patrón, rangos, únicos…:
- *   vive en `core/registry/field-validators.ts` (F7 + B11), con los MISMOS
- *   nombres que el back. Este módulo sólo RECORRE ese registro por cada
- *   campo: añadir un validador es una entrada allá, no un `case` acá.
- *
- * El schema de Signal Forms recibe el path RAÍZ; las reglas se atan a la ruta
- * dinámica de cada campo. El barrido es **recursivo** — un `group` registra
- * las reglas de sus hijos bajo su propia ruta y un `list` registra las de
- * cada ítem con `applyEach`, de modo que las reglas corran también para los
- * ítems que se agregan después.
- *
- * Solo se generan reglas para los tipos que la UI sabe editar (`isSupported('field', …)`):
- * un campo invisible con `required` bloquearía el guardado para siempre.
- *
- * `api` y `excludeKey` alimentan la validación `unique`: se consulta el
- * listado del recurso y se descarta el propio registro (la clave del registro
- * en edición, tomada de la ruta).
- */
-export declare function buildFormSchema(schema: ResourceSchema, api: ApiService, excludeKey?: string): SchemaFn<Record<string, unknown>>;
-/** Árbol de un formulario con modelo dinámico. */
-export type RootTree = FieldTree<Record<string, unknown>>;
-/**
- * Contexto que el `ng-template` del `list` recibe por `ngTemplateOutlet`
- * para renderizar los campos de un ítem. El template vive en el despachador
- * (`field-host`) porque es el único que puede instanciar `app-field-host`;
- * el list lo instancia una vez por ítem con este contexto.
- */
-export interface ListChildContext {
-  fields: readonly FieldSchema[];
-  tree: RootTree;
-  /** Prefijo de ruta de los errores del backend para este nivel (`faq[2].`). */
-  prefix: string;
-  errors: Record<string, string>;
-  exists: boolean;
-  /** `itemDisplay: 'row'` → los campos van en flujo compacto, no en grilla. */
-  row: boolean;
-  /** Clase `sm:col-span-*` de un campo (literal: Tailwind v4 es JIT). */
-  colSpan: (width?: number) => string;
-}
-/** Subárbol del hijo directo bajo `key`. Lanza un error claro si el modelo no
- * contiene la clave (los modelos se siembran con los `default` del schema
- * antes de llamar a `form()`).
- */
-export declare function childTree<T>(parent: RootTree, key: string): FieldTree<T>;
-/** Subárbol de un campo `list`/`group` cuyo valor es un objeto. */
-export declare function groupTree(parent: RootTree, key: string): RootTree;
-/** Subárbol de un campo `list` (los ítems se acceden por índice). */
-export declare function listTree<T>(parent: RootTree, key: string): FieldTree<T[]>;
-/**
- * Ítem de una lista como árbol navegable.
- *
- * **Los nodos de ítem se atan a la identidad del elemento**, no al índice:
- * tras un cambio del arreglo el nodo viejo queda huérfano y leerlo lanza
- * `NG01904 «Orphan field»`. Por eso este helper se llama SIEMPRE fresco, en
- * cada render/computed — nunca se cachea un nodo entre mutaciones.
- *
- * El `as unknown` es porque `FieldTree<Item, number>` no es assignable a
- * `RootTree` (le falta el index signature de `string`), pero se navega igual.
- */
-export declare function itemTree<T>(items: FieldTree<T[]>, index: number): RootTree;
-/**
- * Ítem escalar de un `string-list` como nodo (`FieldTree<string>`), listo
- * para `[formField]`. Mismo criterio de frescura que `itemTree`.
- */
-export declare function stringItemTree(items: FieldTree<string[]>, index: number): FieldTree<string>;
-/**
- * Modelo y payload del formulario genérico (Fase 10, ampliado en Fase 11).
- *
- * - `seedModel` siembra un valor inicial para CADA campo declarado en el
- *   schema antes de crear el formulario: el árbol de Signal Forms replica la
- *   forma del modelo, así que un campo ausente no tendría estado (ni valor
- *   que enviar). La siembra vive en `shared/utils/seed.ts`.
- * - `buildPayload` decide qué viaja al backend (base.md §10): solo las claves
- *   declaradas en el schema, sin los ocultos y sin `positionField` raíz.
- */
-/** Valores por defecto del schema, en el mismo orden/shape que el JSON. */
-export declare function seedModel(schema: ResourceSchema): Record<string, unknown>;
-/**
- * Payload del guardado: whitelist de `schema.fields`.
- *
- * - Los campos ocultos (`visibleWhen` falso) no se muestran ni se envían
- *   (base.md §10): usar `hidden()` garantiza que no aparezcan acá aunque
- *   tengan valor sembrado — también dentro de `group` y de los ítems de una
- *   `list` (recursivo).
- * - `positionField` del recurso se excluye aunque esté declarado: el orden
- *   del listado lo gestiona el backend (api.md R3, nunca se expone). El
- *   `positionField` de los ÍTEMS de una lista sí viaja: el orden local lo
- *   calcula el front (base.md §8).
- * - Los tipos que la UI todavía no edita SÍ viajan: sus valores llegan del
- *   registro leído, así que reenviarlos evita pisarlos.
- */
-export declare function buildPayload(schema: ResourceSchema, root: RootTree): Record<string, unknown>;
-type View = 'list' | 'detail';
-/**
- * Página del recurso: resuelve el `id` de la ruta contra el registry y
- * despacha según `kind` — colección → list view, singleton → form view,
- * dashboard → panel de sólo lectura — aplicando `permissions` (estado
- * «sin permisos»).
- *
- * Cuando `schema.detail.enabled === true`, intercepta el click de fila del
- * `ListView` y muestra el `DetailView` en lugar de navegar al formulario.
- * «Editar» desde el `DetailView` sí navega al formulario de edición.
- */
-export declare class ResourcePage {
-  private readonly route;
-  private readonly router;
-  private readonly auth;
-  private readonly params;
-  private readonly routeData;
-  readonly schema: import("@angular/core").Signal<ResourceSchema | undefined>;
-  /** Vista activa: 'list' (por defecto) o 'detail' (al hacer clic en una fila con detail.enabled). */
-  readonly currentView: import("@angular/core").WritableSignal<View>;
-  /** Registro seleccionado para la vista de detalle. */
-  readonly selectedRecord: import("@angular/core").WritableSignal<Record<string, unknown> | null>;
-  constructor();
-  private openFromRoute;
-  /**
-   * Clic de fila. R9.9.4 · decision table: si el schema declara `select`,
-   * el contrato declarado REEMPLAZA el comportamiento local (`route` ⇒
-   * emisión al dispatcher, `inline` ⇒ selección local sin URL, `none` ⇒
-   * no-op); sin declaración, la navegación local actual sigue intacta
-   * (backward compat — R9.9 «existing routes untouched»).
-   */
-  switchToDetail(record: Record<string, unknown>): void;
-  switchToList(): void;
-  goEdit(record: Record<string, unknown>): void;
-  /**
-   * Colección sin ninguna operación posible u singleton sin `update`: no hay
-   * nada que mostrar con sentido (base.md §10 «Sin permisos»).
-   *
-   * R7.5: usa policies cuando existan, fallback a permissions.
-   *
-   * Un dashboard nunca entra aquí: es un panel de sólo lectura, `ResourcePermissions`
-   * no tiene `read` y el acceso real a los datos lo decide el endpoint
-   * (A4: el cliente es interfaz, no autoridad).
-   */
-  hasNoAccess(schema: ResourceSchema): boolean;
-  static ɵfac: i0.ɵɵFactoryDeclaration<ResourcePage, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<ResourcePage, "app-resource-page", never, {}, {}, never, never, true, never>;
-}
-/**
- * R9.9 · slice 3 — Host genérico de composición (`uiView` tipo `tabs`).
- *
- * Un SOLO componente recursivo renderiza cualquier composición declarada:
- * resuelve cada hijo por `(kind:'view', type)` dentro del `ViewSlot` (D2,
- * sin `switch` de dominio y sin importar hojas), monta la validación del
- * schema ANTES del primer render (fail-loud) y maneja el tablist accesible
- * con roving tabindex (R9.9.5).
- *
- * Decisiones R9.9.5:
- * - Retención: un hijo `retain:true` visitado queda MONTADO pero oculto
- *   (`hidden`); sin `retain` se destruye al cambiar de pestaña.
- * - Pestaña activa LOCAL por componente: no hay estado compartido entre
- *   instancias de tabs anidadas (documentado en los docs de slice 5).
- * - `visibleWhen` se evalúa sin record (el contenedor no es un formulario):
- *   contra registro vacío, TODAS las condiciones deben pasar (AND).
- *   Si la pestaña activa queda oculta, la selección cae visiblemente a la
- *   primera visible — nunca se pierde en silencio.
- */
-export declare class ComposerHost {
-  private readonly route;
-  private readonly routeData;
-  /** Schema: explícito en `data` (fixtures/ruta embebida) o vía `resourceId`. */
-  readonly schema: import("@angular/core").Signal<ResourceSchema | undefined>;
-  /** instanceId de ESTE contenedor (raíz ⇒ nombre de la uiView de ruta). */
-  readonly uiViewName: import("@angular/core").Signal<string>;
-  /** Profundidad de ESTE contenedor (raíz ⇒ 0; embebido ⇒ payload.depth). */
-  readonly profundidad: import("@angular/core").Signal<number>;
-  /** Config `tabs` declarada para esta instancia. */
-  readonly vista: import("@angular/core").Signal<UiViewTabs | undefined>;
-  /** Error determinista de configuración (schema/vista ausente o no-tabs). */
-  private readonly errorConfig;
-  /** Error de validación D2 (se recalcula una sola vez, en el constructor). */
-  private readonly errorValidacion;
-  /** Error mostrado: validación del schema primero, luego configuración. */
-  readonly error: import("@angular/core").Signal<string | null>;
-  /** Todos los hijos declarados (orden de declaración). */
-  private readonly hijos;
-  /** Hijos visibles: TODAS sus condiciones `visibleWhen` pasan sin record. */
-  readonly visibles: import("@angular/core").Signal<readonly ViewChildNode[]>;
-  /** Selección del usuario (intención; vacío ⇒ usar `initial`/primera). */
-  private readonly seleccion;
-  /**
-   * Pestaña activa EFECTIVA: derivada pura de la selección y de las
-   * visibles — si la selección dejó de existir (u oculta), cae a `initial`
-   * o a la primera visible de forma SINCRÓNICA y visible (R9.9.5: nunca
-   * perder la vista elegida en silencio). Estado LOCAL por instancia.
-   */
-  readonly activo: import("@angular/core").Signal<string>;
-  /** Ids ya seleccionados alguna vez (sustento de la retención). */
-  private readonly visitados;
-  /** Paneles en DOM: activo + retenidos visitados que siguen visibles. */
-  readonly montados: import("@angular/core").Signal<readonly ViewChildNode[]>;
-  constructor();
-  /** Selecciona una pestaña y, opcionalmente, mueve el foco a su botón. */
-  seleccionar(id: string, conFoco: boolean): void;
-  /** Navegación por teclado del tablist: flechas con wrap, Home/End. */
-  onKeydown(event: KeyboardEvent): void;
-  /** El panel de este hijo está montado (⇒ existe su `aria-controls`). */
-  montado(id: string): boolean;
-  /** Clases del botón de pestaña: activo resaltado con token `primary`. */
-  claseTab(id: string): string;
-  /** Etiqueta a11y del tablist (la del recurso). */
-  etiqueta(): string;
-  static ɵfac: i0.ɵɵFactoryDeclaration<ComposerHost, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<ComposerHost, "app-composer-host", never, {}, {}, never, never, true, never>;
-}
-/**
- * Contexto de accesibilidad que `app-field-host` expone a los controles.
- *
- * El host conoce la ayuda y el error (ambos viven en SU plantilla), pero el
- * `<input>` real vive dentro de un componente hijo distinto por cada tipo de
- * campo. En lugar de pasar dos inputs por cada uno de los 14 controles, el
- * host provee este contexto y cada control importa `FieldAria`, que lo lee
- * por DI y lo vuelca en el elemento.
- *
- * Selector por `[id]`: casa sólo con el elemento que ya recibe el `for` de la
- * etiqueta, así el mismo id es ancla de label y de `aria-describedby`. Los
- * controles fuera de un `app-field-host` inyectan `null` y no emiten nada.
- */
-interface FieldAriaContext {
-  /** `id` del texto de ayuda y/o del error, separados por espacio. */
-  readonly describedBy: Signal<string | null>;
-  /** `true` cuando el campo muestra error visible (mismo criterio que el mensaje). */
-  readonly invalid: Signal<boolean>;
-  /**
-   * Requerido por schema. Necesario porque la marca visual `*` desaparece en
-   * los recursos donde mandan los `(opcional)` (§2): sin este atributo el
-   * requerimiento quedaría sólo en pantalla.
-   */
-  readonly required: Signal<boolean>;
-}
-declare const FIELD_ARIA: InjectionToken<FieldAriaContext>;
-/**
- * Vincula `aria-invalid` y `aria-describedby` a un control de formulario.
- *
- * `aria-invalid` se emite SIEMPRE (`"true"`/`"false"`, nunca ausente) para
- * que el atributo sea inspeccionable en cualquier estado; `aria-describedby`
- * se omite cuando no hay ni ayuda ni error, que es el caso por defecto.
- * `aria-required` sigue la misma regla que `aria-invalid`.
- *
- * Convención con `role="alert"` en el mensaje de error: el `alert` anuncia el
- * error en el momento en que aparece (fallo de submit), mientras que
- * `aria-describedby` lo lee al enfocar el campo. Son momentos distintos; no
- * compiten.
- */
-declare class FieldAria {
-  private readonly ctx;
-  protected readonly ariaInvalid: Signal<string | null>;
-  protected readonly ariaRequired: Signal<string | null>;
-  protected readonly ariaDescribedBy: Signal<string | null>;
-  static ɵfac: i0.ɵɵFactoryDeclaration<FieldAria, never>;
-  static ɵdir: i0.ɵɵDirectiveDeclaration<FieldAria, "input[id], select[id], textarea[id], output[id]", never, {}, {}, never, never, true, never>;
-}
-/**
- * Forma del valor inicial que siembra un campo (D32 · R3.8).
- *
- * Son **todos** los valores posibles del dominio: un campo de formulario
- * nuevo nace como cadena, número, booleano, lista o como contenedor que
- * siembra sus hijos. Si un tipo llegara a necesitar otra forma, ampliar este
- * `type` obliga a compilar el `switch` de `seedValue` — que es exactamente
- * el fail-loud que la regla 4 pide.
- */
-type SeedKind = 'string' | 'number' | 'boolean' | 'array' | 'recursive';
-/**
- * Siembra del modelo del formulario: un valor por defecto para CADA campo
- * declarado en el schema (base.md §10).
- *
- * Compartido entre `form-model` (crear/recargar) y los componentes de lista
- * (crear ítems nuevos con la forma de sus `itemFields`).
- */
-/**
- * Valor inicial cuando el schema no declara `default`.
- *
- * **D32 · ya no despacha por tipo.** El `switch` de 20 ramas que obligaba a
- * editar este fichero al añadir un campo — y que §0 contaba como tocar el
- * motor — pasa a resolver el nombre que declara el propio descriptor
- * (`RenderDescriptor.seed`). «Añadir un tipo» queda en carpeta + manifiesto
- * + unión: este archivo no se entera.
- *
- * Dos salidas distintas, ninguna silenciosa:
- *
- *  · **tipo fuera del catálogo** ⇒ `undefined`, la misma degradación
- *    controlada que el render (R1.10): el campo no se pinta, así que su
- *    valor no existe;
- *  · **descriptor sin `seed`** ⇒ lanza. Es un error de programación que
- *    `core/registry/contract.spec.ts` detecta en CI antes de llegar acá.
- */
-declare function seedValue(field: FieldSchema): unknown;
-/** Valor sembrado de un campo, fusionando `default` con la forma del schema. */
-declare function seedFieldValue(field: FieldSchema): unknown;
-/**
- * Siembra recursiva: los `group` anidan sus propios campos. Exportada porque
- * la lista crea sus ítems nuevos con la misma forma (`base.md §6`).
- */
-declare function seedFields(fields: readonly FieldSchema[]): Record<string, unknown>;
-/**
- * Fusiona el registro leído con la forma sembrada del schema.
- *
- * El backend puede omitir claves (p. ej. un ítem guardado antes de que el
- * schema agregara un campo): sin esta fusión el árbol no tendría nodo para
- * ese campo y `childTree` lanzaría al renderizar. Lo ausente toma su
- * `default` y los extras del registro (p. ej. `position` de los ítems) se
- * conservan.
- */
-declare function mergeRecord(fields: readonly FieldSchema[], record: Record<string, unknown>): Record<string, unknown>;
-declare function isRecord(value: unknown): value is Record<string, unknown>;
-/**
- * Registro único de render (R3.1 · `doc/plan-refactor-motor.md` §3.1).
- *
- * Un solo sitio declara qué componentes sabe dibujar la UI: cada tipo de
- * campo, widget, acción o vista aporta un `RenderDescriptor` y el registro
- * lo resuelve por `(kind, type)`. Los hosts dejan de mantener `Set`s de tipos
- * e imports a mano — **en runtime el registro es la única fuente de verdad**.
- *
- * Se carga a scope de módulo y no desde DI: `buildFormSchema()` es una
- * función pura que consulta el registro sin inyectar nada, así que un
- * registro llenado únicamente por un provider dejaría esa consulta correr
- * contra un catálogo vacío. `provideRenderDescriptors()` existe igualmente
- * como punto de entrada explícito para `app.config.ts` (R3.2).
- *
- * Autodescubrimiento (D9-1): se opta por **registro manual** — un manifiesto
- * con una línea por descriptor — porque `import.meta.glob` no está
- * implementada por el bundler de producción (`@angular/build:application`
- * usa esbuild) y la llamada cruda sobreviviría en `dist/`, rompiendo el
- * arranque. Con Vite sólo en el dev-server y en el runner de tests, además,
- * el comportamiento habría diferido entre `npm test` y `npm run build`.
- */
-/** Qué clase de cosa se está resolviendo. Identificador único dentro de su `kind`. */
-type RenderKind = 'field' | 'column-format' | 'widget' | 'action' | 'view' | 'layout';
-type ComponentRenderKind = Exclude<RenderKind, 'layout'>;
-/** Superficies en las que un descriptor puede aparecer. */
-type RenderSurface = 'form' | 'display' | 'list' | 'filter';
-/**
- * Qué puede describir un `RenderDescriptor`: un campo del formulario, un
- * widget del dashboard o una columna de listado (R4.3).
- *
- * Es el tipo del input `config` del host. Los descriptores sólo comparten
- * `key` y `label`; lo demás lo decide cada `kind`, y quien necesita el resto
- * lo castea con su propia mirada (`cfgCampo()`, que es lo que el host ya
- * hacía antes de que existieran las columnas).
- */
-type RenderConfig = FieldSchema | WidgetSchema | ListColumn;
-/**
- * Contexto de render que el host expone por DI (R3.4 · `doc/plan-refactor-motor.md` §3.4).
- *
- * Los controles viven en un componente distinto por cada tipo, así que en vez
- * de repetir cinco inputs en los 20 el host lo provee una sola vez y cada
- * control lo inyecta si lo necesita — el mismo criterio que ya usaba
- * `FIELD_ARIA`.
- *
- * `tree` viaja en el contexto y no como input suelto porque es **por
- * instancia**: los hijos de un `group` o de un `list` navegan su subárbol, no
- * el del padre.
- *
- * Vive acá y no en `render-host.ts` porque el contrato de los descriptores
- * (`RenderExtras`) necesita nombrarlo: el descriptor de un campo compuesto
- * decide qué se le pasa al componente y eso sólo es escribible conociendo el
- * tipo. `render-host.ts` lo re-exporta para no mover a sus consumidores.
- */
-interface RenderContext {
-  /** Árbol del formulario del nivel de este campo. */
-  tree: RootTree;
-  /** Errores del backend por ruta (`address.street`, `faq[2].answer`). */
-  serverErrors: Record<string, string>;
-  /** Prefijo de ruta de este campo en el registro raíz (`address.`). */
-  pathPrefix: string;
-  /** Si el registro ya existe (lo consume `slug` con `lockAfterCreate`). */
-  exists: boolean;
-  /** Recurso dueño del formulario (lo consume `image` para la firma, §11.2). */
-  resource: string;
-}
-/**
- * Contexto vacío con el que arranca `RenderHost.ctx`.
- *
- * Sólo lo alcanza quien renderiza sin contexto — los widgets, que no forman
- * parte de un formulario. Un campo montado sin `ctx` es un error de
- * programación y `childTree` lo dice con su propio mensaje, igual que lo
- * decía el `input.required` anterior.
- */
-declare const RENDER_CONTEXT_VACIO: RenderContext;
-/**
- * Segundo argumento de `RenderDescriptor.inputs`.
- *
- * Aporta lo que el host conoce y el descriptor no: el contexto de formulario
- * (sólo para campos), el payload del dato (sólo para widgets) y los dos
- * templates con los que se componen `group` y `list`.
- */
-interface RenderExtras {
-  /** Contexto del nivel; `RENDER_CONTEXT_VACIO` cuando no hay formulario. */
-  ctx: RenderContext;
-  /** Payload del widget (`<app-widget-host [data]>`); `null` en campos. */
-  data: unknown;
-  /** Template del contenido de un `group`. */
-  groupContent?: TemplateRef<unknown>;
-  /** Template de los hijos de un `list`. */
-  childTemplate?: TemplateRef<unknown>;
-}
-/**
- * Declaración de un componente renderizable.
- *
- * No lleva `configSchema`: esa cláusula de `refactormotor.md` no existe en
- * el código y el plan la descartó (D17).
- */
-interface RenderDescriptor<C = unknown> {
-  /** Clase de cosa. */
-  kind: ComponentRenderKind;
-  /** Identificador `kebab-case`, único dentro de `kind`. */
-  type: string;
-  /** Versión del contrato en que apareció (`doc/refactormotor.md`). */
-  since: string;
-  /**
-   * Carga perezosa del componente. El registro se resuelve sin arrastrar el
-   * bundle: los descriptores sólo guardan el cierre, no la clase.
-   */
-  load: () => Promise<Type<any>>;
-  /** Superficies en las que se usa. Sólo lo que se pueda evidenciar en el código. */
-  surfaces?: RenderSurface[];
-  /** Valores por defecto de la configuración del descriptor. */
-  defaults?: Partial<C>;
-  /**
-   * Forma del valor inicial que siembra este campo en el modelo del
-   * formulario (D32 · R3.8).
-   *
-   * **Dato, no función**: un nombre resuelto por `shared/utils/seed.ts`, no
-   * una clausura. Así el descriptor sigue siendo puro —`kind`, `type`,
-   * `load`, `surfaces`, `seed`— y `seed.ts` es el único dueño de recorrer
-   * un árbol de campos. La alternativa (`seed: (cfg) => …`) obligaría a que
-   * `group` importara `seedFields`, lo que cerraría un ciclo
-   * registro → manifiesto → descriptor → `seed` → registro.
-   *
-   * Sólo los campos lo declaran. **Obligatorio para `kind: 'field'`** — lo
-   * vigila `core/registry/contract.spec.ts`, porque la exhaustividad de una
-   * unión de strings no puede imponerse en tiempo de compilación.
-   */
-  seed?: SeedKind;
-  /**
-   * Cableado del componente: qué inputs recibe y con qué valor.
-   *
-   * Es **la** pieza que mantiene el host genérico: sin esto el motor tendría
-   * que saber que `metric-card` recibe `label/value/hint` y que `group`
-   * necesita además el template de sus hijos, y «añadir un tipo» volvería a
-   * tocar `render-host.ts` (R3.8). Cada descriptor declara el suyo y el host
-   * sólo hace `ngComponentOutletInputs = descriptor.inputs(config, extras)`.
-   *
-   * No es obligatorio: el 80 % de los tipos comparten la forma estándar de su
-   * `kind` — `{field, tree}` en campos, `{widget, data}` en widgets — y para
-   * ellos el host aplica esa forma por defecto. Se declara sólo cuando el
-   * componente se desvía de ella.
-   */
-  inputs?: (config: C, extras: RenderExtras) => Record<string, unknown>;
-}
-/** Declaración de un layout manejado por el host de formularios. */
-interface LayoutDescriptor {
-  kind: 'layout';
-  type: LayoutMode;
-  since: string;
-}
-/**
- * Registra un descriptor. Idempotente por clave: volver a registrar el mismo
- * `(kind, type)` lo sobrescribe, lo que permite que un módulo se recargue en
- * desarrollo sin duplicar entradas.
- */
-declare function register(kind: 'layout', descriptor: LayoutDescriptor): void;
-declare function register(kind: ComponentRenderKind, descriptor: RenderDescriptor): void;
-/**
- * Quita un descriptor (R7.6). Simétrico a `register`: los specs que
- * registran entradas de prueba deben retirarlas, o el catálogo global queda
- * contaminado para cualquier otro spec que lea `renderKinds()` (flaky por
- * orden de ejecución).
- */
-declare function unregister(kind: RenderKind, type: string): void;
-/** Descriptor declarado para `(kind, type)`, o `undefined` si nadie lo registró. */
-declare function get(kind: ComponentRenderKind, type: string): RenderDescriptor | undefined;
-/** ¿La UI sabe dibujar este `(kind, type)`? Reemplaza a los `Set`s de los hosts. */
-export declare function isSupported(kind: RenderKind, type: string): boolean;
-/**
- * Componente para `(kind, type)`, o `fallback` si el tipo no está en el
- * catálogo.
- *
- * Es **asíncrona** porque `load()` importa el componente bajo demanda; el
- * `fallback` es síncrono y sólo se usa cuando no hay descriptor. Un fallo de
- * `load()` NO se traga: propagarlo es lo que hace visible un descriptor mal
- * escrito, y la política «nunca pantalla rota» la resuelve el llamante con el
- * `fallback` que ya recibe.
- */
-declare function resolve<C = unknown>(kind: ComponentRenderKind, type: string, fallback: Type<C>): Promise<Type<C>>;
-/**
- * Punto de entrada para `app.config.ts` (R3.2).
- *
- * El catálogo ya quedó cargado al importar este módulo; el provider sirve
- * para que el arranque sea explícito y para avisar en desarrollo si el
- * manifiesto vino vacío — que es exactamente lo que pasaría si alguien
- * borra una línea del manifiesto sin reemplazarla.
- */
-export declare function provideRenderDescriptors(): EnvironmentProviders;
-/** Cuántos descriptores hay registrados. Sólo para comprobaciones y tests. */
-declare function renderDescriptorCount(): number;
-/**
- * `kind`s que hoy tienen al menos un descriptor.
- *
- * Existe para el test de exhaustividad (R3.7): él recorre los schemas de los
- * `kind`s que tienen registro y **falla** si aparece un `kind` con descriptor
- * que nadie recorre — de lo contrario «tener registro» y «estar cubierto»
- * serían dos afirmaciones distintas que nadie reconcilia.
- */
-export declare function renderKinds(): RenderKind[];
-/** Token con el que los controles inyectan el `RenderContext` del host. */
-declare const RENDER_CONTEXT: InjectionToken<RenderContext>;
-/**
- * Host genérico de render (R3.4).
- *
- * Sustituye el `@switch` de 21 ramas de `FieldHost` por una resolución contra
- * `core/registry/render-registry.ts`: el tipo llega por `[type]`, el registro
- * devuelve el componente y `NgComponentOutlet` lo monta. Añadir un tipo deja
- * de tocar este archivo.
- *
- * Conserva el envoltorio que `FieldHost` dibujaba — `<label>`, marca
- * required/opcional, `data-field`, `colSpanClass`, mensaje de error y ayuda —
- * porque eso es lo que el operador ve y no depende del tipo de control.
- *
- * **Sin imports de los 20 controles**: sólo llegan por `load()` perezoso del
- * descriptor. Mientras el `import()` resuelve se pinta `Skeleton`, y un tipo
- * fuera del catálogo degrada a `UnknownRender` en dev (nunca pantalla rota).
- *
- * **Modo `display` (R4.1 · R4.2).** El mismo host pinta la ficha de detalle:
- * con `mode="display"` no hay árbol, ni etiqueta, ni error — sólo el valor
- * crudo que llega por `[value]` y el componente que elige la tabla
- * `fields/display/display-defaults.ts`. El descriptor declara la superficie
- * (`surfaces: ['form', 'display']`) y, si no la declara o el tipo no está en
- * la tabla, corre la misma degradación controlada de R1.10.
- */
-declare class RenderHost implements FieldAriaContext, RenderContext {
-  /** Categoría de render. Resuelve campos y widgets (R3.6). */
-  readonly kind: import("@angular/core").InputSignal<ComponentRenderKind>;
-  /** Identificador del tipo dentro de su `kind`. */
-  readonly type: import("@angular/core").InputSignal<string>;
-  /**
-   * Configuración del descriptor: el `FieldSchema` del campo, el
-   * `WidgetSchema` del widget o la `ListColumn` de la columna (R4.3).
-   */
-  readonly config: import("@angular/core").InputSignal<RenderConfig>;
-  /**
-   * Contexto de render del nivel de este campo.
-   *
-   * Con valor por defecto y no requerido: los widgets no pertenecen a un
-   * formulario y llegan sin árbol (R3.6). El default es un contexto vacío
-   * que nunca se lee en esa rama — un campo montado sin contexto real ya
-   * era un error antes y `childTree` lo sigue siendo.
-   */
-  readonly ctx: import("@angular/core").InputSignal<RenderContext>;
-  /** Payload del widget (`app-widget-host [data]`). `null` en campos. */
-  readonly data: import("@angular/core").InputSignal<unknown>;
-  /**
-   * Superficie de render (R4.1).
-   *
-   * `'form'` (por defecto) es el formulario de siempre: árbol, etiqueta,
-   * marca required, error y ayuda. `'display'` es la ficha de detalle:
-   * valor crudo, sin envoltorio — es el `mode="display"` con el que
-   * `detail-view` deja de dibujar sus propias celdas (R4.2).
-   */
-  readonly mode: import("@angular/core").InputSignal<"form" | "display">;
-  /**
-   * Valor crudo del registro, **sólo para el modo `display`**.
-   *
-   * En el formulario el valor vive en el árbol de Signal Forms y este
-   * input se ignora: un campo de detalle no tiene árbol que consultar.
-   */
-  readonly value: import("@angular/core").InputSignal<unknown>;
-  /**
-   * Presentación en chip, **sólo para el modo `display`** (R4.2).
-   *
-   * La cabecera de la ficha siempre mostró `headerFields` como etiquetas
-   * compactas, aunque el valor fuera texto plano. Sin este matiz el host
-   * pintaría «ORD-42» como texto suelto y la cabecera cambiaría de cara en
-   * los 7 detalles. El aviso va en el contrato de entrada de los display —
-   * uniforme para los 6 — y sólo lo aprovechan los que dibujan texto: los
-   * que ya son chip (`badge`) o no son un valor escalar (`image`, `list`)
-   * lo ignoran a propósito.
-   */
-  readonly chip: import("@angular/core").InputSignal<boolean>;
-  private readonly dev;
-  /** Mantiene `whenStable()` bloqueado mientras el descriptor carga su chunk. */
-  private readonly pendientes;
-  /** `true` cuando se dibuja un campo, `false` para cualquier otro `kind`. */
-  protected readonly esCampo: import("@angular/core").Signal<boolean>;
-  /** `true` en la rama de detalle (R4.1): sin árbol, etiqueta ni error. */
-  protected readonly esDisplay: import("@angular/core").Signal<boolean>;
-  /**
-   * ¿El descriptor declara la superficie `display`? (R4.1)
-   *
-   * Es la respuesta a «cada descriptor de campo declara si sabe pintarse en
-   * `display`»: sin esa declaración el host no pinta el valor en la ficha,
-   * y `contract.spec.ts` vigila que los 20 la traigan.
-   */
-  private readonly declaraDisplay;
-  /**
-   * Componente que pinta este tipo en `display`.
-   *
-   * El descriptor sólo dice **si** sabe pintarse; **qué** componente usa lo
-   * decide la tabla por tipo (`fields/display/display-defaults.ts`), que es
-   * la que garantiza que el mismo `field.type` se pinte igual en todas las
-   * fichas.
-   */
-  private readonly loaderDisplay;
-  /** El modo display tiene componente para este tipo. */
-  protected readonly soportaDisplay: import("@angular/core").Signal<boolean>;
-  /**
-   * Valor vacío, con el mismo criterio que `formatValue` de `detail-view`
-   * antes de R4.2 (`null`, `undefined` o `''`): se pinta un `—` y el
-   * componente ni se monta. `false`, `0` y `[]` **no** están vacíos.
-   */
-  protected readonly vacio: import("@angular/core").Signal<boolean>;
-  /** Configuración leída como campo. Sólo válida en la rama de campo. */
-  private readonly cfgCampo;
-  private readonly node;
-  protected readonly state: import("@angular/core").Signal<import("@angular/forms/signals").FieldState<unknown, string | number>>;
-  /** Nombre del control: ancla del `<label for>` y base de `*-help`/`*-error`. */
-  protected readonly name: import("@angular/core").Signal<string>;
-  /**
-   * Fuera del catálogo o oculto por `visibleWhen`: no se dibuja.
-   *
-   * El `isSupported` va primero y corta antes de leer `state()`: un tipo
-   * desconocido se siembra como `undefined`, Signal Forms no le crea nodo y
-   * `childTree` lanzaría «El formulario no contiene el campo».
-   *
-   * El `esCampo()` corta lo mismo para los widgets: no hay árbol que ocultar
-   * ni nodo que consultar, así que el widget se dibuja si está en el
-   * catálogo y ya.
-   */
-  protected readonly supported: import("@angular/core").Signal<boolean>;
-  /**
-   * Sin renderizador para este tipo **en la superficie actual**.
-   *
-   * En `display`: el descriptor no declara la superficie o el tipo no está
-   * en la tabla de display. En `form`: sigue siendo «fuera del catálogo».
-   * Ninguna de las dos ramas toca `state()`, que en display no existe.
-   */
-  private readonly unsupported;
-  protected readonly showUnknown: import("@angular/core").Signal<boolean>;
-  private readonly _trazaTipoDesconocido;
-  /** Componente montado, o `null` mientras el `load()` perezoso resuelve. */
-  private readonly control;
-  /** Descarta cargas obsoletas cuando el tipo cambia antes de que resuelva. */
-  private carga;
-  private readonly _cargar;
-  /**
-   * Inputs del componente de display.
-   *
-   * Forma fija y uniforme para los 6 componentes de
-   * `fields/display/`: `field` (el `FieldSchema` completo, para los que
-   * necesitan `options`), `value` (el valor crudo) y `chip` (la
-   * presentación de la cabecera). El descriptor no interviene acá — en
-   * display no hay ni control ni árbol que cablear.
-   */
-  private readonly displayInputs;
-  /**
-   * Inputs del componente montado.
-   *
-   * El motor no sabe qué recibe cada tipo: pregunta al descriptor (`inputs`)
-   * y sólo aplica la forma estándar del `kind` cuando el descriptor no la
-   * sobreescribe — `{field, tree}` en campos, `{widget, data}` en widgets.
-   * Ésa es la pieza que hace que «añadir un tipo» no toque este archivo
-   * (R3.8). `multiselect` e `image` no pasan por aquí: se declaran a mano
-   * por D27.
-   */
-  private readonly controlInputs;
-  protected readonly group: import("@angular/core").Signal<GroupField>;
-  protected readonly list: import("@angular/core").Signal<ListField>;
-  private readonly groupTpl;
-  private readonly childTpl;
-  /** Subárbol y prefijo que heredan los hijos del grupo. */
-  protected readonly groupChildCtx: import("@angular/core").Signal<RenderContext>;
-  protected listChildCtx(child: ListChildContext): RenderContext;
-  /** `sm:col-span-*` compartido con el grupo (literales: Tailwind v4 es JIT). */
-  colSpan(width?: number): string;
-  /**
-   * Los tres `FormValueControl` se declaran en la plantilla (D27), así que
-   * su campo necesita el tipo estrecho que exige cada input — el mismo
-   * estrechado que hacía `FieldHost`.
-   */
-  protected readonly multiselectCfg: import("@angular/core").Signal<MultiselectField>;
-  protected readonly imageCfg: import("@angular/core").Signal<ImageField>;
-  protected readonly fileCfg: import("@angular/core").Signal<FileField>;
-  private readonly multiselectNode;
-  private readonly imageNode;
-  private readonly fileNode;
-  /**
-   * Error visible: primero el del backend (si existe para esta ruta) y
-   * después el propio, solo cuando el campo ya se tocó (validación al
-   * perder el foco).
-   */
-  protected readonly errorMessage: import("@angular/core").Signal<string | null>;
-  /**
-   * Compuestos: varios controles internos, ninguno único. Para ellos
-   * `<label for>` no tendría ancla, porque ningún elemento lleva el id del
-   * campo padre (los hijos tienen los suyos propios).
-   */
-  protected readonly composite: import("@angular/core").Signal<boolean>;
-  /**
-   * Ancla de la ayuda, sólo mientras no hay error: §2 dice que el error
-   * **reemplaza** la ayuda, de modo que el id no puede apuntar a un nodo
-   * que ya no está en el DOM.
-   */
-  readonly helpId: import("@angular/core").Signal<string | null>;
-  readonly errorId: import("@angular/core").Signal<string | null>;
-  readonly describedBy: import("@angular/core").Signal<string | null>;
-  /** Mismo criterio que `errorMessage()` — el estado del control no es público. */
-  readonly invalid: import("@angular/core").Signal<boolean>;
-  readonly required: import("@angular/core").Signal<boolean>;
-  private readonly schema;
-  /**
-   * Se decide una vez por recurso y se aplica a todos los niveles: es un
-   * juicio de diseño sobre el formulario, no sobre un campo suelto. Contado
-   * por nivel (sólo top-level) — un conteo plano mezcla los subcampos de
-   * `group`/`list` y da ratios imposibles.
-   */
-  protected readonly markOptionals: import("@angular/core").Signal<boolean>;
-  protected readonly showRequiredMark: import("@angular/core").Signal<boolean | undefined>;
-  protected readonly showOptionalMark: import("@angular/core").Signal<boolean>;
-  get tree(): RootTree;
-  get serverErrors(): Record<string, string>;
-  get pathPrefix(): string;
-  get exists(): boolean;
-  get resource(): string;
-  static ɵfac: i0.ɵɵFactoryDeclaration<RenderHost, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<RenderHost, "app-render-host", never, {
-    "kind": {
-      "alias": "kind";
-      "required": false;
-      "isSignal": true;
-    };
-    "type": {
-      "alias": "type";
-      "required": true;
-      "isSignal": true;
-    };
-    "config": {
-      "alias": "config";
-      "required": true;
-      "isSignal": true;
-    };
-    "ctx": {
-      "alias": "ctx";
-      "required": false;
-      "isSignal": true;
-    };
-    "data": {
-      "alias": "data";
-      "required": false;
-      "isSignal": true;
-    };
-    "mode": {
-      "alias": "mode";
-      "required": false;
-      "isSignal": true;
-    };
-    "value": {
-      "alias": "value";
-      "required": false;
-      "isSignal": true;
-    };
-    "chip": {
-      "alias": "chip";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {}, never, never, true, never>;
-}
-/**
- * Entrada estable de los formularios (base.md §5).
- *
- * **R3.5 · ya no despacha.** Este host redujo sus 493 líneas —el `@switch`
- * de 20 ramas, los 21 imports a mano y el envoltorio de label/errores— a un
- * adaptador que traduce su API histórica (`field` + `tree` + `pathPrefix` …)
- * al `RenderContext` que espera `<app-render-host>`, el motor único de
- * render (F1 · `refactormotor.md`).
- *
- * El rótulo, las marcas required/opcional, el error, la ayuda,
- * `FIELD_ARIA` y la **recursión de `group`/`list`** (los `ng-template` con
- * `ngTemplateOutlet` y `ListChildContext`) viven ahora en `RenderHost`, que
- * se auto-importa para instanciar sus propios hijos.
- *
- * Rutas del backend: `pathPrefix` encadena el prefijo del contenedor
- * (`address.`, `faq[2].`) y `serverErrors` lleva el mapa completo; el error
- * propio de este campo se resuelve como `serverErrors[prefix + key]`.
- */
-export declare class FieldHost {
-  readonly field: import("@angular/core").InputSignal<FieldSchema>;
-  readonly tree: import("@angular/core").InputSignal<RootTree>;
-  readonly exists: import("@angular/core").InputSignal<boolean>;
-  readonly serverErrors: import("@angular/core").InputSignal<Record<string, string>>;
-  readonly pathPrefix: import("@angular/core").InputSignal<string>;
-  readonly resource: import("@angular/core").InputSignal<string>;
-  protected readonly ctx: import("@angular/core").Signal<RenderContext>;
-  static ɵfac: i0.ɵɵFactoryDeclaration<FieldHost, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<FieldHost, "app-field-host", never, {
-    "field": {
-      "alias": "field";
-      "required": true;
-      "isSignal": true;
-    };
-    "tree": {
-      "alias": "tree";
-      "required": true;
-      "isSignal": true;
-    };
-    "exists": {
-      "alias": "exists";
-      "required": false;
-      "isSignal": true;
-    };
-    "serverErrors": {
-      "alias": "serverErrors";
-      "required": false;
-      "isSignal": true;
-    };
-    "pathPrefix": {
-      "alias": "pathPrefix";
-      "required": false;
-      "isSignal": true;
-    };
-    "resource": {
-      "alias": "resource";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {}, never, never, true, never>;
-}
-/**
- * Opciones del diálogo. Es estructuralmente compatible con
- * `core.NotificationService['confirmation']` (mismos campos) — `shared` no
- * importa `core`, quien une ambos lados es el shell (Fase 7).
- */
-interface ConfirmDialogOptions {
-  title: string;
-  message: string;
-  confirmLabel?: string;
-  cancelLabel?: string;
-}
-export declare class ConfirmDialog {
-  /** `null` = oculto (viene de `NotificationService.confirmation`). */
-  readonly options: import("@angular/core").InputSignal<ConfirmDialogOptions | null>;
-  readonly danger: import("@angular/core").InputSignal<boolean>;
-  readonly confirmed: import("@angular/core").OutputEmitterRef<void>;
-  readonly cancelled: import("@angular/core").OutputEmitterRef<void>;
-  static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialog, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmDialog, "app-confirm-dialog", never, {
-    "options": {
-      "alias": "options";
-      "required": false;
-      "isSignal": true;
-    };
-    "danger": {
-      "alias": "danger";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {
-    "confirmed": "confirmed";
-    "cancelled": "cancelled";
-  }, never, never, true, never>;
-}
-type ToastKind = 'success' | 'error' | 'info';
-/** Estructuralmente idéntico a `core`'s `Toast` — no importa `core`. */
-interface ToastItem {
-  id: number;
-  kind: ToastKind;
-  message: string;
-}
-/**
- * Contenedor visual de toasts: fijo arriba a la derecha, región `status`
- * viva (polite) para que se anuncien los mensajes. Recibe los toasts por
- * `input()` desde quien sí tiene `NotificationService` (Fase 7).
- */
-export declare class Toast {
-  readonly toasts: import("@angular/core").InputSignal<ToastItem[]>;
-  readonly closeLabel: import("@angular/core").InputSignal<string>;
-  readonly dismissed: import("@angular/core").OutputEmitterRef<number>;
-  static ɵfac: i0.ɵɵFactoryDeclaration<Toast, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<Toast, "app-toast", never, {
-    "toasts": {
-      "alias": "toasts";
-      "required": false;
-      "isSignal": true;
-    };
-    "closeLabel": {
-      "alias": "closeLabel";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {
-    "dismissed": "dismissed";
-  }, never, never, true, never>;
-}
-/**
- * Tripwire de compilación (R1.7 · D17): que la unión `FieldType` y los
- * tipos que la UI sabe dibujar sigan diciendo lo mismo.
- *
- *   · un valor que no esté en la unión `FieldSchema` ⇒ `satisfies` falla;
- *   · un tipo de la unión que falte acá ⇒ `FaltaEnLaUi` no es `never`.
- *
- * **No es una fuente de verdad en runtime.** El catálogo vive en
- * `core/registry/render-registry.ts`, alimentado por los descriptores de
- * abajo. Esta lista sólo existe para que `npm run build` y `npm test` vean
- * la aserción por igual, sin depender de que un test la ejecute.
- *
- * **Exportada en R3.7** para que `core/registry/contract.spec.ts` pueda
- * verificar además el sentido que este archivo no cubre — que cada nombre de
- * la lista tenga **descriptor**: aquí sólo se comprueba que está en la unión,
- * y un tipo declarado en la lista pero ausente del manifiesto se vería en el
- * primer schema que lo use.
- *
- * **Mudado acá en R3.8.** Vivía en `field-host/field-host.ts`, y §0 es
- * explícito: «si añadir un tipo obliga a editar `FieldHost`, el motor no
- * está terminado». Estaba sin uso en runtime — sólo servía a este tripwire —
- * así que trasladarlo acá no cambia comportamiento y deja el registro y su
- * aserción en el **mismo archivo**: añadir un tipo toca una carpeta y una
- * línea de este manifiesto, y el host no se entera.
- */
-export declare const SUPPORTED_FIELD_TYPE_LIST: readonly ["text", "textarea", "slug", "number", "currency", "boolean", "select", "multiselect", "url", "email", "phone", "date", "time", "readonly-text", "group", "list", "string-list", "key-value", "relation", "image", "file", "color", "rich-select", "dropdown"];
-/**
- * Manifiesto de descriptores de campo (R3.3 · registro único de render).
- *
- * Una línea por tipo: el registro los recoge al importar este módulo. Es la
- * **única** lista manual del catálogo de campos — `import.meta.glob` no
- * sobrevive a `ng build`, así que D9-1 se resuelve con «registro manual de
- * una línea». Ver `core/registry/render-registry.ts`.
- *
- * Añadir un tipo de campo ⇒ crear la carpeta + su `.descriptor.ts` + una
- * línea acá. **Ningún host se toca** (R3.8).
- */
-export declare const fieldDescriptors: readonly RenderDescriptor[];
-/** Los 7 formatos del `@switch` que este registro reemplaza (R4.3). */
-export declare const columnFormatDescriptors: readonly RenderDescriptor[];
-/**
- * Los 7 nombres, como dato.
- *
- * Va en paralelo a `ListColumnFormat` (unión de `schema.model`) y lo vigila
- * `core/registry/contract.spec.ts`: la unión vive en tipos y el registro en
- * runtime, y sólo un test reconcilia los dos — el mismo tripwire que ya
- * existe para los 20 campos y los 6 widgets.
- */
-export declare const COLUMN_FORMAT_TYPES: readonly ["text", "badge", "thumbnail", "boolean", "number", "currency", "date"];
-/**
- * Descripciones centralizadas del catálogo de campos del motor `@tinya-code/gas-admin-ui`.
- *
- * Este archivo es el único lugar donde se editan los textos descriptivos de
- * cada propiedad del schema. Los JSDoc de `schema.model.ts` usan estos mismos
- * textos para que el editor (VSCode) muestre tooltips al pasar el cursor
- * sobre una propiedad del schema del consumidor.
- *
- * Estructura: clave de propiedad → descripción en español.
- *
- * Uso en el consumidor (loyalty-admin, etc.):
- *   import { schemaDescriptions } from '@tinya-code/gas-admin-ui';
- *   schemaDescriptions['docLink']; // 'URL de documentación externa para este campo.'
- *
- * Nota: este objeto no se renderiza en la UI; solo existe para documentación
- * y tooltips del editor. Para renderizar tooltips en el formulario usa
- * `description` en cada campo del schema del consumidor.
- */
-export declare const schemaDescriptions: {
-  readonly key: "Nombre de la propiedad en el JSON que envía/recibe el back.";
-  readonly label: "Rótulo visible para el usuario en el formulario y la ficha.";
-  readonly help: "Texto corto de ayuda que se muestra debajo del campo.";
-  readonly placeholder: "Texto sugerente que se muestra dentro del input cuando está vacío.";
-  readonly required: "Si es obligatorio. El back también lo valida (R7.4).";
-  readonly default: "Valor por defecto si el registro no trae este campo (ej. `default: \"none\"` en un `select`/`dropdown`).";
-  readonly readonly: "Si el campo es solo lectura (no editable en el formulario).";
-  readonly readonlyOn: "Bloquea el campo solo en creación, solo en edición o siempre.";
-  readonly readonlyWhen: "Condición bajo la cual el campo es solo lectura (expresión sobre otros campos).";
-  readonly visibleWhen: "Condición bajo la cual el campo se muestra u oculta.";
-  readonly hiddenOn: "Oculta el campo en creación, en edición o siempre.";
-  readonly dependsOn: "Selección dependiente (guía §1: país → ciudad). Clave del campo padre del mismo nivel.";
-  readonly validators: "Reglas de validación (mínimo, máximo, patrón, unicidad, etc.).";
-  readonly width: "Ancho en la grilla del formulario (1–12), igual que un widget del dashboard.";
-  readonly section: "Id de la sección/pestaña del layout a la que pertenece (base.md §4).";
-  readonly read: "Código de nivel de acceso requerido para leer el campo.";
-  readonly write: "Código de nivel de acceso requerido para escribir el campo.";
-  readonly description: "Descripción corta de para qué sirve este campo. Se muestra como tooltip al pasar el cursor sobre el rótulo.";
-  readonly docLink: "URL de documentación externa para este campo (se abre al hacer clic en el tooltip).";
-  readonly value: "Valor que se envía al back cuando se elige esta opción.";
-  readonly labelOption: "Texto visible de la opción.";
-  readonly disabled: "Si la opción está deshabilitada (no se puede elegir).";
-  readonly type: "Tipo de campo: `text`, `color`, `number`, `currency`, `boolean`, `select`, `dropdown`, `rich-select`, `multiselect`, `url`, `email`, `phone`, `date`, `time`, `readonly-text`, `slug`, `textarea`, `relation`, `image`, `file`, `group`, `list`, `string-list`, `key-value`.";
-  readonly maxLength: "Longitud máxima de caracteres permitida.";
-  readonly pattern: "Expresión regular que debe cumplir el valor.";
-  readonly rows: "Número de filas visibles del textarea.";
-  readonly minWords: "Cantidad mínima de palabras.";
-  readonly maxWords: "Cantidad máxima de palabras.";
-  readonly tokens: "Marcadores insertables como chips bajo el área (plantillas de mensaje).";
-  readonly from: "Campo del registro del que se autogenera el slug.";
-  readonly lockAfterCreate: "Bloquea el campo una vez creado el registro (por defecto: sí).";
-  readonly min: "Valor mínimo permitido.";
-  readonly max: "Valor máximo permitido.";
-  readonly step: "Incremento entre valores permitidos.";
-  readonly decimals: "Número de decimales mostrados.";
-  readonly currencyFrom: "Campo del registro del que se toma la moneda (ej. `currency`).";
-  readonly trueLabel: "Texto que se muestra cuando el valor es verdadero.";
-  readonly falseLabel: "Texto que se muestra cuando el valor es falso.";
-  readonly source: "De dónde salen las opciones: `{ resource, view?, params?, … }` (F8 · R6.5).";
-  readonly resource: "Recurso declarado (`resource.id`): su listado es el de las opciones.";
-  readonly view: "Vista declarada en `resource.views` (opcional): filtra en el back.";
-  readonly params: "Valores interpolados para la vista (`{campo}` ← contexto).";
-  readonly labelField: "Etiqueta por defecto de las filas (si no, `titleField` del recurso).";
-  readonly valueField: "Valor por defecto de las filas (si no, `keyField` del recurso).";
-  readonly secondaryField: "Segundo dato a mostrar junto a la etiqueta (ej. \"Juan Pérez · DNI 123\").";
-  readonly onlyActive: "Cargar solo registros activos (lo exige además la FK en el back).";
-  readonly accept: "Tipos aceptados (ej. `image/*`, `image/png,image/jpeg` o `pdf,docx`).";
-  readonly maxSizeMB: "Tamaño máximo del archivo en megabytes.";
-  readonly aspectRatio: "Relación de aspecto de la vista previa (ej. `16/9`).";
-  readonly previewSize: "Tamaño de la vista previa.";
-  readonly formatCurrency: "Campo del registro del que se toma la moneda (ej. `currency`).";
-  readonly display: "Presentación del grupo: `card`, `collapsible` o `inline`.";
-  readonly fields: "Campos de cada item (cualquier tipo, incluso `group` o `list`).";
-  readonly minItems: "Cantidad mínima de items.";
-  readonly maxItems: "Cantidad máxima de items.";
-  readonly sortable: "Si se puede reordenar (por defecto: sí).";
-  readonly positionField: "Campo donde se guarda el orden dentro de cada item (`position`).";
-  readonly addLabel: "Etiqueta del botón para agregar un item nuevo.";
-  readonly emptyText: "Texto que se muestra cuando no hay items.";
-  readonly itemDisplay: "Cómo se muestra cada item: `card`, `row` o `accordion`.";
-  readonly itemFields: "Campos de cada item (cualquier tipo, incluso `group` o `list`).";
-  readonly itemTitle: "Campo del item usado como título cuando está colapsado.";
-  readonly primaryFirst: "El primer item tiene significado especial (ej. imagen principal).";
-  readonly itemType: "Tipo permitido de cada item (base.md §9: solo `text`, `url` o `email`).";
-  readonly sort: "Si la lista se ordena alfabéticamente o por posición.";
-  readonly filter: "Si el listado permite filtrado por texto.";
-  readonly search: "Campos buscables en el listado.";
-  readonly filters: "Filtros declarados para el listado.";
-  readonly listColumns: "Columnas que se muestran en el listado.";
-  readonly searchable: "Si el campo es buscable.";
-  readonly filterable: "Si el campo es filtrable.";
-  readonly sortableItems: "Si los items de la lista se pueden reordenar.";
-  readonly groupBy: "Campo por el que agrupar los items.";
-  readonly cardWidth: "Ancho de cada tarjeta de opción en la grilla (1–12). Por defecto `4` (3 tarjetas por fila en escritorio).";
-  readonly cardCols: "Cuántas tarjetas mostrar por fila en el punto de ruptura `lg`. Sobrescribe el cálculo automático basado en `cardWidth`.";
-  readonly hintMetric: "Texto secundario bajo la cifra (estático, va en el schema).";
-  readonly unitChart: "Sufijo de las cifras del eje («unidades», «S/»).";
-  readonly segments: "Segmentos de la barra de distribución porcentual.";
-  readonly actions: "Acciones de navegación por fila.";
-  readonly labelAction: "Etiqueta de la acción.";
-  readonly icon: "Icono de la acción.";
-  readonly navigateTo: "Ruta de destino de la acción.";
-  readonly variant: "Variante visual: `primary`, `secondary` u `outline`.";
-  readonly widgets: "Widgets del panel. Se declara en `ResourceSchema.widgets` — no en `fields`, porque un KPI no es un campo.";
-  readonly mobileWidth: "Ancho en la grilla en mobile (1–12). Por defecto `12` (ancho completo, apilado).";
-  readonly sourceWidget: "De dónde saca sus datos: `DataSource` o `{ kind: \"payload\" }`.";
-  readonly hintWidget: "Texto secundario bajo la cifra (estático, va en el schema).";
-  readonly unitWidget: "Sufijo de las cifras del eje.";
-};
-export type SchemaDescriptionKey = keyof typeof schemaDescriptions;
-export declare const layoutDescriptors: readonly LayoutDescriptor[];
-export declare const viewDescriptors: readonly RenderDescriptor[];
-/**
- * Validador de composición de vistas (R9.9.2 · D2/D3).
- *
- * Una composición (un `uiView` contenedor con `config.children`, p. ej.
- * `tabs`) se valida ANTES del render con esta única función pura y síncrona:
- *
- *  - identidad de hijos (`id` presente y único entre hermanos);
- *  - tipos resueltos con `get('view', type)` — **nunca** `resolve()`, cuyo
- *    `fallback` silencioso dejaría un hijo inválido pintándose de todos modos;
- *  - `ref` rotos y ciclos (directos o transitivos) que los `ref` permiten;
- *  - profundidad y cantidad de nodos con topes configurables;
- *  - destinos de navegación (`resource` + `view` + params) y fuentes de
- *    filas — una URL cruda nunca es un destino válido;
- *
- * El llamante es D3: `resourceRoutes()` en `shell.routes.ts` (fail-loud al
- * arrancar) y el guardián de montaje del composer. Cualquier violación lanza
- * `SchemaCompositionError` con un mensaje legible que nombra recurso,
- * contenedor e hijo: nada se oculta ni se sustituye en silencio.
- *
- * El tipo de una `uiView` RAÍZ no se chequea acá: eso ya lo hace
- * `resourceRoutes()` con su error genérico de descriptor inexistente. Este
- * validador cubre lo que ese recorrido no ve: la estructura de los hijos.
- */
-/** Profundidad máxima de anidamiento de contenedores (hijos raíz = 1). */
-export declare const MAX_DEPTH = 3;
-/** Cantidad máxima de nodos-hijo declarados en la composición de un schema. */
-declare const MAX_NODES = 50;
-/** Violación del contrato de composición, detectada antes del render. */
-export declare class SchemaCompositionError extends Error {
-  constructor(message: string);
-}
-/**
- * Valida TODA la composición de un schema. Lanza `SchemaCompositionError`
- * en la primera violación; no lanzar significa «apto para renderizar».
- */
-export declare function validateComposition(schema: ResourceSchema): void;
-/** Ruta de un campo en el árbol de Signal Forms. Los casts viven acá. */
-type FieldPath<V> = SchemaPath<V, SchemaPathRules.Supported, PathKind.Child>;
-/**
- * Vocabulario compartido con el back (`VALIDATORS_` en 23-validate.js).
- *
- * El orden es el de registro de `FIELD_VALIDATORS`, que fija el orden de los
- * errores en `field.errors()`: el primero es el que pinta el campo.
- */
-type ValidatorName = 'required' | 'email' | 'url' | 'min-length' | 'max-length' | 'pattern' | 'min-words' | 'max-words' | 'min' | 'max' | 'min-items' | 'max-items' | 'date-min' | 'date-max' | 'unique';
-/** Todo lo que un validador necesita para decidir y para registrarse. */
-interface ValidatorContext {
-  path: FieldPath<unknown>;
-  field: FieldSchema;
-  schema: ResourceSchema;
-  api: ApiService;
-  excludeKey: string | undefined;
-}
-interface ValidatorEntry {
-  readonly name: ValidatorName;
-  /** ¿Este campo declara este validador? (tipo + props del schema) */
-  readonly declares: (ctx: ValidatorContext) => boolean;
-  /** Ata la regla de Signal Forms a `ctx.path`. */
-  readonly register: (ctx: ValidatorContext) => void;
-}
-/** Formato de URL para una ruta cualquiera (`string-list`, ítems de list). */
-declare function registerUrlRule(path: FieldPath<unknown>): void;
-/** Formato de correo para una ruta cualquiera (`string-list`, ítems de list). */
-declare function registerEmailRule(path: FieldPath<unknown>): void;
-declare const FIELD_VALIDATORS: readonly ValidatorEntry[];
-/** Nombres del registro: lo que `contract-check.mjs` compara con el back. */
-declare const VALIDATOR_NAMES: readonly ValidatorName[];
-/**
- * Resuelve una plantilla de texto reemplazando marcadores `{key}` o `{nested.key}`
- * con los valores presentes en el objeto `data` o en el contexto adicional `extraContext`.
- *
- * Si un valor es `null` o `undefined`, se reemplaza por una cadena vacía.
- * No arroja excepciones ante claves no encontradas ni ante objetos nulos.
- */
-export declare function interpolateTemplate(template: string, data?: Record<string, unknown>, extraContext?: Record<string, unknown>): string;
-interface ParsedRoute {
-  path: string;
-  queryParams: Record<string, string>;
-}
-/**
- * Descompone una ruta relativa o absoluta en path y queryParams para routerLink.
- */
-declare function parseNavigationUrl(url: string): ParsedRoute;
-/**
- * Descriptores de las tres acciones que hoy declara el modelo
- * (R3.10 · `doc/plan-refactor-motor.md` §3.2).
- *
- * Éste es el fichero que **cierra la triplicación de `copy-share`**: la
- * resolución de enlace y de mensaje vivía en `list-view.runAction`,
- * `detail-view.resolveUrl/resolveShareText` y
- * `post-create-modal.resolvedShareUrl/resolvedShareText`. Aquí se resuelve
- * una sola vez (`resolveShare`) y las vistas consumen ese resultado en R3.11.
- *
- * Se registra al importar, desde `action-registry.ts`, con el mismo criterio
- * que el registro de render: sin esperar a DI, porque el registro es la única
- * fuente de verdad en runtime.
- */
-/** Enlace y mensaje ya interpolados, listos para copiar o compartir. */
-interface ResolvedShare {
-  url: string;
-  shareText: string;
-}
-/**
- * `true` cuando la acción es de las que las vistas presentan como botón de
- * compartir (`detail-view`, `post-create-modal`).
- *
- * Vive acá y no en la vista porque es **el único sitio donde se puede nombrar
- * `'copy-share'`**: fuera de `descriptors.ts` ninguna vista decide por tipo
- * (criterio de R3.11).
- */
-export declare function isShareAction(action: ResourceAction): action is CopyShareAction;
-/**
- * `true` cuando la acción es un `trigger` (acción de dominio del back).
- *
- * Mismo criterio que `isShareAction`: el único sitio que nombra el tipo,
- * para que las vistas no decidan por string literal (R3.11). `detail-view`
- * lo usa en R8.8 para renderizar «Regenerar PIN» junto a los botones de
- * compartir.
- */
-export declare function isTriggerAction(action: ResourceAction): action is TriggerAction;
-/**
- * Resuelve `urlTemplate` y el mensaje de compartir contra `vars`
- * (config global + registro).
- *
- * **Única implementación** de esta lógica en el admin. El fallback a
- * `share_message_template` (la plantilla que declara el singleton de
- * configuración) lo aplican los tres puntos por igual: hasta ahora la fila
- * del listado no lo honraba y se quedaba sin saludo.
- */
-export declare function resolveShare(action: CopyShareAction, vars: Record<string, unknown>): ResolvedShare;
-/** Catálogo — una línea por acción, en el orden en que se registran. */
-declare const actionDescriptors: readonly ActionDescriptor[];
-/**
- * Registro único de acciones (R3.9 · `refactormotor.md`).
- *
- * Es el gemelo del registro de render (`core/registry/render-registry.ts`):
- * en lugar de «qué componente pinta un tipo de campo», responde «qué
- * comportamiento ejecuta un tipo de acción» y permite **migrar el dispatch
- * if/copiado-pegado de las vistas (R3.11) a datos + un solo `run`**.
- *
- * Como los descriptores son objetos planos de módulo (no los inyecta Angular),
- * todo lo que necesiten llegar por el `ActionContext`: los puertos (`api`,
- * `router`, `toast`) y los datos (`record`, `resource`, `vars`).
- */
-/** Superficies donde una acción puede aparecer. */
-export type ActionSurface = 'row' | 'detail' | 'header' | 'bulk' | 'post-create';
-/**
- * Lo que aporta el llamador al ejecutar una acción: el registro sobre el que
- * corre y los puertos que el descriptor usará para actuar.
- *
- * `record` es `null` en las superficies sin fila (`header`, `bulk`), para que
- * un descriptor pueda distinguir «sin registro» de «registro vacío».
- */
-export interface ActionRequest {
-  record: Record<string, unknown> | null;
-  /** Id del recurso (schema) dueño de la acción. */
-  resource: string;
-  api: ApiService;
-  router: Router;
-  toast: NotificationService;
-  user: SessionUser | null;
-  /**
-   * `keyField` del schema. **R3.12 (desviación nº 3 del contrato):** con
-   * `record` forma la clave que necesita la ruta lógica de `trigger`
-   * (`/admin/<recurso>/<key>/actions/<name>`). Lo aporta la vista, que es
-   * quien tiene el schema.
-   */
-  keyField: string;
-}
-/**
- * Contexto que recibe el descriptor: la petición del llamador más el contexto
- * de interpolación ya resuelto. `ActionService.run` lo arma, así que ninguna
- * vista repite `buildInterpolationContext(record)`.
- */
-export interface ActionContext extends ActionRequest {
-  /** `{...configGlobal, ...record, public_base_url}` — listo para las plantillas. */
-  vars: Record<string, unknown>;
-}
-/** Resultado que la vista puede leer para saber si debe recargar. */
-export interface ActionResult {
-  /** `false` cuando la acción no llegó a ejecutarse; el error ya se notificó. */
-  ok: boolean;
-  /** `true` cuando tocó datos y la vista debe recargar su listado/detalle. */
-  reload?: boolean;
-}
-export interface ActionDescriptor {
-  /** Clave del dispatch: el `type` del schema (`'navigate'` no lo declara). */
-  type: string;
-  /** Superficies donde esta acción puede aparecer. */
-  surfaces: ActionSurface[];
-  run: (ctx: ActionContext, action: ResourceAction) => Promise<ActionResult>;
-  /** `true` si el descriptor exige confirmación antes de ejecutar. */
-  confirm?: boolean;
-  /**
-   * Icono lucide que representa la acción donde el espacio es reducido
-   * (la fila del listado). Sin él, la vista muestra `action.label`.
-   */
-  icon?: LucideIcon;
-}
-/** Registra (o reemplaza) un descriptor de acción. */
-export declare function registerAction(descriptor: ActionDescriptor): void;
-export declare function getAction(type: string): ActionDescriptor | undefined;
-/** Descriptores disponibles en una superficie. */
-export declare function actionsFor(surface: ActionSurface): ActionDescriptor[];
-/**
- * Clave de dispatch de una acción. `NavigateAction.type` es **opcional**
- * (schema.model.ts), así que una acción sin `type` es una navegación.
- */
-export declare function actionType(action: ResourceAction): string;
-/** Tipos registrados. Sólo para comprobaciones y tests. */
-export declare function actionTypes(): string[];
-export { type ComponentRenderKind, type FirebaseAuthAdapter, type GasAdminConfig, type RenderKind, type ResolvedShare, type ValidatorName, type ValueSources, get as getRenderDescriptor, isSupported as isRenderSupported, register as registerRenderDescriptor, unregister as unregisterRenderDescriptor };