@stapel/reviews-react 0.1.0

package/src/headless/ReviewAggregate.tsx

@@ -0,0 +1,94 @@
+import type { ReactElement, ReactNode } from "react";
+import { loadFailed, loadLoading, loadReady } from "@stapel/core";
+import type { LoadState } from "@stapel/core";
+import type { RatingAggregate, ReviewTarget } from "../api/types.js";
+import { useReviewsRuntime } from "../model/context.js";
+import { useReviewAggregate } from "../model/queries.js";
+import { ratingSummary } from "../model/rating.js";
+import type { RatingSummary } from "../model/rating.js";
+
+/** What `<ReviewAggregate>` hands its render prop. */
+export interface ReviewAggregateBag {
+  /**
+   * The rating, READ — `rated: false` when nobody has rated the target, so a
+   * skin can never print the zero the wire carries in that case.
+   */
+  readonly state: LoadState<RatingSummary>;
+  /** Where the number came from. */
+  readonly source: "fetched" | "supplied";
+  /** The deployment's rating ceiling, for a star row that draws `max` stars. */
+  readonly max: number;
+}
+
+export interface ReviewAggregateProps {
+  /**
+   * What this rating is ABOUT. Always required, even when {@link aggregate}
+   * is supplied and nothing is fetched: it is the identity of the thing being
+   * rated, it keys the cache, and a rating rendered without one is a number
+   * nobody can trace back to a subject.
+   */
+  readonly target: ReviewTarget;
+  /**
+   * Numbers somebody else computed. Supplying them makes this component a
+   * pure display: no request is made, and `source` reports `"supplied"`.
+   */
+  readonly aggregate?: RatingAggregate;
+  readonly children: (bag: ReviewAggregateBag) => ReactNode;
+}
+
+/**
+ * The headless rating display — the same bag whether the number came from
+ * this module or from the composite. `AllowAny` upstream since 0.3.0, so a
+ * guest sees the rating and there is no "sign in" state here.
+ *
+ * ── Why `aggregate` is a prop, and not a second endpoint ───────────────────
+ *
+ * stapel-reviews can aggregate exactly ONE `(target_type, target_key)` per
+ * call. The storefront's product decision (spec fork F5) is that a review
+ * targets the SELLER for a specific listing — `target_type: "listing"`, one
+ * per author per listing — and the seller's own rating is therefore a ROLL-UP
+ * across every listing they own. No endpoint computes that: the composite
+ * does, server-side, as `shop.listing_review_summary`
+ * (`stapel_shop/projections.py`), and the roll-up over a seller's keys is the
+ * composite's projection to publish, on its own route.
+ *
+ * So this pair does the half it can honestly do: it renders `{avg, count}` —
+ * the projection's own field names, chosen upstream precisely so both modes
+ * answer one shape — from wherever the host got them. `source` says which,
+ * so a skin that wants to (a demo, an admin view) can show it. A seller
+ * header therefore reads
+ * `<ReviewAggregate target={{targetType: "seller", targetKey: id}}
+ * aggregate={rollup}>`: the target names the subject, the numbers come from
+ * the composite, and no request is made against an endpoint that could not
+ * have answered it.
+ *
+ * The gap is real and is recorded in the README rather than papered over with
+ * N+1 requests: a page that wants a seller rating today must be served the
+ * two numbers by its own backend.
+ */
+export function ReviewAggregate(props: ReviewAggregateProps): ReactElement {
+  const runtime = useReviewsRuntime();
+  const supplied = props.aggregate;
+  const query = useReviewAggregate(props.target, {
+    enabled: supplied === undefined,
+  });
+
+  const state: LoadState<RatingSummary> =
+    supplied !== undefined
+      ? loadReady(ratingSummary(supplied))
+      : query.status === "error"
+        ? loadFailed(query.error)
+        : query.data === undefined
+          ? loadLoading()
+          : loadReady(ratingSummary(query.data));
+
+  return (
+    <>
+      {props.children({
+        state,
+        source: supplied !== undefined ? "supplied" : "fetched",
+        max: runtime.ratingBounds.max,
+      })}
+    </>
+  );
+}

package/src/headless/ReviewForm.tsx

