@stapel/forms-react 0.1.0

package/src/headless/ResponsesTable.tsx

@@ -0,0 +1,341 @@
+import { useCallback, useMemo, useState } from "react";
+import type { ReactNode } from "react";
+import {
+  actionAvailable,
+  actionBlocked,
+  bothLoaded,
+  isStapelApiError,
+  loadStateFromQuery,
+  mapLoad,
+  requireLoaded,
+} from "@stapel/core";
+import type {
+  ActionAvailability,
+  LoadState,
+  StapelApiError,
+} from "@stapel/core";
+import type {
+  FormFieldDef,
+  FormVersion,
+  Submission,
+} from "../api/types.js";
+import { useFormVersions, useSubmissions } from "../model/queries.js";
+import {
+  useCsvExport,
+  useDeleteSubmission,
+  useResendSubmission,
+} from "../model/mutations.js";
+import type { ResendRequest } from "../api/types.js";
+import { FORMS_I18N_KEYS } from "../i18n/keys.js";
+
+/** Default page size for the keyset list. */
+const DEFAULT_LIMIT = 50;
+
+/** One column of the responses grid — a field of the version being reviewed. */
+export interface ResponseColumn {
+  readonly slug: string;
+  /** The admin-authored label, or the slug when the field was never named. */
+  readonly title: string;
+  readonly kind: string;
+}
+
+/** The rows and the columns that describe them, loaded together. */
+export interface ResponsesView {
+  readonly rows: readonly Submission[];
+  /**
+   * Columns for the CURRENT version filter. Per-version column sets are what
+   * the version FK buys: a submission records which schema it answered, so
+   * reviewing an old response shows the questions that were actually asked,
+   * not today's.
+   *
+   * With no version filter this is the union of every version's fields, in
+   * newest-version-first order — the honest superset, because rows from
+   * different versions genuinely have different keys.
+   */
+  readonly columns: readonly ResponseColumn[];
+}
+
+/** The bag `<ResponsesTable>` hands its render prop (spec §8.2). */
+export interface ResponsesTableBag {
+  readonly state: LoadState<ResponsesView>;
+  /** Every published version, for the filter control. */
+  readonly versions: LoadState<readonly FormVersion[]>;
+  /** The active version filter, or `null` for "all versions". */
+  readonly version: number | null;
+  setVersion(version: number | null): void;
+
+  /** Go to the next keyset page. Blocked with a reason at the end of the
+   * list, while loading, and when the load failed. */
+  readonly nextPage: ActionAvailability;
+  goNextPage(): void;
+  /** Go back one page. Blocked with a reason on the first page. */
+  readonly prevPage: ActionAvailability;
+  goPrevPage(): void;
+  /** 0-based index of the page on screen. */
+  readonly pageIndex: number;
+
+  /** The row opened in a detail drawer, or `null`. */
+  readonly selected: Submission | null;
+  select(submission: Submission | null): void;
+
+  /** `forms.responses.manage`. */
+  remove(submissionId: string): void;
+  readonly isRemoving: boolean;
+  /**
+   * Re-deliver one response. An `override` REPLACES the form's configured
+   * targets rather than adding to them (backend delta note 7).
+   */
+  resend(submissionId: string, override?: ResendRequest): void;
+  readonly isResending: boolean;
+  /** How many deliveries the last resend reported, or `null`. */
+  readonly lastResendCount: number | null;
+
+  /** Drive the CSV export to completion; resolves to the whole file's text. */
+  exportCsv(): Promise<string>;
+  readonly isExporting: boolean;
+  readonly exportPages: number;
+
+  /** The last mutation refusal (delete / resend / export). */
+  readonly error: StapelApiError | null;
+  refetch(): void;
+}
+
+/**
+ * A caught value → the API dialect, or `null`.
+ *
+ * `caught as StapelApiError` is a lie for a network fault (no `.code`, no
+ * `.status`), and `stapel/no-raw-error-shape` is right to refuse it. A bag
+ * that reports `error: null` for a fault it cannot describe is honest; the
+ * mutation's own `isError` still says something went wrong.
+ */
+function asApiError(caught: unknown): StapelApiError | null {
+  return isStapelApiError(caught) ? caught : null;
+}
+
+function columnsOf(fields: readonly FormFieldDef[]): ResponseColumn[] {
+  return fields
+    // A header is a caption, not a question: it has no answer, so it is not a
+    // column. (The engine regenerates its DAO from config and rejects an
+    // answer to one, so a header column would always be empty.)
+    .filter((field) => field.kind !== "header")
+    .map((field) => ({
+      slug: field.slug,
+      title:
+        typeof field.name === "string" && field.name.length > 0
+          ? field.name
+          : field.slug,
+      kind: field.kind,
+    }));
+}
+
+/**
+ * Headless response review — keyset paging, per-version columns, detail
+ * selection, delete, resend and CSV export, renderless.
+ *
+ * Live-updating counts are refetch-only by design: a `forms:ws:<workspace_id>`
+ * Signal stream is RESERVED naming for when the stapel-realtime substrate
+ * lands (spec §8.2), and forms does not build a socket of its own — that is a
+ * lint boundary, not an omission.
+ */
+export function ResponsesTable(props: {
+  workspaceId: string;
+  formId: string;
+  /** Rows per page. Default 50. */
+  limit?: number;
+  children: (bag: ResponsesTableBag) => ReactNode;
+}): ReactNode {
+  const limit = props.limit ?? DEFAULT_LIMIT;
+  const [version, setVersionState] = useState<number | null>(null);
+  // The keyset trail: one cursor per page boundary crossed. Index 0 is the
+  // first page (no cursor). Keeping the whole trail — rather than one
+  // "current" cursor — is what makes "previous" possible at all: a keyset
+  // cursor only ever walks forward.
+  const [trail, setTrail] = useState<readonly (string | undefined)[]>([
+    undefined,
+  ]);
+  const [pageIndex, setPageIndex] = useState(0);
+  const [selected, setSelected] = useState<Submission | null>(null);
+  const [error, setError] = useState<StapelApiError | null>(null);
+  const [lastResendCount, setLastResendCount] = useState<number | null>(null);
+
+  const before = trail[pageIndex];
+
+  const submissionsQuery = useSubmissions({
+    workspaceId: props.workspaceId,
+    formId: props.formId,
+    limit,
+    ...(before !== undefined ? { before } : {}),
+    ...(version !== null ? { version } : {}),
+  });
+  const versionsQuery = useFormVersions(props.workspaceId, props.formId);
+
+  const rowsState = loadStateFromQuery(submissionsQuery);
+  const versionsState = loadStateFromQuery(versionsQuery);
+
+  const state: LoadState<ResponsesView> = useMemo(
+    () =>
+      mapLoad(bothLoaded(rowsState, versionsState), ([rows, versions]) => {
+        const chosen =
+          version !== null
+            ? versions.filter((v) => v.version === version)
+            : [...versions].sort((a, b) => b.version - a.version);
+        const seen = new Set<string>();
+        const columns: ResponseColumn[] = [];
+        for (const v of chosen) {
+          for (const column of columnsOf(v.schema.fields ?? [])) {
+            if (seen.has(column.slug)) continue;
+            seen.add(column.slug);
+            columns.push(column);
+          }
+        }
+        return { rows, columns };
+      }),
+    [rowsState, versionsState, version]
+  );
+
+  const deleteMutation = useDeleteSubmission();
+  const resendMutation = useResendSubmission();
+  const csv = useCsvExport();
+
+  const setVersion = useCallback((next: number | null): void => {
+    setVersionState(next);
+    // A version filter is a different list, so the keyset trail from the old
+    // one is meaningless — carrying it over would page into cursors that
+    // belong to rows this filter excludes.
+    setTrail([undefined]);
+    setPageIndex(0);
+    setSelected(null);
+  }, []);
+
+  // Memoized, not a bare conditional: `goNextPage` closes over `rows`, and a
+  // fresh `[]` on every render would re-create that callback every time.
+  const rows = useMemo(
+    () => (state.status === "ready" ? state.data.rows : []),
+    [state]
+  );
+  // A short page is the end of the list: the server returns at most `limit`.
+  const atEnd = state.status === "ready" && rows.length < limit;
+
+  const nextPage: ActionAvailability = useMemo(
+    () =>
+      requireLoaded(state, (view) => {
+        if (view.rows.length === 0 || view.rows.length < limit) {
+          return actionBlocked(FORMS_I18N_KEYS.responsesAtEnd);
+        }
+        return actionAvailable();
+      }),
+    [state, limit]
+  );
+
+  const prevPage: ActionAvailability = useMemo(
+    () =>
+      pageIndex === 0
+        ? actionBlocked(FORMS_I18N_KEYS.responsesAtStart)
+        : actionAvailable(),
+    [pageIndex]
+  );
+
+  const goNextPage = useCallback((): void => {
+    if (atEnd || rows.length === 0) return;
+    const last = rows[rows.length - 1];
+    if (last === undefined) return;
+    setTrail((current) => {
+      const next = current.slice(0, pageIndex + 1);
+      next.push(last.submitted_at);
+      return next;
+    });
+    setPageIndex((index) => index + 1);
+    setSelected(null);
+  }, [atEnd, rows, pageIndex]);
+
+  const goPrevPage = useCallback((): void => {
+    setPageIndex((index) => (index > 0 ? index - 1 : 0));
+    setSelected(null);
+  }, []);
+
+  const onError = useCallback((caught: unknown): void => {
+    setError(asApiError(caught));
+  }, []);
+
+  const remove = useCallback(
+    (submissionId: string): void => {
+      setError(null);
+      deleteMutation.mutate(
+        { workspaceId: props.workspaceId, submissionId },
+        {
+          onError,
+          onSuccess: () => {
+            setSelected((current) =>
+              current !== null && current.id === submissionId ? null : current
+            );
+          },
+        }
+      );
+    },
+    [deleteMutation, props.workspaceId, onError]
+  );
+
+  const resend = useCallback(
+    (submissionId: string, override?: ResendRequest): void => {
+      setError(null);
+      setLastResendCount(null);
+      resendMutation.mutate(
+        {
+          workspaceId: props.workspaceId,
+          submissionId,
+          ...(override !== undefined ? { override } : {}),
+        },
+        {
+          onError,
+          onSuccess: (result) => {
+            setLastResendCount(result.sent);
+          },
+        }
+      );
+    },
+    [resendMutation, props.workspaceId, onError]
+  );
+
+  const exportCsv = useCallback(async (): Promise<string> => {
+    setError(null);
+    try {
+      return await csv.run({
+        workspaceId: props.workspaceId,
+        formId: props.formId,
+        ...(version !== null ? { version } : {}),
+      });
+    } catch (caught) {
+      setError(asApiError(caught));
+      throw caught;
+    }
+  }, [csv, props.workspaceId, props.formId, version]);
+
+  const refetch = useCallback((): void => {
+    void submissionsQuery.refetch();
+    void versionsQuery.refetch();
+  }, [submissionsQuery, versionsQuery]);
+
+  return props.children({
+    state,
+    versions: versionsState,
+    version,
+    setVersion,
+    nextPage,
+    goNextPage,
+    prevPage,
+    goPrevPage,
+    pageIndex,
+    selected,
+    select: setSelected,
+    remove,
+    isRemoving: deleteMutation.isPending,
+    resend,
+    isResending: resendMutation.isPending,
+    lastResendCount,
+    exportCsv,
+    isExporting: csv.isExporting,
+    exportPages: csv.pagesFetched,
+    error,
+    refetch,
+  });
+}

