@tinya-code/gas-admin-ui 0.0.0-stage → 0.1.0-alpha.2

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

@@ -0,0 +1,3099 @@
+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 { HttpEvent, HttpInterceptorFn } 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. */
+  key: string;
+  label: string;
+  help?: string;
+  placeholder?: string;
+  required?: boolean;
+  default?: T;
+  readonly?: boolean;
+  /** Ciclo de vida: bloquea el campo solo en creación, solo en edición o siempre. */
+  readonlyOn?: 'create' | 'update' | 'always';
+  readonlyWhen?: FieldCondition;
+  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;
+  validators?: FieldValidators;
+  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?: {
+    read?: string;
+    write?: string;
+  };
+}
+export interface SelectOption {
+  value: string;
+  label: string;
+  disabled?: boolean;
+}
+export interface TextField extends FieldBase<string> {
+  type: 'text';
+  maxLength?: number;
+  pattern?: string;
+}
+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;
+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;
+  /**
+   * 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 | UrlField | EmailField | PhoneField | DateField | TimeField | ReadonlyTextField | RelationField | ImageField | FileField | GroupField | ListField | StringListField | KeyValueField;
+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).
+ * Pueden incluir el marcador `{key}`. Los singleton solo usan
+ * `get` / `update`.
+ */
+export interface ResourceEndpoints {
+  list?: string;
+  get?: string;
+  create?: string;
+  update?: string;
+  remove?: string;
+}
+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;
+  /** 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;
+}
+/**
+ * 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. §9.1 eligió B: **sólo `password`**. */
+  providers: string[];
+  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;
+}
+/** 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;
+}
+/**
+ * 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)[];
+/**
+ * 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;
+/**
+ * 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>;
+/**
+ * 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 error: import("@angular/core").WritableSignal<string | null>;
+  readonly loading: import("@angular/core").WritableSignal<boolean>;
+  /** 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;
+  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';
+/**
+ * CRUD genérico sobre el contrato v2 (baseapi §2.3): TODA llamada a la API
+ * es un `POST` a `API_URL` con cuerpo `text/plain` y el JSON
+ * `{ token, method, path, payload }`. `method: 'GET'` también para lecturas;
+ * el token viaja en el cuerpo (nunca en cabeceras: criterio 11 de §17).
+ *
+ * `text/plain` en lugar de `application/json` evita el preflight CORS
+ * (simple request) — criterio 11: sin cabeceras custom.
+ *
+ * **R2.8 — convención sobre el snippet.** `auth.md` §5.2 llama a las claves
+ * `{ route, op, token, payload }`, pero el backend (`parseEnvelope_`) lee
+ * `path` y `method`: el snippet es un esquema a medias, no un contrato.
+ * Mismo precedente que en R2.5 — **la convención del código gana**. Cambiar
+ * el nombre ahora rompería el único transporte que existe.
+ *
+ * **R2.12 — el token sale de `AuthService`, no de configuración.** El
+ * `ADMIN_TOKEN` (D21-C) se retiró: no hay credencial fija, hay sesión.
+ *
+ * Devuelve el JSON plano tal cual, sin transformaciones ocultas
+ * (base.md §1, principio 4). Los errores del backend (200 + `{ error: {…} }`)
+ * los convierte en `ApiError` el interceptor `apiErrorInterceptor`, que es
+ * también quien pasa los `AUTH_*` a `AuthService.applyAuthCode` (R2.9).
+ */
+export declare class ApiService {
+  private readonly http;
+  private readonly apiUrl;
+  private readonly auth;
+  /**
+   * 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[]>;
+  /** `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>;
+  private send;
+  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;
+  /**
+   * 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>;
+  /**
+   * 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>;
+  /** Revoca las sesiones del usuario en todos sus dispositivos. */
+  logoutAll(): Observable<{
+    effectiveWithinSeconds: number;
+  }>;
+  /** 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 envelope;
+  /**
+   * Mismo transporte que `ApiService` (R2.8): cuerpo JSON con
+   * `Content-Type: text/plain` ⇒ **simple request**, sin preflight CORS.
+   * Los tres endpoints de sesión pasan por acá — si alguno se saltara el
+   * header, el navegador añadiría `application/json` y la llamada empezaría
+   * a pedir permiso al servidor con un OPTIONS.
+   */
+  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 closingAllSessions: 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[]>;
+  closeAllSessions(): 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"];
+/**
+ * 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"];
+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 GasAdminConfig, type RenderKind, type ResolvedShare, type ValidatorName, get as getRenderDescriptor, isSupported as isRenderSupported, register as registerRenderDescriptor, unregister as unregisterRenderDescriptor };