@@ -0,0 +1,163 @@
+import { useCallback, useState } from "react";
+import type { ReactElement, ReactNode } from "react";
+import { actionAvailable, actionBlocked, firstBlock } from "@stapel/core";
+import type { ActionAvailability, FlowError } from "@stapel/core";
+import type { Review, ReviewTarget } from "../api/types.js";
+import { REVIEWS_I18N_KEYS } from "../i18n/keys.js";
+import { useReviewsRuntime } from "../model/context.js";
+import { useSubmitReview } from "../model/mutations.js";
+import { reviewVisibility } from "../model/list.js";
+import type { ReviewRatingBounds } from "../model/runtime.js";
+import {
+  isDuplicateReview,
+  isReviewingForbidden,
+  isSignInRequired,
+  toReviewsError,
+} from "../model/refusals.js";
+
+/** What `<ReviewForm>` hands its render prop. */
+export interface ReviewFormBag {
+  /** The chosen rating, or `null` while nothing is chosen. */
+  readonly rating: number | null;
+  readonly setRating: (rating: number) => void;
+  readonly body: string;
+  readonly setBody: (body: string) => void;
+  /** The deployment's inclusive bounds — the star row draws exactly these. */
+  readonly bounds: ReviewRatingBounds;
+  /** Send it. A no-op while {@link canSubmit} is blocked. */
+  readonly submit: () => void;
+  /** Whether the button may be pressed, and if not, the sentence saying why. */
+  readonly canSubmit: ActionAvailability;
+  readonly submitting: boolean;
+  /**
+   * The persisted review, once it exists. Its `status` is the whole point:
+   * `published` means it is already on the page, `pending` means the
+   * deployment pre-moderates and it is NOT — and the person who just wrote it
+   * must be told that rather than left looking for it.
+   */
+  readonly submitted: Review | null;
+  /** `submitted?.status`, narrowed, with a fourth arm for an unknown state. */
+  readonly submittedVisibility: "published" | "pending" | "hidden" | "unknown" | null;
+  /**
+   * The server said this author has already reviewed this target
+   * (`error.400.reviews_duplicate_review` — a 400, not a 409; see
+   * `model/refusals.ts`). Or the host told us so up front via
+   * `alreadyReviewed`.
+   */
+  readonly alreadyReviewed: boolean;
+  /**
+   * The write failed with 401 — the form was offered to a signed-out reader.
+   *
+   * The LAST place this state survives. Since stapel-reviews 0.3.0 both reads
+   * are anonymous (`IsAuthenticatedOrReadOnly` on the list class, `AllowAny`
+   * on the aggregate), so a guest reads the reviews and only the POST refuses
+   * — there has to be an author to attribute the review to. That makes this a
+   * prompt to sign in at the moment it is actually true, rather than a wall in
+   * front of content.
+   */
+  readonly signInRequired: boolean;
+  /** The type's `can_review` callback refused this author for this target. */
+  readonly forbidden: boolean;
+  /**
+   * The refusal, for the error surface — `undefined` once it has been
+   * translated into one of the named flags above AND that flag is what the
+   * skin renders. Duplicate/forbidden/sign-in are named states with their own
+   * copy; everything else (an invalid rating the mirror let through, an
+   * outage) stays here.
+   */
+  readonly error: FlowError | undefined;
+}
+
+export interface ReviewFormProps {
+  readonly target: ReviewTarget;
+  /**
+   * The host already knows this author has reviewed the target — typically
+   * from `findOwnReview()` over the loaded list. An OPTIMISTIC input: it
+   * cannot see a pending review (the list is published-only), so a `false`
+   * here never means "the server will accept this".
+   */
+  readonly alreadyReviewed?: boolean;
+  readonly children: (bag: ReviewFormBag) => ReactNode;
+}
+
+/**
+ * The headless "rate this" form.
+ *
+ * The one rule it exists to hold: **the refusal is read by code, never by
+ * status**. "You have already reviewed this" arrives as a 400 whose code is
+ * `error.400.reviews_duplicate_review`, while the module's only 409 means the
+ * owner's reply already exists. A form that branched on the number would miss
+ * the first and mishandle the second.
+ *
+ * The second rule: a submitted review is not necessarily a visible one. The
+ * bag reports the created row's `status` so a pre-moderated deployment can
+ * say "sent — it will appear once it is checked", instead of leaving the
+ * author to hunt for a review that is deliberately invisible.
+ */
+export function ReviewForm(props: ReviewFormProps): ReactElement {
+  const { target, alreadyReviewed = false, children } = props;
+  const runtime = useReviewsRuntime();
+  const mutation = useSubmitReview(target);
+  // Destructured because `mutation` is a new object every render while
+  // `mutate` is stable (TanStack v5 contract) — depending on the object would
+  // rebuild `submit` on every state change and re-render the whole render
+  // prop below it.
+  const { mutate } = mutation;
+  const [rating, setRating] = useState<number | null>(null);
+  const [body, setBody] = useState("");
+
+  const submitted = mutation.data ?? null;
+  const failure = mutation.error ?? undefined;
+  const duplicate = failure !== undefined && isDuplicateReview(failure);
+  const forbidden = failure !== undefined && isReviewingForbidden(failure);
+  const signInRequired = failure !== undefined && isSignInRequired(failure);
+  const alreadyKnown = alreadyReviewed || duplicate;
+
+  const canSubmit = firstBlock(
+    alreadyKnown
+      ? actionBlocked(REVIEWS_I18N_KEYS.submitBlockedDuplicate)
+      : actionAvailable(),
+    submitted !== null
+      ? actionBlocked(REVIEWS_I18N_KEYS.submitBlockedSubmitted)
+      : actionAvailable(),
+    mutation.isPending
+      ? actionBlocked(REVIEWS_I18N_KEYS.submitBlockedPending)
+      : actionAvailable(),
+    rating === null
+      ? actionBlocked(REVIEWS_I18N_KEYS.submitBlockedNoRating)
+      : actionAvailable(),
+    forbidden
+      ? actionBlocked(REVIEWS_I18N_KEYS.submitBlockedForbidden)
+      : actionAvailable()
+  );
+
+  const submit = useCallback(() => {
+    if (rating === null) return;
+    mutate({ rating, ...(body.length > 0 ? { body } : {}) });
+  }, [rating, body, mutate]);
+
+  return (
+    <>
+      {children({
+        rating,
+        setRating,
+        body,
+        setBody,
+        bounds: runtime.ratingBounds,
+        submit,
+        canSubmit,
+        submitting: mutation.isPending,
+        submitted,
+        submittedVisibility:
+          submitted === null ? null : reviewVisibility(submitted.status),
+        alreadyReviewed: alreadyKnown,
+        signInRequired,
+        forbidden,
+        error:
+          failure === undefined || duplicate || forbidden || signInRequired
+            ? undefined
+            : toReviewsError(failure),
+      })}
+    </>
+  );
+}