package/src/i18n/errorsMap.ts

@@ -0,0 +1,31 @@
+/**
+ * The pair's error map (frontend-standard §4 checklist #7, frontend-core §2.5):
+ * the generated `code → { status, params, remediation, en }` catalog plus a
+ * tiny `explain()` lookup. Backs the manifest `errors` block and gives hosts a
+ * mechanical UX branch beside `t(code, params)`. The map itself is generated
+ * from the backend registry (`pnpm gen:errors`); this file only adds the lookup
+ * helper and re-exports the public surface.
+ */
+import { FORMS_ERRORS } from "./generated/errors.gen.js";
+import type { Remediation } from "./generated/errors.gen.js";
+
+export {
+  FORMS_ERRORS,
+  FORMS_ERROR_CODES,
+  formsErrorBundleEn,
+} from "./generated/errors.gen.js";
+export type {
+  FormsErrorCode,
+  FormsErrorSpec,
+  Remediation,
+} from "./generated/errors.gen.js";
+
+/**
+ * Resolve a backend error code to its remediation hint, or `undefined` for a
+ * code this module doesn't know (e.g. a cross-cutting `stapel.http.*` fallback).
+ * Zero guessing at runtime — a static lookup over the generated map.
+ */
+export function explainFormsError(code: string): Remediation | undefined {
+  return (FORMS_ERRORS as Record<string, { remediation: Remediation }>)[code]
+    ?.remediation;
+}

