@opencxh/domain 1.171.0 → 1.172.2

package/dist/entities/activity/blocks.d.ts

@@ -1,36 +1,36 @@
 import { ActivityText } from './descriptor';
 /**
- * De blokken waaruit een gedeclareerde tijdlijnrij is opgebouwd.
+ * The blocks a declared timeline row is built from.
  *
- * Geleend van Slack's Block Kit: dezelfde namen en dezelfde grammatica, zodat iemand die
- * ooit een Slack-app bouwde ze herkent — en wij schrijven Block Kit zelf al
- * (`apps/slack/server/src/thread/context-blocks.ts`). Maar niet de hele catalogus: Block
- * Kit telt inmiddels 21 bloktypes, waarvan de invoervelden-helft een compleet
- * formuliersysteem is dat we al hebben in `ui-kit`'s `Form`.
+ * Borrowed from Slack's Block Kit: the same names and the same grammar, so anyone who once built a
+ * Slack app recognizes them — and we already write Block Kit ourselves
+ * (`apps/slack/server/src/thread/context-blocks.ts`). But not the whole catalog: Block Kit now
+ * counts 21 block types, the input-field half of which is a complete form system we already have
+ * in `ui-kit`'s `Form`.
  *
- * De scheiding die dat mogelijk maakt: **de blokken beschrijven de binnenkant van de rij,
- * de descriptor-semantiek de buitenkant.** Uitlijning op `direction`, de avatar, de
- * groepering van opeenvolgende bubbels en de tijdstempel blijven van de host — Block Kit
- * kent die begrippen niet, want daar is een bericht een losstaande kaart.
+ * The separation that makes that possible: **the blocks describe the inside of the row, the
+ * descriptor semantics the outside.** Alignment on `direction`, the avatar, the grouping of
+ * consecutive bubbles and the timestamp stay with the host — Block Kit has no notion of those,
+ * because there a message is a standalone card.
  */
-/** Semantische kleur. Geen vrije kleuren, zodat dark mode en de tokens blijven kloppen. */
+/** Semantic colour. No free colours, so dark mode and the tokens keep working. */
 export type ActivityTone = "info" | "success" | "warning" | "destructive";
 export interface ActivityBadge {
     text: ActivityText;
     tone?: ActivityTone;
 }
 export interface ActivityAction {
-    /** Stabiel binnen de rij; routeert de klik en laat de host één knop hertekenen. */
+    /** Stable within the row; routes the click and lets the host redraw one button. */
     action_id: string;
     text: ActivityText;
     /**
-     * De route waar de klik heen gaat, `"<app>.<scope>.<route>"`.
+     * The route the click goes to, `"<app>.<scope>.<route>"`.
      *
-     * Let op: `sdk.http.invoke` maakt van elke `.` een URL-`/`. Een id met punten hoort dus
-     * in {@link params} en niet in de action zelf.
+     * Note: `sdk.http.invoke` turns every `.` into a URL `/`. An id with dots therefore belongs in
+     * {@link params} and not in the action itself.
      */
     invoke: string;
-    /** Paden in de activity; de host leest ze uit en stuurt ze als body mee. */
+    /** Paths into the activity; the host reads them out and sends them as the body. */
     params?: Record<string, string>;
     style?: "primary" | "secondary" | "destructive";
 }