package/src/headless/ReviewList.tsx

@@ -0,0 +1,99 @@
+import { useCallback } from "react";
+import type { ReactElement, ReactNode } from "react";
+import {
+  actionAvailable,
+  actionBlocked,
+  loadFailed,
+  loadLoading,
+  loadReady,
+} from "@stapel/core";
+import type { ActionAvailability, LoadState } from "@stapel/core";
+import type { Review, ReviewTarget } from "../api/types.js";
+import { REVIEWS_I18N_KEYS } from "../i18n/keys.js";
+import { reviewsFromPages } from "../model/list.js";
+import { useReviewList } from "../model/queries.js";
+import type { UseReviewListOptions } from "../model/queries.js";
+
+/** What `<ReviewList>` hands its render prop. */
+export interface ReviewListBag {
+  readonly target: ReviewTarget;
+  /**
+   * The rows, newest first — `loading` / `ready` / `failed`, never a
+   * defaulted empty array. An empty READY list is the only honest way to say
+   * "this target has no reviews".
+   */
+  readonly state: LoadState<readonly Review[]>;
+  /** Ask for the next (older) page. */
+  readonly loadMore: () => void;
+  /** Whether there is another page, and if not, why the control is off. */
+  readonly more: ActionAvailability;
+  /** A next page is in flight (the rows already on screen stay on screen). */
+  readonly loadingMore: boolean;
+  /** Re-read the first page. */
+  readonly refresh: () => void;
+  /**
+   * The scope actually requested. `"all"` means pending/hidden rows were
+   * ASKED for — the server grants them only to a moderator/owner and narrows
+   * everyone else silently, so this is never a promise that they are here.
+   */
+  readonly include: "all" | undefined;
+}
+
+export interface ReviewListProps extends UseReviewListOptions {
+  readonly target: ReviewTarget;
+  readonly children: (bag: ReviewListBag) => ReactNode;
+}
+
+/**
+ * The headless review list: anchor-paginated, newest first, over one opaque
+ * `(target_type, target_key)`, readable by anyone.
+ *
+ * There is no `signInRequired` here: since stapel-reviews 0.3.0 the list is
+ * `IsAuthenticatedOrReadOnly`, so a guest gets the published rows. An empty
+ * READY list therefore means what it says — nobody has reviewed this target —
+ * and it is a state a signed-out visitor can legitimately reach.
+ *
+ * No markup, no strings — a render prop and a bag (frontend-standard §2). The
+ * antd rendering of the same bag is `@stapel/reviews-react/default`'s
+ * `<ReviewListPanel>`.
+ */
+export function ReviewList(props: ReviewListProps): ReactElement {
+  const { target, children, ...options } = props;
+  const query = useReviewList(target, options);
+  const { fetchNextPage, refetch } = query;
+
+  const loadMore = useCallback(() => {
+    void fetchNextPage();
+  }, [fetchNextPage]);
+  const refresh = useCallback(() => {
+    void refetch();
+  }, [refetch]);
+
+  const rows = reviewsFromPages(query.data);
+  const state: LoadState<readonly Review[]> =
+    query.status === "error"
+      ? loadFailed(query.error)
+      : rows === undefined
+        ? loadLoading()
+        : loadReady(rows);
+
+  const more: ActionAvailability = query.hasNextPage
+    ? query.isFetchingNextPage
+      ? actionBlocked(REVIEWS_I18N_KEYS.moreBlockedPending)
+      : actionAvailable()
+    : actionBlocked(REVIEWS_I18N_KEYS.moreBlockedEnd);
+
+  return (
+    <>
+      {children({
+        target,
+        state,
+        loadMore,
+        more,
+        loadingMore: query.isFetchingNextPage,
+        refresh,
+        include: options.include,
+      })}
+    </>
+  );
+}