package/src/i18n/es.ts

@@ -0,0 +1,140 @@
+import type { I18nDictionary, I18nEngine } from "@stapel/core";
+import { formsErrorBundleEs } from "./generated/errors.es.gen.js";
+
+export { formsErrorBundleEs } from "./generated/errors.es.gen.js";
+
+/**
+ * Spanish bundle for forms-react — the pair's `es` locale, shipped as the
+ * `@stapel/forms-react/i18n/es` subpath (i18n-shipping.md §2) so the locale is
+ * opt-in: hosts that don't register it never carry these strings (the main
+ * entry does not import this module — gated by size-limit + the bundle-purity
+ * test).
+ *
+ * Composition mirrors `formsI18nBundleEn`; see `ru.ts` for the same structure
+ * and the same provenance statement — stapel-forms' es catalogue ships
+ * `origin=seed:authored` and is UNREVIEWED (backend delta note 10), and the
+ * pair-authored strings below are the same grade.
+ */
+const ATTRIBUTES_ERRORS_ES: Readonly<Record<string, string>> = {
+  "error.400.feature_below_minimum": "El valor es inferior al mínimo de «{feature}»",
+  "error.400.feature_above_maximum": "El valor supera el máximo de «{feature}»",
+  "error.400.feature_not_in_options":
+    "El valor no está entre las opciones permitidas de «{feature}»",
+  "error.400.feature_invalid_type": "Tipo de valor no válido para «{feature}»",
+  "error.400.feature_invalid_format": "Formato no válido para «{feature}»",
+  "error.400.feature_mandatory_missing": "El campo «{feature}» es obligatorio",
+  "error.400.feature_unknown_type": "Tipo de campo desconocido para «{feature}»",
+  "error.400.feature_not_allowed": "El campo «{feature}» no se permite aquí",
+  "error.400.feature_unknown": "Campo desconocido «{feature}»",
+  "error.400.feature_invalid_config": "Configuración no válida para «{feature}»",
+  "error.400.description_too_short": "La descripción debe tener al menos {min_length} caracteres",
+  "error.400.description_too_long": "La descripción debe tener como máximo {max_length} caracteres",
+};
+
+export const formsI18nBundleEs: I18nDictionary = {
+  ...formsErrorBundleEs,
+  ...ATTRIBUTES_ERRORS_ES,
+
+  "forms.error.unknown": "Algo salió mal. Inténtalo de nuevo.",
+
+  "forms.fill.loading": "Cargando el formulario…",
+  "forms.fill.retry": "Reintentar",
+  "forms.fill.load_failed":
+    "No pudimos cargar este formulario. Es un problema nuestro, no de tu enlace.",
+  "forms.fill.not_found": "Este enlace de formulario no es válido.",
+  "forms.fill.closed": "Este formulario está cerrado y ya no acepta respuestas.",
+  "forms.fill.superseded":
+    "El formulario cambió mientras lo rellenabas. Revisa tus respuestas y envíalo de nuevo.",
+  "forms.fill.unsupported_field":
+    "Este tipo de campo ({kind}) no se puede mostrar en esta versión de la aplicación.",
+  "forms.fill.required": "Obligatorio",
+  "forms.fill.submit": "Enviar",
+  "forms.fill.submitting": "Enviando…",
+  "forms.fill.thanks": "Gracias, hemos registrado tu respuesta.",
+  "forms.fill.optional_hint": "Opcional",
+  "forms.fill.bool_yes": "Sí",
+  "forms.fill.bool_no": "No",
+  "forms.fill.select_placeholder": "Elige…",
+  "forms.fill.unlimited": "Sin límite",
+
+  "forms.submit.blocked.done": "Ya has enviado este formulario.",
+  "forms.submit.blocked.in_flight": "Enviando tu respuesta…",
+  "forms.submit.blocked.unsupported_kind":
+    "Este formulario usa un tipo de campo que la aplicación no puede mostrar ({kinds}), así que no se puede enviar con seguridad.",
+
+  "forms.builder.title": "Editor de formularios",
+  "forms.builder.add_field": "Añadir campo",
+  "forms.builder.remove_field": "Eliminar campo",
+  "forms.builder.move_up": "Subir",
+  "forms.builder.move_down": "Bajar",
+  "forms.builder.field_slug": "Clave",
+  "forms.builder.field_label": "Etiqueta",
+  "forms.builder.field_required": "Obligatorio",
+  "forms.builder.field_kind": "Tipo",
+  "forms.builder.save": "Guardar borrador",
+  "forms.builder.publish": "Publicar",
+  "forms.builder.blocked.saving": "Guardando el borrador…",
+  "forms.builder.blocked.publishing": "Publicando…",
+  "forms.builder.blocked.no_changes": "Nada ha cambiado desde el último guardado.",
+  "forms.builder.blocked.empty_schema": "Añade al menos un campo antes de publicar.",
+  "forms.builder.blocked.unsaved_draft":
+    "Guarda el borrador primero: publicar ahora lanzaría la versión guardada anteriormente.",
+  "forms.builder.builder_less":
+    "Este tipo de campo no tiene opciones editables aquí. Su configuración se define mediante la API de borradores.",
+  "forms.builder.kind_unregistered":
+    "Esta instalación no reconoce este tipo de campo, así que no se puede configurar ni mostrar aquí. El campo se conserva para que no desaparezca del esquema sin avisar.",
+  "forms.builder.kinds_failed":
+    "No pudimos cargar la lista de tipos de campo, así que ahora no se pueden añadir campos.",
+  "forms.builder.no_kinds":
+    "Esta instalación no tiene tipos de campo configurables disponibles.",
+  "forms.builder.unsupported_config":
+    "Algunas opciones de este campo ({keys}) aún no se pueden editar aquí.",
+  "forms.builder.empty": "Este formulario aún no tiene campos.",
+  "forms.builder.meta_title": "Título del formulario",
+  "forms.builder.meta_description": "Descripción",
+  "forms.builder.meta_submit_label": "Texto del botón de envío",
+  "forms.builder.meta_confirmation": "Mensaje de confirmación",
+  "forms.builder.state_open": "Abierto",
+  "forms.builder.state_closed": "Cerrado",
+  "forms.builder.state_draft": "Borrador",
+  "forms.builder.rotate_link": "Renovar el enlace público",
+  "forms.builder.public_link": "Enlace público",
+
+  "forms.responses.title": "Respuestas",
+  "forms.responses.empty": "Todavía no hay respuestas.",
+  "forms.responses.load_failed": "No pudimos cargar las respuestas.",
+  "forms.responses.submitted_at": "Enviada",
+  "forms.responses.respondent": "Participante",
+  "forms.responses.anonymous": "Anónimo",
+  "forms.responses.version": "Versión",
+  "forms.responses.all_versions": "Todas las versiones",
+  "forms.responses.next": "Siguiente",
+  "forms.responses.prev": "Anterior",
+  "forms.responses.blocked.at_end": "Esta es la última página.",
+  "forms.responses.blocked.at_start": "Esta es la primera página.",
+  "forms.responses.delete": "Eliminar",
+  "forms.responses.delete_confirm": "¿Eliminar esta respuesta de forma permanente?",
+  "forms.responses.resend": "Reenviar",
+  "forms.responses.resend_sent": "Enviado a {count} destino(s).",
+  "forms.responses.resend_override": "Enviar a direcciones concretas",
+  "forms.responses.resend_override_hint":
+    "Sustituyen a los destinatarios configurados del formulario para este envío.",
+  "forms.responses.export": "Exportar CSV",
+  "forms.responses.exporting": "Exportando… ({pages} página(s))",
+  "forms.responses.erased": "Borrada",
+  "forms.responses.detail": "Detalle de la respuesta",
+  "forms.responses.close": "Cerrar",
+
+  "forms.list.title": "Formularios",
+  "forms.list.empty": "Todavía no hay formularios en este espacio de trabajo.",
+  "forms.list.load_failed": "No pudimos cargar los formularios.",
+  "forms.list.create": "Nuevo formulario",
+  "forms.list.new_title": "Formulario sin título",
+  "forms.list.submission_count": "{count} respuesta(s)",
+};
+
+/** Register the es bundle. Call AFTER `registerFormsI18n` so it layers over
+ * the en floor (merge priority = registration order). */
+export function registerFormsI18nEs(engine: I18nEngine): void {
+  engine.registerBundle("es", formsI18nBundleEs);
+}

