@opencxh/domain 1.172.1 → 1.172.2

package/dist/platform/context.d.ts

@@ -18,19 +18,19 @@ export interface HostContext {
     /** Highest wins when multiple apps claim the same route. */
     priority?: number;
     /**
-     * De interactie waar dit oppervlak over gaat, als er één is.
+     * The interaction this surface is about, when there is one.
      *
-     * Als **veld** en niet als losse `slices`-sleutel: een paneel dat hierop leunt hoort te
-     * kunnen vertrouwen dat het er is. `CallTranscriptTab` hing zijn "Opslaan als notitie" hier
-     * al aan terwijl niemand het vulde, dus die knop was permanent uitgeschakeld — een
-     * toevallige sleutel geeft geen typefout, een ontbrekend veld wel.
+     * As a **field** and not as a loose `slices` key: a panel leaning on this should be able to
+     * trust it is there. `CallTranscriptTab` already hung its "save as note" off it while nobody
+     * filled it, so that button was permanently disabled — an accidental key gives no type error, a
+     * missing field does.
      */
     interactionId?: string;
     /**
-     * De **live** gesprekssessie, alleen gevuld zolang er een verbinding staat.
+     * The **live** call session, only filled while a connection stands.
      *
-     * Dit is de sleutel waarmee een paneel zich op `transcripts.deltas$(sessionId)` abonneert.
-     * Zonder dit veld toonde de transcript-tab altijd de lege staat, ongeacht wat er gezegd werd.
+     * This is the key a panel subscribes to `transcripts.deltas$(sessionId)` with. Without this
+     * field the transcript tab always showed the empty state, whatever was being said.
      */
     sessionId?: string;
     /** Extra data providers attach (e.g. interaction, activities, transcripts). */

package/dist/platform/identity.d.ts

@@ -1,14 +1,13 @@
 /**
- * Namens wie een actie gebeurt.
+ * Who an action happens on behalf of.
  *
- * Orthogonaal aan *wie* er belt (dat is `Caller` in `@opencxh/platform-api`): een
- * app kan bellen namens een gebruiker, namens een team, of namens de organisatie.
- * Een app-to-app call draagt van zichzelf geen bruikbare identiteit — de auth die
- * de runtime meestuurt is die van de oorspronkelijke beller, niet van degene
- * namens wie gehandeld wordt. Vandaar dit eigen, expliciete kanaal.
+ * Orthogonal to *who* is calling (that is `Caller` in `@opencxh/platform-api`): an app can call on
+ * behalf of a user, of a team, or of the organisation. An app-to-app call carries no usable
+ * identity of its own — the auth the runtime passes along is the original caller's, not that of
+ * whoever is being acted for. Hence this separate, explicit channel.
  *
- * `MutationAuthor` wordt hieruit *afgeleid* (attributie is een projectie van
- * identiteit), niet parallel bijgehouden. Zie `resolveAuthor`.
+ * `MutationAuthor` is *derived* from this (attribution is a projection of identity), not tracked in
+ * parallel. See `resolveAuthor`.
  */
 export type ActingIdentity = {
     kind: "user";
@@ -20,23 +19,21 @@ export type ActingIdentity = {
     kind: "org";
 };
 /**
- * Compacte, header-veilige vorm: `"user:<id>"` | `"team:<id>"` | `"org"`.
- * ASCII, geen JSON — een header hoort geen gestructureerde payload te dragen, en
- * dit blijft leesbaar in logs.
+ * Compact, header-safe form: `"user:<id>"` | `"team:<id>"` | `"org"`. ASCII, no JSON — a header
+ * should not carry a structured payload, and this stays readable in logs.
  */
 export declare function formatActingIdentity(actor: ActingIdentity): string;
 /**
- * Leest de compacte vorm terug. Strikt: een onbekende soort, een ontbrekende of
- * lege ref levert `undefined` — nooit een gok en nooit een half-gevulde identiteit
- * zoals `{ kind: "user", userId: "" }`, want die zou als geldig door een gate
- * glippen.
+ * Reads the compact form back. Strict: an unknown kind, a missing or empty ref yields `undefined` —
+ * never a guess and never a half-filled identity like `{ kind: "user", userId: "" }`, which would
+ * slip through a gate as valid.
  *
- * Round-trip: `parseActingIdentity(formatActingIdentity(a))` is diep gelijk aan `a`.
+ * Round-trip: `parseActingIdentity(formatActingIdentity(a))` deep-equals `a`.
  */
 export declare function parseActingIdentity(raw: string | null | undefined): ActingIdentity | undefined;
 /**
- * Stabiele sleutel om identiteiten te vergelijken of te dedupliceren (bijvoorbeeld
- * "één autorisatie-call per distincte actor"). Gelijk aan de wire-vorm; apart
- * genoemd omdat de bedoeling anders is dan transporteren.
+ * Stable key for comparing or deduplicating identities ("one authorization call per distinct
+ * actor", say). Identical to the wire form; named separately because the intent differs from
+ * transporting.
  */
 export declare function actingIdentityKey(actor: ActingIdentity): string;

package/dist/platform/kernel.d.ts

@@ -4,7 +4,7 @@ export interface PlatformContext {
     user: User | null;
     activeOrg: Organization | null;
     availableOrganizations: Organization[];
-    env: 'production' | 'staging' | 'dev';
+    env: "production" | "staging" | "dev";
     locale: string;
     isAuthenticated: boolean;
     isOrgSelected: boolean;

package/dist/platform/manifest.d.ts

@@ -53,7 +53,7 @@ export interface AppManifest<TSDK = any> {
     /**
      * The framework of the application.
      */
-    framework?: 'react' | 'svelte' | 'other';
+    framework?: "react" | "svelte" | "other";
     /**
      * Optional short description of the application.
      */
@@ -93,7 +93,7 @@ export interface AppManifest<TSDK = any> {
     /**
      * Optional documentation URL for the application.
      */
-    visibility?: 'public' | 'private';
+    visibility?: "public" | "private";
     /**
      * Defines the security permissions for this app. The SDK will deny any
      * action not explicitly granted here, following the principle of least privilege.

package/dist/platform/media.d.ts

@@ -1,4 +1,4 @@
-export type Speaker = 'local' | 'remote';
+export type Speaker = "local" | "remote";
 export interface AudioSegment {
     sessionId: string;
     speaker: Speaker;
@@ -10,14 +10,13 @@ export interface AudioSegment {
     avgRMS: number;
     isFinal: boolean;
     /**
-     * Dit segment begint midden in een lopende zin, omdat de VAD op
-     * `maxSpeechDurationMs` hard moest knippen in plaats van op een stilte.
+     * This segment starts mid-sentence, because the VAD had to cut hard on
+     * `maxSpeechDurationMs` instead of on a silence.
      *
-     * Dit is het enige geval waarin twee opeenvolgende segmenten elkaars tekst kunnen
-     * overlappen, en dus het enige geval waarin de naad geplakt moet worden. Een knip op
-     * stilte valt tussen twee woorden: daar valt niets te ontdubbelen. Zonder deze vlag
-     * moest de ontvanger dat verschil raden, en dat raden was de hele reden dat er drie
-     * fuzzy dedupe-lagen bestonden.
+     * The only case in which two consecutive segments can overlap each other's text, and therefore
+     * the only case in which the seam has to be glued. A cut on silence falls between two words:
+     * nothing to deduplicate there. Without this flag the receiver had to guess that difference, and
+     * that guessing was the whole reason three fuzzy dedupe layers existed.
      */
     continuesPrevious?: boolean;
 }
@@ -29,10 +28,9 @@ export interface TranscriptWord {
 export interface TranscriptSegment {
     sessionId: string;
     /**
-     * Alleen gezet als bekend is wie lokaal/remote spreekt (live calls). Bij
-     * batch- of gediarizeerde transcriptie weten we dat niet — dan blijft dit leeg
-     * en gebruikt de UI `speakerLabel`/`speakerId` als tag (Fireflies-stijl, geen
-     * links/rechts-alignment).
+     * Only set when it is known who speaks locally/remotely (live calls). With batch or diarized
+     * transcription we do not know — then this stays empty and the UI uses
+     * `speakerLabel`/`speakerId` as a tag (Fireflies style, no left/right alignment).
      */
     speaker?: Speaker;
     speakerId?: string;
@@ -44,7 +42,7 @@ export interface TranscriptSegment {
     endedAt: number;
     language?: string;
     confidence?: number;
-    /** Zie {@link AudioSegment.continuesPrevious} — reist mee zodat de store de naad kent. */
+    /** See {@link AudioSegment.continuesPrevious} — travels along so the store knows the seam. */
     continuesPrevious?: boolean;
 }
 export interface AudioPipelineOptions {
@@ -53,9 +51,9 @@ export interface AudioPipelineOptions {
     speechFrameRatio: number;
     silenceDurationMs: number;
     maxSpeechDurationMs: number;
-    /** Naad-overlap, uitsluitend toegepast na een harde `maxSpeechDurationMs`-knip. */
+    /** Seam overlap, applied only after a hard `maxSpeechDurationMs` cut. */
     overlapMs: number;
-    /** Audio die vóór de spraak-onset bewaard blijft, zodat de eerste klank niet wegvalt. */
+    /** Audio kept before the speech onset, so the first sound is not lost. */
     preRollMs: number;
 }
 export type MediaPermissionKind = "microphone" | "camera";

package/dist/platform/permission.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The platform-wide permission vocabulary — the only place permission strings are declared.
+ *
+ * The shape is the locked `resource.action` convention, dot-separated and WITHOUT an app prefix:
+ * the app key comes from the router (`routes(app, APP)` in platform-api passes it once), and
+ * grants in `auth.permissions` are grouped per app (`Record<app, string[]>`), so the string itself
+ * need not repeat the app. Verbs are `read` / `write` / `publish` — no create/update/delete split;
+ * `write` covers every mutation. A third segment (like `billing.write`) is field level within a
+ * resource.
+ *
+ * `as const` and not an enum or a loose union: the declaration sites want literal types (a typo in
+ * `permissions: ["inbox.wirte"]` has to go red), and the runtime value is needed for tests and
+ * later for seeding roles.
+ */
+export declare const APP_PERMISSIONS: {
+    readonly ai: readonly ["account.read", "account.write", "agent.read", "agent.write", "assignment.read", "budget.read", "budget.write", "connector.read", "connector.write", "context.read", "context.write", "conversation.read", "conversation.write", "lens.read", "lens.write", "message.read", "message.write", "playbook.read", "playbook.write", "profile.read", "profile.write", "run.read", "run.write", "settings.read", "settings.write", "tool.read", "transcript.write", "usage.read"];
+    readonly analytics: readonly ["report.read"];
+    readonly "app-store": readonly ["app.publish", "app.read", "app.write", "setting.read", "setting.write"];
+    readonly automations: readonly ["sync.read", "sync.write", "webhook.read", "webhook.write"];
+    readonly communication: readonly ["account.read", "account.write", "activity-type.read", "activity.read", "activity.write", "attachment.read", "attribute.read", "attribute.write", "calendar.read", "calendar.write", "channel.read", "channel.write", "custom-field.read", "custom-field.write", "folder.read", "folder.write", "inbox.read", "inbox.write", "interaction.read", "interaction.write", "reminder.read", "task.read", "task.write", "template.read", "template.write", "topic.read", "topic.write"];
+    readonly context: readonly ["kind.read", "kind.write", "memory.read", "memory.write"];
+    readonly crm: readonly ["company.read", "company.write", "contact.read", "contact.write"];
+    readonly "eylo-voip": readonly ["account.read", "account.write", "callflow.read", "callflow.write", "channel.read", "channel.write", "contact.read", "contact.write", "device.read", "device.write", "group.read", "group.write", "interaction.read", "interaction.write", "media.read", "media.write", "menu.read", "menu.write", "phone-number.read", "phone-number.write", "recording.read", "recording.write", "sip.read", "temporal-rule.read", "temporal-rule.write", "user.read", "user.write", "vmbox.read", "vmbox.write", "webhook.read", "webhook.write"];
+    readonly google: readonly ["account.read", "account.write", "contact.read"];
+    readonly kb: readonly ["article.read", "article.write", "category.read", "category.write", "help-center.read", "help-center.write", "kb.read", "kb.write"];
+    readonly mail: readonly ["account.write"];
+    readonly meta: readonly ["account.read", "account.write"];
+    readonly microsoft: readonly ["account.read", "account.write", "contact.read", "sync.write"];
+    readonly organization: readonly ["billing.read", "billing.write", "settings.read", "settings.write", "team.read", "team.write"];
+    readonly shopify: readonly ["account.read", "account.write", "order.read"];
+    readonly slack: readonly ["thread.read", "thread.write"];
+    readonly storage: readonly ["artifact.read", "artifact.write", "file.read", "file.write", "mount.read", "mount.write"];
+    readonly time: readonly ["entry.read", "entry.write", "work-type.read", "work-type.write"];
+    readonly user: readonly ["user.read", "user.write"];
+    readonly work: readonly ["item.read", "item.write", "project.read", "project.write"];
+};
+export type PermissionApp = keyof typeof APP_PERMISSIONS;
+/** One app's permission strings, as a literal union (`"inbox.read" | "inbox.write"`). */
+export type PermissionOf<A extends PermissionApp> = (typeof APP_PERMISSIONS)[A][number];

package/dist/platform/permission.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/platform/presence.d.ts

@@ -98,37 +98,37 @@ export interface AgeablePresence {
  */
 export declare function agePresenceEntry<T extends AgeablePresence>(entry: T, now: number): T;
 /**
- * Voor welk **team** iemand nu werkt.
+ * Which **team** someone is working for right now.
  *
- * De rol van een medewerker is een eigenschap van de persoon en niet van het gesprek: een
- * support-medewerker doet meestal één ding, en op een persoonlijk kanaal is er niets aan het
- * gesprek af te lezen. Deze instelling staat naast presence om dezelfde reden dat presence
- * bestaat — het is "hoe ben ik nu", niet "wie ben ik".
+ * An agent's role is a property of the person and not of the conversation: a support agent usually
+ * does one thing, and on a personal channel there is nothing to read off the conversation. This
+ * setting sits next to presence for the same reason presence exists — it is "how am I now", not
+ * "who am I".
  *
- * Waarde is een `teamId` en geen profielverwijzing: team is de scope waar profielen, onderwerpen,
- * workflows en inboxen al op gescoped zijn, en het is ook wat een gerouteerd gesprek oplevert
- * (`assignedInboxId` → `Inbox.teamId`). Eén keuze lost ze allemaal consistent op.
+ * The value is a `teamId` and not a profile reference: team is the scope profiles, topics,
+ * workflows and inboxes are already scoped on, and it is also what a routed conversation yields
+ * (`assignedInboxId` → `Inbox.teamId`). One choice resolves them all consistently.
  */
 export interface WorkMode {
     userId: string;
     teamId: string;
-    /** `"manual"` of een bron die het namens de gebruiker zette (een rooster, later). */
+    /** `"manual"` or a source that set it on the user's behalf (a schedule, later). */
     source: string;
 }
 /**
- * Voor welk team deze gebruiker nu werkt, en of hij daarvoor iets moet kiezen.
+ * Which team this user is working for right now, and whether they have to choose one first.
  *
- * Drie uitkomsten, en de derde is het hele punt:
+ * Three outcomes, and the third is the whole point:
  *
- * - **`teamId`** — óf expliciet gezet, óf impliciet omdat er maar één team is. Wie één ding doet
- *   hoeft nooit iets in te stellen.
- * - **`undefined` met `mustChoose: false`** — geen enkel team; er is niets te kiezen en niets te
- *   doen.
- * - **`undefined` met `mustChoose: true`** — meer dan één team en niets gekozen. Dan hoort een
- *   oppervlak dat op de rol leunt te **zwijgen** in plaats van er één te raden: fout gokken is
- *   erger dan niets tonen, en dat is dezelfde fail-closed regel als bij de account↔kanaal-binding.
+ * - **`teamId`** — either set explicitly, or implicit because there is only one team. Whoever does
+ *   one thing never has to configure anything.
+ * - **`undefined` with `mustChoose: false`** — no team at all; there is nothing to choose and
+ *   nothing to do.
+ * - **`undefined` with `mustChoose: true`** — more than one team and nothing chosen. A surface
+ *   leaning on the role should then **stay quiet** instead of guessing one: guessing wrong is
+ *   worse than showing nothing, the same fail-closed rule as the account↔channel binding.
  *
- * Pure functie, want dit is de enige echte beslissing in de werkmodus — de rest is opslag.
+ * A pure function, because this is the only real decision in the work mode — the rest is storage.
  */
 export declare function resolveWorkMode(stored: {
     teamId?: string;
@@ -137,20 +137,20 @@ export declare function resolveWorkMode(stored: {
     mustChoose: boolean;
 };
 /**
- * Mag de audio-pijplijn lopen — en dus: mag er meegelezen worden?
+ * May the audio pipeline run — and therefore: may anything listen along?
  *
- * Twee onafhankelijke voorwaarden, en dat is precies waarom dit een functie is en geen `&&` op
- * de plek van gebruik:
+ * Two independent conditions, which is exactly why this is a function and not an `&&` at the point
+ * of use:
  *
- * - **`providerAvailable`** — is er een STT-provider geregistreerd. Dat was tot nu toe de énige
- *   voorwaarde, en daarmee was "de AI-app is geïnstalleerd" hetzelfde als "we luisteren mee bij
- *   elk gesprek, org-breed". Een technische toevalligheid als beleid.
- * - **`allowed`** — wil de organisatie dat. Een assistent die ongevraagd meeleest hoort niet te
- *   bestaan zonder dat je hem kunt stoppen.
+ * - **`providerAvailable`** — is an STT provider registered. That used to be the *only* condition,
+ *   making "the AI app is installed" the same as "we listen in on every call, org-wide". A
+ *   technical accident as policy.
+ * - **`allowed`** — does the organisation want it. An assistant listening unasked should not exist
+ *   without a way to stop it.
  *
- * De gate wordt elke twee seconden opnieuw geasserteerd (federated remotes kunnen hun handler
- * later registreren dan deze app boot), dus een schakelaar die niet in deze functie zit racet
- * tegen die tik en gaat vanzelf weer aan.
+ * The gate is re-asserted every two seconds (federated remotes may register their handler later
+ * than this app boots), so a switch that is not inside this function races that tick and turns
+ * itself back on.
  */
 export declare function shouldRunAudioPipeline(input: {
     providerAvailable: boolean;

package/dist/platform/provider.d.ts

@@ -2,12 +2,11 @@ import { Interaction } from '../entities/interaction';
 import { Uri } from './communication';
 import { TranscriptSegment } from './media';
 export interface ProviderTranscribeResponse {
-    /** Volledige transcript-tekst (altijd aanwezig, backwards compatible). */
+    /** Full transcript text (always present, backwards compatible). */
     text: string;
     /**
-     * Segment-niveau transcript, alleen gevuld als `segments` was aangevraagd én de
-     * provider het ondersteunt. `sessionId` wordt door de consumer ingevuld (de
-     * provider kent de call-session niet).
+     * Segment-level transcript, only filled when `segments` was requested and the provider supports
+     * it. `sessionId` is filled in by the consumer (the provider does not know the call session).
      */
     segments?: TranscriptSegment[];
 }
@@ -17,14 +16,14 @@ export interface ComposePayload {
     channelId: string;
     channelUri?: Uri;
     /**
-     * Adressering-envelope. `to` verplicht (1+); `cc`/`bcc` alleen voor
-     * mail. Niet-mail providers gebruiken `to[0]`.
+     * Addressing envelope. `to` is required (1+); `cc`/`bcc` are mail only. Non-mail providers use
+     * `to[0]`.
      */
     recipients: import('./communication').RecipientList;
     subject?: string;
     /**
-     * Uitgaande bijlagen (base64 + filename + mimeType). Compose-handlers
-     * geven ze door aan de provider-send; metadata belandt op de Activity.
+     * Outgoing attachments (base64 + filename + mimeType). Compose handlers pass them to the
+     * provider send; the metadata lands on the Activity.
      */
     attachments?: import('./communication').OutgoingAttachment[];
     /**
@@ -121,17 +120,17 @@ export interface ListFilesPayload {
     path?: string;
 }
 /**
- * Kijken over mappen heen in plaats van in één map (`POST storage/file/browse`).
+ * Looking across folders instead of inside one (`POST storage/file/browse`).
  *
- * Geen `mountId` en geen `path`: de vraag is juist "waar dan ook waar ik mag
- * kijken". De server bepaalt zelf welke mappen dat zijn — zie `readableMounts`.
+ * No `mountId` and no `path`: the question is precisely "anywhere I am allowed to look". The
+ * server decides which folders those are — see `readableMounts`.
  */
 export interface BrowseFilesPayload {
-    /** Vrije tekst op de bestandsnaam; hoofdletterongevoelig, deelreeks. */
+    /** Free text on the file name; case-insensitive, substring. */
     name?: string;
-    /** `mine` beperkt tot wat je zelf hebt toegevoegd; standaard alles. */
+    /** `mine` restricts to what you added yourself; everything by default. */
     scope?: "all" | "mine";
-    /** Plafond op het aantal rijen; de server kapt hem af op zijn eigen maximum. */
+    /** Ceiling on the number of rows; the server truncates it at its own maximum. */
     limit?: number;
 }
 export interface DownloadAttachmentPayload {
@@ -139,6 +138,6 @@ export interface DownloadAttachmentPayload {
     accountId?: string;
     path?: string;
     id?: string;
-    /** Conversatie-id (Teams chatId) — nodig om chat-hostedContent te proxyen. */
+    /** Conversation id (Teams chatId) — needed to proxy chat hostedContent. */
     conversationId?: string;
 }

package/dist/platform/resource-source.d.ts

@@ -1,94 +1,92 @@
 /**
- * Aanwijsbare resources, over app-grenzen heen.
+ * Pointable resources, across app boundaries.
  *
- * Eén vraag die in dit platform steeds terugkwam en tot nu toe per geval werd opgelost: *welke
- * dingen kan ik hier aanwijzen, en hoe heten ze?* Een werkitem koppelen aan een gesprek, een
- * `resource_ref`-veld invullen, straks een bestand aanhaken — drie keer dezelfde vraag aan drie
- * verschillende apps.
+ * One question that kept coming back in this platform and was solved case by case until now:
+ * *which things can I point at here, and what are they called?* Linking a work item to a
+ * conversation, filling a `resource_ref` field, attaching a file later — the same question asked
+ * of three different apps three times.
  *
- * Het antwoord is een **contract op de servicebus**, niet een HTTP-providerrol: beide vragen
- * worden op de client gesteld door een gebruiker die de bron-app toch al open heeft, en die app
- * heeft zijn gesprekken en bedrijven al in een store staan. Een providerrol zou daar een
- * round-trip van maken voor gegevens die in het geheugen liggen.
+ * The answer is a **service-bus contract**, not an HTTP provider role: both questions are asked on
+ * the client by a user who has the source app open anyway, and that app already has its
+ * conversations and companies in a store. A provider role would turn that into a round trip for
+ * data sitting in memory.
  *
- * Drie sleutels, alle drie via `sdk.services.execute` (die de antwoorden van elke geïnstalleerde
- * app als array teruggeeft):
+ * Three keys, all three through `sdk.services.execute` (which returns the answers of every
+ * installed app as an array):
  *
- * | Sleutel | Params | Antwoord |
+ * | Key | Params | Answer |
  * |---|---|---|
  * | `resources.describe` | — | {@link ResourceSourceDescribe} |
  * | `resources.search` | {@link ResourceSearchParams} | {@link ResourceSummary}`[]` |
  * | `resources.resolve` | {@link ResourceResolveParams} | {@link ResourceSummary}`[]` |
  *
- * `describe` is niet cosmetisch: een kiezer tekent zijn soort-filters uit wat er daadwerkelijk
- * antwoordt. Zonder die call zou hij een vaste lijst tonen met tabbladen die leeg blijven zodra
- * een app niet geïnstalleerd is — precies de per-provider aanname die dit contract vermijdt.
+ * `describe` is not cosmetic: a picker draws its kind filters from what actually answers. Without
+ * that call it would show a fixed list with tabs that stay empty as soon as an app is not
+ * installed — exactly the per-provider assumption this contract avoids.
  */
-/** De servicebus-sleutels, als constante zodat een typefout niet stil een lege lijst oplevert. */
+/** The service-bus keys, as constants so a typo does not silently yield an empty list. */
 export declare const RESOURCE_DESCRIBE_SERVICE = "resources.describe";
 export declare const RESOURCE_SEARCH_SERVICE = "resources.search";
 export declare const RESOURCE_RESOLVE_SERVICE = "resources.resolve";
-/** Eén aanwijsbare resource, zoals de app die hem bezit hem toont. */
+/** One pointable resource, as the app that owns it shows it. */
 export interface ResourceSummary {
     /**
-     * `<kind>:<ref>` — dezelfde vorm die `ScopeAuth` autoriseert en `WorkLink.toKey` draagt.
+     * `<kind>:<ref>` — the same shape `ScopeAuth` authorizes and `WorkLink.toKey` carries.
      *
-     * Dit is de identiteit: twee aanbieders die dezelfde resource kennen (comms federeert
-     * adresboeken, crm heeft eigen contacten) leveren dezelfde sleutel, en een consument
-     * ontdubbelt daarop.
+     * This is the identity: two providers knowing the same resource (comms federates address books,
+     * crm has its own contacts) deliver the same key, and a consumer deduplicates on it.
      */
     scopeKey: string;
-    /** Het voorvoegsel van {@link ResourceSummary.scopeKey}, apart zodat filteren geen split vraagt. */
+    /** The prefix of {@link ResourceSummary.scopeKey}, separate so filtering needs no split. */
     kind: string;
     title: string;
-    /** Tweede regel: afzender, e-mailadres, bedrijfsnaam, statuslabel. */
+    /** Second line: sender, email address, company name, status label. */
     subtitle?: string;
-    /** Lucide-icoonnaam, zoals `TimeTarget.icon`. Afwezig = de consument kiest er zelf één bij de soort. */
+    /** Lucide icon name, like `TimeTarget.icon`. Absent = the consumer picks one for the kind. */
     icon?: string;
     /**
-     * Pad binnen de shell om deze resource te openen.
+     * Path inside the shell to open this resource.
      *
-     * Afwezig = de regel is niet aanklikbaar. Dat is bewust een aparte staat en geen gok: een
-     * verzonnen pad levert een doodlopende navigatie op, en dat is erger dan geen link.
+     * Absent = the row is not clickable. Deliberately a separate state and not a guess: an invented
+     * path yields a dead-end navigation, which is worse than no link.
      */
     href?: string;
-    /** Sorteerhint; recenter staat hoger. Afwezig telt als oudst. */
+    /** Sort hint; more recent ranks higher. Absent counts as oldest. */
     updatedAt?: number;
     /**
-     * Andere scopeKeys die bij deze resource horen — het contact en het bedrijf achter een
-     * gesprek, de klant achter een zaak.
+     * Other scopeKeys belonging to this resource — the contact and the company behind a
+     * conversation, the customer behind a case.
      *
-     * **De bron zegt het, de consument raadt het niet.** Comms weet dat een interactie
-     * `partyKeys` heeft; `apps/work` weet dat niet en hoort dat ook niet te weten. Zonder dit
-     * veld zou "neem het contact mee" in de koppel-flow een `if (kind === "interaction")` met
-     * een comms-specifieke veldnaam worden, en dat breekt bij de volgende aanbieder.
+     * **The source says it, the consumer does not guess it.** Comms knows an interaction has
+     * `partyKeys`; `apps/work` does not and should not. Without this field, "bring the contact
+     * along" in the link flow would become an `if (kind === "interaction")` with a comms-specific
+     * field name, and that breaks at the next provider.
      *
-     * Alleen één hop, en alleen wat de bron zelf al in handen heeft: dit is een hint voor een
-     * kiezer, geen graaf.
+     * One hop only, and only what the source already holds: this is a hint for a picker, not a graph.
      */
     related?: string[];
 }
-/** Antwoord op `resources.describe`: welke soorten deze app kan zoeken en oplossen. */
+/** Answer to `resources.describe`: which kinds this app can search and resolve. */
 export interface ResourceSourceDescribe {
     kinds: string[];
 }
-/** Params voor `resources.search`. */
+/** Params for `resources.search`. */
 export interface ResourceSearchParams {
-    /** Vrije tekst. Leeg = "wat is er recent", niet "alles". */
+    /** Free text. Empty = "what is recent", not "everything". */
     query: string;
-    /** Beperk tot deze soorten. Leeg/afwezig = alles wat de aanbieder heeft. */
+    /** Restrict to these kinds. Empty/absent = everything the provider has. */
     kinds?: string[];
-    /** Maximum per aanbieder, niet in totaal — de consument kapt zelf af na het ontdubbelen. */
+    /** Maximum per provider, not in total — the consumer truncates after deduplicating. */
     limit?: number;
 }
-/** Params voor `resources.resolve`: van sleutel naar leesbare rij. */
+/** Params for `resources.resolve`: from key to readable row. */
 export interface ResourceResolveParams {
     scopeKeys: string[];
 }
 /**
- * De soort uit een scopeKey, zonder de rest te hoeven splitsen.
+ * The kind out of a scopeKey, without having to split the rest.
  *
- * Losse helper en geen `splitScopeKey`-hergebruik: die zit in `platform-api` (server), en dit
- * contract wordt vooral op de client gelezen.
+ * A separate helper and not a reuse of `splitScopeKey`: that one sits in `platform-api` (server),
+ * and this contract is read mostly on the client.
  */
 export declare function resourceKindOf(scopeKey: string): string;