package/src/headless/ReviewsProvider.tsx

@@ -0,0 +1,20 @@
+import type { ReactElement, ReactNode } from "react";
+import { ModuleProvider } from "../model/context.js";
+import type { ReviewsRuntime } from "../model/runtime.js";
+
+/**
+ * Provides the wired {@link ReviewsRuntime} to every reviews hook and headless
+ * component below it. Bring your own visual shell — this component renders
+ * nothing of its own. (Core's `createModuleContext` provider, bound to this
+ * pair — slim wave §21/S2.)
+ *
+ * ```tsx
+ * const runtime = createReviewsRuntime({ baseUrl: "/reviews/api/v1" });
+ * // give runtime.client to core's <StapelConfigProvider config={{ client }}>
+ * <ReviewsProvider runtime={runtime}>{app}</ReviewsProvider>
+ * ```
+ */
+export const ReviewsProvider: (props: {
+  runtime: ReviewsRuntime;
+  children: ReactNode;
+}) => ReactElement = ModuleProvider;

package/src/i18n/errorsMap.ts

@@ -0,0 +1,33 @@
+/**
+ * The pair's error map (frontend-standard §4 checklist #7): 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 { REVIEWS_ERRORS } from "./generated/errors.gen.js";
+import type { Remediation } from "./generated/errors.gen.js";
+
+export {
+  REVIEWS_ERRORS,
+  REVIEWS_ERROR_CODES,
+  reviewsErrorBundleEn,
+} from "./generated/errors.gen.js";
+export type {
+  ReviewsErrorCode,
+  ReviewsErrorSpec,
+  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 (a cross-cutting `stapel.http.*` fallback, or
+ * one of this pair's own client-side rules such as
+ * `reviews.submit.blocked.no_rating` — which is not a backend code and
+ * deliberately has no entry here).
+ */
+export function explainReviewsError(code: string): Remediation | undefined {
+  return (REVIEWS_ERRORS as Record<string, { remediation: Remediation }>)[code]
+    ?.remediation;
+}

package/src/i18n/es.ts