package/src/i18n/generated/errors.es.gen.ts

@@ -0,0 +1,85 @@
+// AUTO-GENERATED by scripts/gen-errors.mjs — do not edit by hand.
+// Source: stapel-auth canonical errors.json (backend codegen artifact).
+// Regenerate: pnpm gen:errors   ·   Drift gate: pnpm gen:errors:check
+// Locale source: backend translations/errors.es.json (locale catalog
+// beside the canonical errors.json — i18n-shipping.md §1).
+import type { FormsErrorCode } from "./errors.gen.js";
+
+/**
+ * `es` texts for the backend error codes this catalog carries.
+ *
+ * PARTIAL, and deliberately typed to say so: 12 key(s) owned by
+ * stapel_attributes are absent, because that owner ships no locale catalog
+ * (ERRORS_LOCALE_EXEMPT_OWNERS). English for them still comes from the registry
+ * artifact via the en bundle; the pair layers its own authored `es`
+ * strings over this one until upstream ships translations. `Partial` is what
+ * makes the gap visible to TypeScript instead of a silent English fallback.
+ *
+ * Import from the pair's `./i18n/es` subpath, NOT the main entry, so
+ * the locale stays out of hosts that don't ship it.
+ */
+export const formsErrorBundleEs: Partial<Record<FormsErrorCode, string>> = {
+  "error.400.bad_request": "Solicitud incorrecta",
+  "error.400.captcha_invalid": "La verificación del captcha ha fallado. Inténtalo de nuevo.",
+  "error.400.captcha_required": "Se requiere el token del captcha.",
+  "error.400.expected_list": "Se esperaba una lista de elementos",
+  "error.400.field.blank": "{field} no puede estar vacío",
+  "error.400.field.does_not_exist": "{field} no existe",
+  "error.400.field.invalid": "{field} no es válido",
+  "error.400.field.invalid_choice": "{field} no es una opción válida",
+  "error.400.field.max_length": "{field} debe tener como máximo {max_length} caracteres",
+  "error.400.field.max_value": "{field} debe ser como máximo {max_value}",
+  "error.400.field.min_length": "{field} debe tener al menos {min_length} caracteres",
+  "error.400.field.min_value": "{field} debe ser como mínimo {min_value}",
+  "error.400.field.null": "{field} no puede ser nulo",
+  "error.400.field.required": "{field} es obligatorio",
+  "error.400.field.unique": "{field} debe ser único",
+  "error.400.forms_answers_not_object": "Las respuestas deben ser un objeto indexado por identificador de campo",
+  "error.400.forms_duplicate_slug": "El identificador de campo {slug} aparece más de una vez",
+  "error.400.forms_empty_schema": "Un formulario debe tener al menos un campo para publicarse",
+  "error.400.forms_invalid_retention": "La retención por formulario solo puede acortar el periodo del módulo",
+  "error.400.forms_invalid_schema": "El esquema del formulario no es válido",
+  "error.400.forms_invalid_state": "Estado de formulario desconocido",
+  "error.400.forms_kind_not_allowed": "El tipo de campo {kind} no puede usarse en un formulario",
+  "error.400.forms_no_draft": "No hay ningún borrador que publicar",
+  "error.400.forms_no_recipients": "Este formulario no tiene ningún destinatario de notificaciones configurado",
+  "error.400.forms_not_published": "El formulario aún no tiene ninguna versión publicada",
+  "error.400.forms_too_many_fields": "El formulario tiene más campos de los que permite el límite",
+  "error.400.forms_too_many_open": "Este espacio de trabajo ya tiene el número máximo de formularios abiertos",
+  "error.400.forms_unknown_field": "La respuesta contiene un campo que el formulario no tiene",
+  "error.400.invalid_ad_id": "ID de anuncio no válido",
+  "error.400.validation_error": "Error de validación",
+  "error.400.verification_failed": "La verificación ha fallado",
+  "error.400.verification_invalid_factor": "Este factor de verificación no está disponible",
+  "error.401.unauthorized": "Se requiere autenticación",
+  "error.402.payment_required": "Se requiere pago",
+  "error.403.forbidden": "No tienes permiso para realizar esta acción",
+  "error.403.forms_forbidden": "No tienes acceso a este formulario",
+  "error.403.network_blocked": "No se permiten solicitudes desde esta red.",
+  "error.403.verification_enrollment_required": "Es necesario registrar un factor de verificación.",
+  "error.403.verification_required": "Se requiere verificación adicional",
+  "error.404.ad_not_found": "Anuncio no encontrado",
+  "error.404.forms_not_found": "Formulario no encontrado",
+  "error.404.forms_submission_not_found": "Respuesta no encontrada",
+  "error.404.not_found": "Recurso solicitado no encontrado",
+  "error.404.verification_challenge_not_found": "Desafío de verificación no encontrado o caducado",
+  "error.405.method_not_allowed": "Método no permitido",
+  "error.406.not_acceptable": "No aceptable",
+  "error.408.request_timeout": "Tiempo de espera de la solicitud agotado",
+  "error.409.conflict": "El recurso ya existe",
+  "error.409.forms_submission_cap": "Este formulario ha alcanzado su límite de respuestas",
+  "error.409.forms_version_superseded": "El formulario cambió mientras lo rellenabas",
+  "error.410.forms_closed": "Este formulario está cerrado",
+  "error.410.gone": "El recurso se ha eliminado permanentemente",
+  "error.413.forms_body_too_large": "La respuesta supera el tamaño máximo",
+  "error.413.payload_too_large": "El cuerpo de la solicitud es demasiado grande",
+  "error.415.unsupported_media_type": "Tipo de contenido no compatible",
+  "error.422.unprocessable_entity": "Entidad no procesable",
+  "error.423.locked": "El recurso está bloqueado",
+  "error.423.verification_locked": "Demasiados intentos fallidos — verificación bloqueada",
+  "error.429.rate_limit": "Demasiados intentos. Inténtalo de nuevo en {retry_after_minutes} minutos.",
+  "error.429.too_many_requests": "Demasiadas solicitudes. Inténtalo de nuevo más tarde.",
+  "error.500.internal": "Algo salió mal",
+  "error.503.forms_workspaces_unavailable": "El servicio de espacios de trabajo no está disponible",
+  "error.503.mandate_unavailable": "No se puede verificar el mandato del espacio de trabajo",
+};