@@ -48,12 +48,12 @@ export type ActivityBlock = {
     block_id?: string;
     type: "section";
     text?: ActivityText;
-    /** Tweekoloms sleutel/waarde. */
+    /** Two-column key/value. */
     fields?: {
         label: ActivityText;
         value: ActivityText;
     }[];
-    /** Het rechterslot. Voorlopig alleen een badge — een knop hoort in `actions`. */
+    /** The right-hand slot. A badge for now — a button belongs in `actions`. */
     accessory?: ActivityBadge;
 } | {
     block_id?: string;
@@ -70,9 +70,9 @@ export type ActivityBlock = {
     alt: string;
 }
 /**
- * Een rij per item. Kwam erbij door `ProposedActionCard` om te zetten: die toont een
- * regel per voorgestelde actie, en `section.fields` is een rooster dat dat niet kan.
- * Ticketregels en orderregels lopen op hetzelfde aan.
+ * One row per item. Came in while converting `ProposedActionCard`: that one shows a line per
+ * proposed action, and `section.fields` is a grid that cannot do it. Ticket lines and order
+ * lines run into the same thing.
  */
  | {
     block_id?: string;
@@ -83,27 +83,27 @@ export type ActivityBlock = {
     type: "actions";
     elements: ActivityAction[];
 }
-/** Alleen aanzetten; de host tekent `activity.attachments` en regelt het downloaden. */
+/** Switch on only; the host draws `activity.attachments` and handles the downloading. */
  | {
     block_id?: string;
     type: "attachments";
 };
 /**
- * Een tijdlijnrij van vijftig blokken breekt de feed. Slack hanteert 50 per bericht; een
- * rij in een lijst verdraagt minder, want hij staat tussen tientallen andere.
+ * A timeline row of fifty blocks breaks the feed. Slack allows 50 per message; a row in a list
+ * tolerates fewer, because it sits among dozens of others.
  */
 export declare const MAX_BLOCKS = 10;
 export declare const MAX_FIELDS = 10;
 export declare const MAX_LIST_ITEMS = 10;
 export declare const MAX_ACTIONS = 5;
 /**
- * Snoeit een gedeclareerde blokkenlijst tot iets wat de feed veilig kan tekenen.
+ * Prunes a declared block list down to something the feed can safely draw.
  *
- * Weigeren en niet afkappen zou de hele rij laten verdwijnen om één slecht blok; dit laat
- * de rest staan. Draait bij het samenstellen van de catalogus, zodat een verkeerde
- * declaratie één keer gemeld wordt in plaats van bij elke render.
+ * Refusing instead of truncating would make the whole row disappear over one bad block; this
+ * keeps the rest. Runs while composing the catalog, so a wrong declaration is reported once
+ * instead of on every render.
  *
- * `onDrop` krijgt te horen wat er wegviel — stil snoeien maakt "waarom staat mijn knop er
- * niet?" onbeantwoordbaar.
+ * `onDrop` is told what fell away — silent pruning makes "why is my button missing?"
+ * unanswerable.
  */
 export declare function normalizeBlocks(blocks: unknown, onDrop?: (reason: string) => void): ActivityBlock[];

package/dist/entities/activity/catalog.d.ts

@@ -1,99 +1,79 @@
 import { Activity, ActivityType } from './types';
 /**
- * Eén plek die beschrijft wat een activity-type *betekent* en hoe het als tekst leest.
+ * Single source of truth for what an activity type *means* and how it reads as text.
  *
- * Waarom dit bestaat: dezelfde vraag stond zes keer los in de codebase — "is dit een echt
- * bericht?" in `summarize`, in `lastMessagePreview`, in `attentionScore`, in
- * `reply-to-interaction`, in de analytics-rollup en in de playbook-dry-run, elke keer met
- * nét een andere lijst. Een nieuw type moest dus op zes plekken worden bijgeschreven, en
- * een vergeten plek faalt *stil*: het type verdwijnt uit de focus-score of uit de
- * analytics zonder dat er iets kapotgaat.
- *
- * Daarnaast werd de kanaalsoort geraden uit het type-voorvoegsel (`startsWith("EMAIL")`),
- * op de server én — als losse regex — in de playbook-editor.
- *
- * Deze catalogus is bewust een platte declaratie en geen gedragslaag: hij beantwoordt
- * vragen over een type, hij voert niets uit. De tekstfuncties zijn letterlijk verplaatst
- * uit `preview.ts` en `TimelineEvent.tsx`, niet herschreven — de uitvoer is byte-identiek.
+ * "Is this a real message?" used to live in six places (summarize, lastMessagePreview,
+ * attentionScore, reply-to-interaction, analytics rollup, playbook dry-run), each with a
+ * slightly different list — a forgotten spot failed *silently*. Channel kind was guessed
+ * from the type prefix (`startsWith("EMAIL")`), on the server and as a regex in the
+ * playbook editor. Deliberately a flat declaration, not a behavior layer: it answers
+ * questions about a type, executes nothing. The text functions were moved verbatim from
+ * `preview.ts` and `TimelineEvent.tsx` — output is byte-identical.
  */
 /**
- * Wat voor soort ding is dit op de tijdlijn?
- *
- * - `message` — een bericht van of aan de tegenpartij, met een leesbare body.
- * - `note` — interne tekst, zichtbaar voor collega's maar niet voor de tegenpartij.
- * - `artifact` — meegeleverde inhoud die geen bericht is (bestand, transcript).
- * - `event` — een gebeurtenis zonder eigen inhoud (gesprek gestart, status gewijzigd).
+ * What kind of thing is this on the timeline?
+ * - `message` — to/from the counterparty, with a readable body.
+ * - `note` — internal text, visible to colleagues but not the counterparty.
+ * - `artifact` — attached content that is not a message (file, transcript).
+ * - `event` — an occurrence without content of its own (call started, status changed).
  */
 export type ActivityShape = "message" | "note" | "artifact" | "event";
-/** Kanaalsoort, voorheen geraden uit het type-voorvoegsel. */
+/** Channel kind; previously guessed from the type prefix. */
 export type ActivityChannelKind = "mail" | "chat" | "voice" | "video";
-/** De arm van de `Activity`-union die bij precies dit type hoort. */
+/** The arm of the `Activity` union for exactly this type. */
 type ActivityOf<T extends ActivityType> = Extract<Activity, {
     type: T;
 }>;
 interface ActivityTypeInfo<T extends ActivityType = ActivityType> {
     shape: ActivityShape;
     channelKind?: ActivityChannelKind;
-    /** Lucide-icoonnaam, gedeeld door web en mobiel. */
+    /** Lucide icon name, shared by web and mobile. */
     icon: string;
     /**
-     * Kan een mens hierop antwoorden? Een interne notitie draagt wél tekst maar is geen
-     * antwoordbaar bericht — daarom een eigen vlag en niet afgeleid van `shape`.
+     * Can a human reply to it? An internal note carries text but is not a replyable
+     * message — hence its own flag, not derived from `shape`.
      */
     replyable?: boolean;
-    /** Telt mee als in-/uitgaand bericht in de analytics-rollup. */
+    /** Counts as an in-/outbound message in the analytics rollup. */
     countsAs?: "inbound_message" | "outbound_message";
     /**
-     * Draagt dit type door mensen geschreven tekst die de moeite waard is om aan een model
-     * te voeren? Ruimer dan `shape === "message"`: een transcript is een artifact maar wel
-     * leesbare inhoud.
+     * Carries human-written text worth feeding to a model. Broader than
+     * `shape === "message"`: a transcript is an artifact but still readable content.
      */
     carriesText?: boolean;
-    /** Door de engine zelf geschreven; mag geen nieuwe playbook-run openen. */
+    /** Written by the engine itself; must not open a new playbook run. */
     playbookAuthored?: boolean;
     /**
-     * Betekent dit type dat er daadwerkelijk contact tot stand kwam — dat er gesproken is?
-     *
-     * Nodig omdat "is hier echt iets uitgewisseld" niet uit berichten alleen te bepalen valt: een
-     * aangenomen telefoongesprek is een volwaardige casus met nul berichten, en een gemiste oproep
-     * is het tegenovergestelde. Een eigen vlag en niet afgeleid van `shape`, want beide zijn
-     * `event` — het verschil zit in de betekenis, niet in de vorm.
-     *
-     * Bewust hier en niet als lijstje in de app die de vraag stelt: dat is precies hoe "is dit een
-     * bericht?" zes keer los kwam te staan.
+     * Did actual contact happen — was there a conversation? Not derivable from messages
+     * alone: an answered phone call is a full case with zero messages, a missed call is
+     * the opposite. Its own flag, not derived from `shape` — both are `event`; the
+     * difference is meaning, not form. Deliberately declared here, not as a list in the
+     * asking app: that is exactly how "is this a message?" ended up in six places.
      */
     connected?: boolean;
     /**
-     * Verschijnt in de trigger-keuzelijst van playbooks en webhooks.
-     *
-     * Niet elk type is een zinnig startsignaal: op "gesprek in de wacht" wil niemand een
-     * playbook hangen. Dit zijn exact de vijf die de builder tot nu toe hardcodeerde, nu op
-     * de plek waar een app zijn eigen type er ook aan toe kan voegen.
+     * Appears in the playbook/webhook trigger picker. Not every type is a sensible start
+     * signal; these are exactly the five the builder used to hardcode, now in the place
+     * where an app can add its own type too.
      */
     triggerable?: boolean;
     /**
-     * Vertaalsleutel voor de naam in een keuzelijst. Alleen nodig zodra een type
-     * {@link triggerable} is — pas dan moet iemand het bij naam kunnen kiezen.
+     * Translation key for the name in a picker. Only needed once a type is
+     * {@link triggerable}.
      */
     displayNameKey?: string;
     /**
-     * Eigen component voor de feed, als `"<app>:<Resource>"`.
-     *
-     * Bewust hetzelfde veld dat een externe app straks in zijn descriptor zet: onze eigen
-     * rijke types (mail, chat, notitie, ...) lopen daarmee door precies dezelfde resolver
-     * als een helpdesk-app die `helpdesk:TicketActivity` meebrengt. Zou dit een aparte
-     * lijst in de comms-app zijn, dan zou dat pad alleen door vreemde apps gedragen worden
-     * en zouden de gaten erin pas bij de eerste externe bouwer opvallen.
-     *
-     * Spiegelt `TransportConfig.ui.canvas`, dat op dezelfde manier naar
-     * `communication:CallCanvas` wijst.
+     * Custom feed component, as `"<app>:<Resource>"`. Deliberately the same field an
+     * external app sets in its descriptor: our own rich types run through exactly the
+     * resolver a foreign `helpdesk:TicketActivity` would, so gaps surface before the
+     * first external builder hits them. Mirrors `TransportConfig.ui.canvas`.
      */
     component?: `${string}:${string}`;
-    /** Regel voor de inboxlijst. Verplaatst uit `preview.ts`. */
+    /** Inbox-list line. Moved from `preview.ts`. */
     snippet?: (activity: ActivityOf<T>) => string;
-    /** Regel voor de tijdlijn. Verplaatst uit `TimelineEvent.tsx`. */
+    /** Timeline line. Moved from `TimelineEvent.tsx`. */
     timeline?: (activity: ActivityOf<T>, authorName: string) => string;
-    /** Deelnameknop op de tijdlijnregel. Verplaatst uit `TimelineEvent.tsx`. */
+    /** Join button on the timeline line. Moved from `TimelineEvent.tsx`. */
     joinUrl?: (activity: ActivityOf<T>) => string | undefined;
 }
 export declare function stripHtml(input: string): string;
@@ -101,54 +81,51 @@ type Catalog = {
     [T in ActivityType]: ActivityTypeInfo<T>;
 };
 export declare const ACTIVITY_CATALOG: Catalog;
-/** Onbekende types (van een app die zijn type nog niet declareert) geven `undefined`. */
+/** Unknown types (from an app that has not declared its type yet) return `undefined`. */
 export declare function activityTypeInfo(type: string): ActivityTypeInfo | undefined;
-/** Lucide-icoonnaam; `circle` voor onbekende types. */
+/** Lucide icon name; `circle` for unknown types. */
 export declare function activityIconOf(type: string): string;
-/** `mail` | `chat` | `voice` | `video`, of `undefined` voor een levenscyclus-event. */
+/** `mail` | `chat` | `voice` | `video`, or `undefined` for a lifecycle event. */
 export declare function channelKindOf(type: string): ActivityChannelKind | undefined;
 /**
- * Draagt deze vorm een bericht of een interne notitie — iets wat een mens schreef en wat als
- * "het gesprek" telt? Sluit transcripten uit; die zijn wel tekst, maar geen bericht.
+ * Does this shape carry a message or internal note — human-written text that counts as
+ * "the conversation"? Excludes transcripts: text, but not messages.
  *
- * Op de **shape** en niet op het type, zodat er precies één definitie van "is dit een
- * bericht" bestaat. {@link isMessageType} beantwoordt hem voor de ingebouwde types;
- * `ActivityTypeRegistry.isMessage` doet hetzelfde voor een type dat een app declareerde.
- * Zonder die splitsing had elk van beide zijn eigen kopie van de regel gekregen — en dat is
- * precies hoe er twaalf hardgecodeerde typelijstjes door de codebase zijn ontstaan.
+ * Keyed on the **shape**, not the type, so exactly one definition of "is this a message"
+ * exists. {@link isMessageType} answers it for the built-in types;
+ * `ActivityTypeRegistry.isMessage` for app-declared ones. Without that split each would
+ * have grown its own copy of the rule — how the hardcoded type lists arose before.
  */
 export declare function isMessageShape(shape: ActivityShape | undefined): boolean;
-/** Zie {@link isMessageShape}. Voor de ingebouwde types. */
+/** See {@link isMessageShape}. For the built-in types. */
 export declare function isMessageType(type: string): boolean;
-/** Kan een mens hierop antwoorden? Notities niet — die gaan nergens heen. */
+/** Can a human reply to it? Not to notes — those go nowhere. */
 export declare function isReplyableType(type: string): boolean;
 /**
- * Leesbare inhoud voor een model: berichten, notities én transcripten. Ruimer dan
- * {@link isMessageType}, en dat verschil is opzettelijk — zie de dry-run van playbooks.
+ * Readable content for a model: messages, notes, and transcripts. Broader than
+ * {@link isMessageType}, and that difference is deliberate — see the playbook dry-run.
  */
 export declare function carriesText(type: string): boolean;
-/** Telt mee als in- of uitgaand bericht in de analytics-rollup. */
+/** Counts as an in- or outbound message in the analytics rollup. */
 export declare function messageCountsAs(type: string): "inbound_message" | "outbound_message" | undefined;
-/** Door de playbook-engine zelf geschreven; mag geen nieuwe run openen. */
+/** Written by the playbook engine itself; must not open a new run. */
 export declare function isPlaybookAuthoredType(type: string): boolean;
-/** Kwam er met dit type daadwerkelijk contact tot stand? Zie {@link ActivityTypeInfo.connected}. */
+/** Did this type establish actual contact? See {@link ActivityTypeInfo.connected}. */
 export declare function isConnectedType(type: string): boolean;
 /**
- * Is dit een transcript-achtig artefact — meegeleverde inhoud die leesbare tekst draagt?
- *
- * Het onderscheid met een bestand zit al in de catalogus (`FILE_UPLOADED` draagt geen tekst), dus
- * dit is geen nieuwe lijst maar een combinatie van twee bestaande antwoorden. Zo telt het
- * transcript van een externe provider mee zodra die app zijn type declareert, zonder dat hier een
- * naam bij hoeft.
+ * Transcript-like artifact — attached content that carries readable text. Not a new
+ * list but a combination of two existing catalog answers (`FILE_UPLOADED` carries no
+ * text), so an external provider's transcript counts as soon as its app declares the
+ * type, without adding a name here.
  */
 export declare function isTranscriptType(type: string): boolean;
-/** De inboxlijst-regel, of `""` wanneer het type er geen heeft. */
+/** The inbox-list line, or `""` when the type has none. */
 export declare function activitySnippet(activity: Activity): string;
 /**
- * De tijdlijnregel. Valt terug op het ontstreepte type — precies wat de feed vandaag doet
- * voor elk type zonder eigen tekst.
+ * The timeline line. Falls back to the de-underscored type — what the feed does today
+ * for any type without its own text.
  */
 export declare function activityTimelineText(activity: Activity, authorName: string): string;
-/** Deelnamelink op de tijdlijnregel, wanneer het type er een draagt. */
+/** Join link on the timeline line, when the type carries one. */
 export declare function activityJoinUrl(activity: Activity): string | undefined;
 export {};

package/dist/entities/activity/descriptor.d.ts

@@ -2,27 +2,26 @@ import { LocaleBundle } from '../analytics/dashboard';
 import { ActivityBlock } from './blocks';
 import { ActivityChannelKind, ActivityShape } from './catalog';
 /**
- * Wat een app over zijn eigen activity-soort declareert.
+ * What an app declares about its own activity kind.
  *
- * Dit is de JSON-tegenhanger van `ActivityTypeInfo`: dezelfde vragen, maar over de draad.
- * Waar de ingebouwde catalogus functies gebruikt voor zijn teksten, gebruikt een
- * gedeclareerd type een vertaalsleutel plus parameters — een functie overleeft geen
- * HTTP-hop, en een letterlijke zin is niet te vertalen.
+ * The JSON counterpart of `ActivityTypeInfo`: the same questions, but over the wire. Where the
+ * built-in catalog uses functions for its texts, a declared type uses a translation key plus
+ * parameters — a function does not survive an HTTP hop, and a literal sentence cannot be
+ * translated.
  */
 /**
- * Een stuk tekst in een descriptor.
+ * A piece of text in a descriptor.
  *
- * Twee vormen, omdat er twee soorten tekst zijn:
+ * Two shapes, because there are two kinds of text:
  *
- * - **chrome** — door de app geschreven ("Ticket #{number} aangemaakt"). Vertaalbaar, dus
- *   een sleutel met parameters. De plaatshouders staan ín de vertaalde zin, zodat de
- *   woordvolgorde per taal mag verschillen; zou je de tekst eromheen plakken, dan is dat
- *   precies wat er stukgaat.
- * - **data** — door een mens getypt (het onderwerp van het ticket). Valt niets te
- *   vertalen, dus een pad naar de waarde in de activity.
+ * - **chrome** — written by the app ("Ticket #{number} created"). Translatable, so a key with
+ *   parameters. The placeholders sit *inside* the translated sentence, so word order may differ
+ *   per language; gluing the text around them is exactly what breaks.
+ * - **data** — typed by a person (the ticket's subject). Nothing to translate, so a path to the
+ *   value in the activity.
  *
- * `format` bepaalt of de weergave de tekst als platte tekst neemt of door de rijke
- * renderer haalt. Nooit geraden: het staat op het tekstobject zelf.
+ * `format` decides whether the view takes the text as plain text or runs it through the rich
+ * renderer. Never guessed: it sits on the text object itself.
  */
 export type ActivityText = string | {
     key: string;
@@ -33,55 +32,55 @@ export type ActivityText = string | {
     format?: "plain" | "rich";
 };
 export interface ActivityTypeDescriptor {
-    /** Plat en app-geprefixt, bv. `HELPDESK_TICKET_ADDED`. */
+    /** Flat and app-prefixed, e.g. `HELPDESK_TICKET_ADDED`. */
     type: string;
-    /** Vertaalsleutel voor de naam van dit type (keuzelijsten, filters). */
+    /** Translation key for this type's name (pickers, filters). */
     displayNameKey: string;
-    /** Lucide-icoonnaam; werkt op web en native. */
+    /** Lucide icon name; works on web and native. */
     icon?: string;
     shape: ActivityShape;
     channelKind?: ActivityChannelKind;
     replyable?: boolean;
     countsAs?: "inbound_message" | "outbound_message";
     carriesText?: boolean;
-    /** Verschijnt in de trigger-keuzelijst van playbooks en webhooks. */
+    /** Appears in the trigger picker of playbooks and webhooks. */
     triggerable?: boolean;
     /**
-     * De regel voor de inboxlijst, de zoekindex en de assistent. **Altijd platte tekst**,
-     * los van hoe de rij eruitziet: opmaak hier lekt naar plekken die geen opmaak kunnen.
+     * The line for the inbox list, the search index and the assistant. **Always plain text**,
+     * regardless of how the row looks: markup here leaks into places that cannot render markup.
      */
     text?: ActivityText;
     /**
-     * Declaratieve blokken voor de feed. Rendert op web én mobiel, want er komt geen bundel
-     * aan te pas — en de host houdt de uitlijning, de avatar en de tijdstempel.
+     * Declarative blocks for the feed. Renders on web and mobile, because no bundle is involved —
+     * and the host keeps the alignment, the avatar and the timestamp.
      */
     render?: ActivityBlock[];
     /**
-     * Eigen component voor de feed, `"<app>:<Resource>"`. **Alleen web**: op native bestaat
-     * geen module federation, dus daar zakt de rij terug naar {@link render} of {@link text}.
+     * Own component for the feed, `"<app>:<Resource>"`. **Web only**: native has no module
+     * federation, so there the row falls back to {@link render} or {@link text}.
      */
     component?: `${string}:${string}`;
 }
-/** Wat de comms-app aan de client teruggeeft: de gedeclareerde types plus hun vertalingen. */
+/** What the comms app returns to the client: the declared types plus their translations. */
 export interface ActivityTypeCatalog {
     types: ActivityTypeDescriptor[];
     locales: LocaleBundle;
 }
-/** Wat een `activity-source` op `GET /provider/activity-types/describe` teruggeeft. */
+/** What an `activity-source` returns on `GET /provider/activity-types/describe`. */
 export interface ActivityTypeSourceDescription {
     types: ActivityTypeDescriptor[];
     locales?: LocaleBundle;
 }
-/** Leest `payload.number` / `author.name` uit een object; geeft "" als het pad niet bestaat. */
+/** Reads `payload.number` / `author.name` from an object; returns "" when the path is absent. */
 export declare function readPath(source: unknown, path: string): string;
 /**
- * Lost een `ActivityText` op tegen een activity.
+ * Resolves an `ActivityText` against an activity.
  *
- * Geeft `null` terug wanneer er niets te tonen is, zodat de aanroeper kan terugvallen in
- * plaats van een lege regel te tekenen.
+ * Returns `null` when there is nothing to show, so the caller can fall back instead of drawing an
+ * empty line.
  */
 export declare function resolveActivityText(text: ActivityText | undefined, activity: unknown, translate: (key: string, params?: Record<string, string>) => string): string | null;
-/** De parameters die een `ActivityText` uit de activity leest — voor een opgeslagen preview. */
+/** The parameters an `ActivityText` reads from the activity — for a stored preview. */
 export declare function activityTextParams(text: ActivityText | undefined, activity: unknown): {
     key: string;
     params: Record<string, string>;

package/dist/entities/activity/index.d.ts

@@ -1,8 +1,8 @@
-export * from './types';
 export * from './blocks';
 export * from './catalog';
 export * from './descriptor';
-export * from './resolve';
 export * from './preview';
+export * from './resolve';
 export * from './seen';
 export * from './timestamp';
+export * from './types';

package/dist/entities/activity/preview.d.ts

@@ -2,14 +2,14 @@ import { ActivityPreview } from '../interaction/types';
 import { ActivityTypeDescriptor } from './descriptor';
 import { Activity } from './types';
 /**
- * De regel die in de inboxlijst onder de afzender staat.
+ * The line under the sender in the inbox list.
  *
- * De per-type tekst zelf staat in {@link ACTIVITY_CATALOG}, niet hier: dezelfde vraag
- * werd op zes plekken los beantwoord en dreef uit elkaar. Hier blijft alleen wat écht
- * over de *preview* gaat — de lengtegrens en de velden die op de interactie belanden.
+ * The per-type text itself lives in {@link ACTIVITY_CATALOG}, not here: the same question was
+ * answered separately in six places and drifted apart. Only what is really about the *preview*
+ * stays here — the length limit and the fields that land on the interaction.
  *
- * `descriptor` is er voor types die een app zelf meebracht. Die dragen een vertaalsleutel
- * in plaats van een zin, en die sleutel wordt méé opgeslagen: de preview wordt eenmalig
- * server-side berekend, maar elke lezer heeft zijn eigen taal.
+ * `descriptor` is there for types an app brought itself. Those carry a translation key instead of
+ * a sentence, and that key is stored along: the preview is computed once server-side, but every
+ * reader has their own language.
  */
 export declare function buildActivityPreview(activity: Activity, descriptor?: ActivityTypeDescriptor): ActivityPreview;