@@ -0,0 +1,81 @@
+import type { I18nDictionary, I18nEngine } from "@stapel/core";
+import { reviewsErrorBundleEs } from "./generated/errors.es.gen.js";
+
+export { reviewsErrorBundleEs } from "./generated/errors.es.gen.js";
+
+/**
+ * Spanish bundle for reviews-react — the `@stapel/reviews-react/i18n/es`
+ * subpath (i18n-shipping.md §2), opt-in exactly like `./i18n/ru`.
+ *
+ * Same two sources, same reason (see `./ru.ts`): 42 cross-cutting keys come
+ * from stapel-core's catalogue through the generated bundle, and the 9 keys
+ * stapel-reviews owns are authored below until upstream ships
+ * `translations/errors.es.json`.
+ *
+ * The UI copy is carried here too, not just the error keys: a review form is
+ * a surface a buyer reads word by word, and half a translation is worse than
+ * either language on its own (the chat-react precedent).
+ */
+export const reviewsI18nBundleEs: I18nDictionary = {
+  // Backend error codes — generated es texts for every key core owns.
+  ...reviewsErrorBundleEs,
+
+  // Backend error codes stapel-reviews owns — authored here.
+  "error.400.reviews_duplicate_review": "Ya has valorado esto",
+  "error.400.reviews_invalid_moderation_action":
+    "La acción de moderación debe ser una de: ocultar, publicar",
+  "error.400.reviews_invalid_rating": "La valoración está fuera del rango permitido",
+  "error.400.reviews_response_not_allowed":
+    "Las respuestas están desactivadas para este tipo de objeto",
+  "error.400.reviews_unknown_target_type": "Tipo de objeto de reseña desconocido",
+  "error.403.reviews_cannot_moderate":
+    "No puedes moderar las reseñas de este objeto",
+  "error.403.reviews_cannot_review": "No puedes reseñar este objeto",
+  "error.404.reviews_review_not_found": "Reseña no encontrada",
+  "error.409.reviews_already_responded": "Esta reseña ya tiene una respuesta",
+
+  // UI copy.
+  "reviews.error.unknown": "Algo ha fallado con las reseñas",
+
+  "reviews.list.heading": "Reseñas",
+  "reviews.list.empty": "Todavía no hay reseñas",
+  "reviews.list.load_more": "Ver más",
+  "reviews.list.refresh": "Actualizar",
+  "reviews.list.more.blocked.end": "Eso es todo",
+  "reviews.list.more.blocked.pending": "Cargando…",
+
+  "reviews.review.author_fallback": "Un cliente",
+  "reviews.review.response_heading": "Respuesta del vendedor",
+
+  "reviews.status.pending": "Pendiente de moderación",
+  "reviews.status.hidden": "Oculta por moderación",
+  "reviews.status.unknown": "Estado desconocido: {status}",
+
+  "reviews.rating.none": "Todavía no hay reseñas",
+  "reviews.rating.value": "{avg} de {max}",
+  "reviews.rating.count": "{count} reseñas",
+  "reviews.rating.star_label": "{index} de {max}",
+
+  "reviews.form.heading": "Valora esto",
+  "reviews.form.rating_label": "Tu valoración",
+  "reviews.form.body_label": "Tu reseña",
+  "reviews.form.body_placeholder": "¿Qué tal fue el trato? (opcional)",
+  "reviews.form.submit": "Enviar",
+  "reviews.form.sent.published": "Gracias — tu reseña está publicada",
+  "reviews.form.sent.pending":
+    "Gracias — tu reseña aparecerá cuando se haya revisado",
+  "reviews.form.sent.hidden": "Tu reseña se ha guardado, pero no se muestra",
+  "reviews.form.sent.unknown": "Tu reseña se ha guardado",
+  "reviews.form.sign_in_required": "Inicia sesión para dejar una reseña",
+
+  "reviews.submit.blocked.no_rating": "Elige primero una valoración",
+  "reviews.submit.blocked.pending": "Enviando…",
+  "reviews.submit.blocked.duplicate": "Ya has valorado esto",
+  "reviews.submit.blocked.submitted": "Tu reseña se ha enviado",
+  "reviews.submit.blocked.forbidden": "No puedes reseñar esto",
+};
+
+/** Register the Spanish bundle into a core i18n engine. */
+export function registerReviewsI18nEs(engine: I18nEngine, locale = "es"): void {
+  engine.registerBundle(locale, reviewsI18nBundleEs);
+}

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

@@ -0,0 +1,64 @@
+// 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 { ReviewsErrorCode } from "./errors.gen.js";
+
+/**
+ * `es` texts for the backend error codes this catalog carries.
+ *
+ * PARTIAL, and deliberately typed to say so: 9 key(s) owned by
+ * stapel_reviews 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 reviewsErrorBundleEs: Partial<Record<ReviewsErrorCode, 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.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.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.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.410.gone": "El recurso se ha eliminado permanentemente",
+  "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.mandate_unavailable": "No se puede verificar el mandato del espacio de trabajo",
+};