@opencxh/domain 1.171.0 → 1.172.2

package/dist/platform/communication.d.ts

@@ -1,21 +1,19 @@
-export type SessionState = 'idle' | 'ringing' | 'connecting' | 'connected' | 'on_hold' | 'ended' | 'failed';
+export type SessionState = "idle" | "ringing" | "connecting" | "connected" | "on_hold" | "ended" | "failed";
 /**
  * `"appName:ResourceName"` — how the platform addresses a federated resource.
- * Not to be confused with the read-state `ResourceRef`, which points at a
- * domain object rather than at a piece of UI.
+ * Not the read-state `ResourceRef`, which points at a domain object, not UI.
  */
 export type FederatedResourceRef = `${string}:${string}`;
 export interface Session {
     id: string;
     accountId: string;
     providerId: string;
-    direction: 'inbound' | 'outbound';
+    direction: "inbound" | "outbound";
     remoteIdentity: string;
     /**
-     * Number of remote participants, when the provider can report it. Used by
-     * transcript labeling: with more than one remote party the audio is a single
-     * mixed stream, so `remoteIdentity` can't be trusted to name the speaker and
-     * the label falls back to a generic one. Absent/1 = single remote party.
+     * Number of remote participants, when the provider can report it. With more
+     * than one remote party the audio is a single mixed stream, so transcript
+     * labeling falls back to a generic speaker label. Absent/1 = single remote party.
      */
     remoteParticipantCount?: number;
     state: SessionState;
@@ -25,9 +23,8 @@ export interface Session {
     actions: SessionAction[];
     /**
      * Provider-supplied externalId the transcript persistence should bind to.
-     * Server resolves this against `interaction.externalIds` (with an activity
-     * fallback). Lets providers point at the right interaction without the
-     * server needing to know their id shape.
+     * Server resolves it against `interaction.externalIds` (activity fallback),
+     * so providers need not know the server's id shape.
      */
     externalId?: string;
     ui: {
@@ -43,28 +40,23 @@ export interface CommsAccount<T = any> {
     organizationId: string;
     userId: string;
     config: T;
-    status: 'registered' | 'unregistered' | 'error';
+    status: "registered" | "unregistered" | "error";
     /**
-     * The channel this registration serves. Set by the transport provider from
-     * its registration config; this is what binds an outgoing intent on a
-     * channel to the right account when several are registered at once.
+     * The channel this registration serves; set by the transport provider from
+     * its registration config. Binds an outgoing intent on a channel to the
+     * right account when several are registered at once.
      */
     channelId?: string;
 }
 export interface ITransportProvider {
     readonly id: string;
     /**
-     * The ops this provider actually carries out, when it wants to say so.
-     *
-     * `dispatch` is a switch, so an op it has no case for returns quietly — the
-     * caller cannot tell "done" from "ignored". That is fine for a button the
-     * provider's own action tray never draws, but not for something the platform
-     * does on the user's behalf: auto-holding the previous call at a provider
-     * without hold would park a call that stays live.
-     *
-     * Undeclared means unknown, and unknown is tried anyway — that is the
-     * behaviour every provider had before this field existed. Declare it to be
-     * skipped rather than silently no-op'd.
+     * The ops this provider actually carries out. `dispatch` is a switch, so an
+     * op without a case returns quietly — the caller cannot tell "done" from
+     * "ignored". Harmless for a button the provider's tray never draws, but not
+     * for platform-initiated ops: auto-holding at a provider without hold would
+     * park a call that stays live. Undeclared means unknown, and unknown is
+     * tried anyway (pre-existing behaviour); declare to be skipped, not no-op'd.
      */
     readonly supportedOps?: readonly TransportOpKind[];
     subscribeSessions(callback: (sessions: Session[]) => void): () => void;
@@ -73,8 +65,8 @@ export interface ITransportProvider {
     registerAccount(orgId: string, userId: string, config: any): Promise<CommsAccount>;
     unregisterAccount(accountId: string): Promise<void>;
     /**
-     * Uniforme entry voor alle session-ops (invite/answer/hangup/hold/
-     * transfer/dtmf/set-stream).
+     * Uniform entry for all session ops (invite/answer/hangup/hold/transfer/
+     * dtmf/set-stream).
      */
     dispatch(op: TransportOp): Promise<void>;
 }
@@ -99,29 +91,25 @@ export declare enum CommunicationScheme {
     CALENDAR = "calendar"
 }
 /**
- * The colour-coded channel kinds the design system defines tokens for. This is
- * about *how you reach someone*, not about which product delivers it: Teams and
- * Telegram are both `chat`, SIP and a phone number are both `tel`.
+ * The colour-coded channel kinds the design system defines tokens for. About
+ * *how you reach someone*, not which product delivers it: Teams and Telegram
+ * are both `chat`, SIP and a phone number are both `tel`.
  */
 export type ChannelKind = "mail" | "wa" | "chat" | "tel" | "note";
 /** Channel kind for a scheme; anything unrecognised is neutral. */
 export declare function channelKindForScheme(scheme?: string | null): ChannelKind;
 /**
- * How a provider wants its channel drawn.
- *
- * Two routes, mirroring how apps ship translations. `icon`/`tone`/`label` are
- * declarative and travel in `/provider/describe`, so they work for a provider
- * with no frontend at all and on any surface where no bundle is loaded yet.
- * `resource` is the escape hatch: a federated component (`"app:Component"`)
- * that renders the provider's own mark and wins once it loads.
+ * How a provider wants its channel drawn. Two routes: `icon`/`tone`/`label`
+ * are declarative and travel in `/provider/describe`, so they work without a
+ * frontend or loaded bundle. `resource` is the escape hatch — a federated
+ * component (`"app:Component"`) that renders the provider's own mark and wins once loaded.
  */
 export interface ChannelPresentation {
     /** Lucide icon name, resolved by the host's icon renderer. */
     icon?: string;
     /**
-     * A {@link ChannelKind} to borrow that channel's colour, or any other
-     * stable string — a provider bringing its own channel gets a colour derived
-     * from it rather than collapsing onto the neutral tone.
+     * A {@link ChannelKind} to borrow that channel's colour, or any other stable
+     * string — a provider-owned channel gets a derived colour instead of the neutral tone.
      */
     tone?: ChannelKind | string;
     /** What to call this channel in the UI, e.g. "WhatsApp". */
@@ -130,38 +118,33 @@ export interface ChannelPresentation {
     resource?: string;
 }
 /**
- * Account selector for `transport: session` intents. Narrows the registered
- * `CommsAccount`s down to the one that should service this intent.
- *
- * `protocol` is the filter axis rather than a provider id because the two id
- * spaces don't line up: `channel.providerId` is the *server* provider (e.g.
- * eylo-voip) while `account.providerId` is the *transport* provider (e.g.
- * sip-provider). Which of the remaining candidates is picked is decided by the
- * binding on the account itself (`CommsAccount.channelId`) — `accountId` is
- * only a static pin for providers that have no per-channel binding.
+ * Account selector for `transport: session` intents — narrows registered
+ * `CommsAccount`s to the one servicing this intent. `protocol` is the filter
+ * axis rather than a provider id because the id spaces differ:
+ * `channel.providerId` is the *server* provider (e.g. eylo-voip),
+ * `account.providerId` the *transport* provider (e.g. sip-provider). The final
+ * pick comes from `CommsAccount.channelId`; `accountId` is only a static pin
+ * for providers without per-channel binding.
  */
 export interface AccountSelector {
     protocol: string;
     accountId?: string;
 }
 /**
- * Routing-hint voor de frontend en de comm-server: hoe wordt deze intent
- * uitgevoerd?
- *
+ * Routing hint for frontend and comm-server: how an intent executes.
  *  - `dispatch` — server-side via comm-server `provider/dispatch/` →
- *    `IProvider.dispatch(op)` op de provider-app's server. Dekt
- *    message.*, attachment.*, calendar.*, contact.* ServerOps.
- *  - `session` — client-side via `ITransportProvider.dispatch(op)` in
- *    de browser-UA (SIP/WebRTC). Geen server-roundtrip.
+ *    `IProvider.dispatch(op)` (message.*, attachment.*, calendar.*, contact.* ServerOps).
+ *  - `session` — client-side via `ITransportProvider.dispatch(op)` in the
+ *    browser UA (SIP/WebRTC); no server round-trip.
  */
 export type TransportConfig = {
     kind: "dispatch";
     /** Optional federated composer resource as "<app>:<resource>". */
     composer?: string;
     /**
-     * When true, comms-app `interaction/compose` skips its auto-create
-     * and lets the provider own interaction lifecycle (e.g. Teams chat
-     * upserts on a chatId externalId).
+     * When true, comms-app `interaction/compose` skips its auto-create and
+     * the provider owns interaction lifecycle (e.g. Teams chat upserts on a
+     * chatId externalId).
      */
     ownsInteraction?: boolean;
 } | {
@@ -175,24 +158,23 @@ export type TransportConfig = {
 /**
  * One user-facing intent a provider/channel can perform on a target.
  * `intent` is an open string — known values (call/mail/message/video) get
- * default UI/labels; new ones (`schedule`, `transfer`, `record`) render as
- * generic actions until a provider declares specialised UI.
+ * default UI/labels; new ones render as generic actions until a provider
+ * declares specialised UI.
  */
 export interface IntentCapability {
     intent: string;
     targetSchemes: CommunicationScheme[];
     transport: TransportConfig;
-    /** User mag deze intent aan/uit zetten per account. Default false (provider-locked). */
+    /** User may toggle this intent per account. Default false (provider-locked). */
     togglable?: boolean;
-    /** Default-state als togglable=true en user nog geen keuze maakte. Default true. */
+    /** Default state when togglable=true and the user has not chosen. Default true. */
     defaultEnabled?: boolean;
-    /** Optionele i18n-key voor toggle-label; UI valt anders terug op `cap_${intent}`. */
+    /** Optional i18n key for the toggle label; UI falls back to `cap_${intent}`. */
     labelKey?: string;
 }
 /**
- * Provider-level feature flag (no routing relevance). Used for things
- * like `call_hold`, `call_forward`, `message_reactions` that providers
- * advertise to feature-detect, but which are not user-pickable intents.
+ * Provider-level feature flag (no routing relevance) — e.g. `call_hold`,
+ * `message_reactions` — advertised for feature detection, not user-pickable intents.
  */
 export interface ProviderFeature {
     name: string;
@@ -208,46 +190,42 @@ export interface ProviderDescription {
     features: ProviderFeature[];
     /**
      * How this provider's channel is drawn. Optional: without it the UI falls
-     * back to the scheme's channel kind, which is what every surface did before
-     * providers could say anything about themselves.
+     * back to the scheme's channel kind.
      */
     presentation?: ChannelPresentation;
 }
 /**
- * Provider-feature names die de composer generiek interpreteert (geen
- * hardcoding per-provider). Een provider die `message_window` adverteert
- * heeft een tijdgebonden messaging-venster; `message_templates` betekent dat
- * er pre-approved templates beschikbaar zijn buiten dat venster.
+ * Provider-feature names the composer interprets generically (no per-provider
+ * hardcoding). `message_window` = time-bound messaging window;
+ * `message_templates` = pre-approved templates available outside that window.
  */
 export declare const PROVIDER_FEATURE_MESSAGE_WINDOW = "message_window";
 export declare const PROVIDER_FEATURE_MESSAGE_TEMPLATES = "message_templates";
-/**
- * Eén variabele in een provider-template (bv. WhatsApp HSM body-param `{{1}}`).
- */
+/** One variable in a provider template (e.g. WhatsApp HSM body param `{{1}}`). */
 export interface ProviderMessageTemplateVariable {
-    /** Stabiele key — voor WhatsApp de 1-based index als string ("1", "2", …). */
+    /** Stable key — for WhatsApp the 1-based index as string ("1", "2", …). */
     key: string;
-    /** Optioneel voorbeeld/placeholder uit de provider. */
+    /** Optional example/placeholder from the provider. */
     example?: string;
     label?: string;
 }
 /**
- * Pre-approved provider-template (WhatsApp HSM). De composer rendert per
- * `variables` een invoerveld; submit stuurt `templateId` + ingevulde waarden
- * mee. Los van de user-gemaakte canned-reply {@link MessageTemplate}.
+ * Pre-approved provider template (WhatsApp HSM). The composer renders an input
+ * per variable; submit sends `templateId` + filled values. Distinct from the
+ * user-made canned-reply {@link MessageTemplate}.
  */
 export interface ProviderMessageTemplate {
     id: string;
     name: string;
     language?: string;
-    /** Voorbeeld van de samengestelde body (variabelen als placeholders). */
+    /** Preview of the composed body (variables as placeholders). */
     bodyPreview?: string;
     category?: string;
     variables: ProviderMessageTemplateVariable[];
 }
 /**
- * Geldige tag waarmee buiten het standaard-venster tóch een vrij-tekst bericht
- * verstuurd mag worden (Messenger/Instagram message-tags, human-agent-tag).
+ * Tag that permits a free-text message outside the standard window
+ * (Messenger/Instagram message tags, human-agent tag).
  */
 export interface MessageTag {
     id: string;
@@ -255,18 +233,18 @@ export interface MessageTag {
     description?: string;
 }
 /**
- * Antwoord van `provider/message-context` (read-route op een dispatch-provider
- * met `message_window`/`message_templates`-features). Per interaction vertelt
- * dit de composer of vrij-tekst mag, en zo niet welke templates/tags er zijn.
+ * Response of `provider/message-context` (read route on a dispatch provider
+ * with `message_window`/`message_templates`). Tells the composer, per
+ * interaction, whether free text is allowed and otherwise which templates/tags exist.
  */
 export interface MessageContext {
-    /** Vrij-tekst toegestaan? false ⇒ composer forceert template of tag. */
+    /** Free text allowed? false ⇒ composer forces a template or tag. */
     windowOpen: boolean;
-    /** Epoch-ms waarop het venster sluit (indien open en bekend). */
+    /** Epoch ms when the window closes (if open and known). */
     windowExpiresAt?: number;
-    /** Beschikbare pre-approved templates (WhatsApp). */
+    /** Available pre-approved templates (WhatsApp). */
     templates?: ProviderMessageTemplate[];
-    /** Geldige message-tags (Messenger/Instagram). */
+    /** Valid message tags (Messenger/Instagram). */
     tags?: MessageTag[];
 }
 export interface PersonalAuthOption {
@@ -282,10 +260,10 @@ export interface PersonalAuthField {
     placeholder?: string;
 }
 /**
- * Describes how to connect a personal account for a provider.
- * - mode "redirect": user picks an option → OAuth redirect flow
- * - mode "form": user fills in fields → credentials submitted server-side
- * - mode "unavailable": provider does not support personal connections (or no options configured)
+ * How to connect a personal account for a provider.
+ * - "redirect": user picks an option → OAuth redirect flow
+ * - "form": user fills in fields → credentials submitted server-side
+ * - "unavailable": no personal connections (or no options configured)
  */
 export interface PersonalAuthDescription {
     mode: "redirect" | "form" | "unavailable";
@@ -304,27 +282,22 @@ export interface Uri {
     displayName?: string;
 }
 /**
- * Een Uri uitgebreid met identity-cache. Gebruikt voor remote counterparties
- * (afzender, ontvangers, meeting-attendees). Channels (eigen adressen) blijven
- * een plain `Uri`.
- *
- *  - `contactId`: resolved-hint, gezet door de server tijdens ingest. UI mag
- *    direct navigeren zonder lookup; voor live displayName/avatar blijft de
- *    Contact-entity de autoriteit.
- *  - `role`: rol van deze deelnemer in deze interactie. Open string; zie
- *    `InteractionParticipantRole` voor well-known waardes per kanaal.
- *
- * Niet te verwarren met `Participant` uit `entities/communication` — dat is
- * een live call-session-participant (muted/speaking/etc.).
+ * A Uri extended with an identity cache, used for remote counterparties
+ * (sender, recipients, meeting attendees); channels (own addresses) stay plain `Uri`.
+ * `contactId` is a resolved hint set by the server during ingest — UI may
+ * navigate without a lookup, but the Contact entity stays the authority for
+ * live displayName/avatar. `role` is an open string; see
+ * `InteractionParticipantRole` for well-known values. Not the live
+ * call-session `Participant` from `entities/communication`.
  */
 export interface InteractionParticipant extends Uri {
     contactId?: string;
     role?: string;
 }
 /**
- * Well-known rollen voor `InteractionParticipant.role`. Open string in het
- * type zodat provider-specifieke rollen geen domain-PR vereisen — gebruik
- * deze constants wanneer het kanaal een standaardrol kent.
+ * Well-known roles for `InteractionParticipant.role`. The type stays an open
+ * string so provider-specific roles need no domain PR; use these constants
+ * when the channel has a standard role.
  */
 export declare const InteractionParticipantRole: {
     readonly FROM: "from";
@@ -340,27 +313,20 @@ export declare const InteractionParticipantRole: {
     readonly HOST: "host";
     readonly PARTICIPANT: "participant";
 };
-export type InteractionParticipantRoleValue = typeof InteractionParticipantRole[keyof typeof InteractionParticipantRole];
+export type InteractionParticipantRoleValue = (typeof InteractionParticipantRole)[keyof typeof InteractionParticipantRole];
 /** Props the host passes to a provider's `ui.actionTray` resource. */
 export interface CallActionTrayProps {
     session: Session;
     account?: CommsAccount;
     /**
      * Resource currently shown in place of `ui.canvas`, or null for the canvas
-     * itself. The canvas and the tray are separate federated resources and
-     * cannot hold state between them, so the host holds this one value and both
-     * sides speak the same currency they already use for `ui.canvas`: a
-     * resource reference.
-     *
-     * Deliberately a reference and not an enum of known panels. A keypad or a
-     * transfer form is not the same everywhere — a provider that transfers to a
-     * directory rather than to a dialled number points this at its own
-     * resource, and a provider that can do neither leaves the affordance out.
-     * `communication:CallKeypad` and `communication:CallTransfer` are there to
-     * be reused by any provider that wants the plain ones.
-     *
-     * Both are absent when the host does not support overriding the canvas; a
-     * tray must then not offer the affordance.
+     * itself. Canvas and tray are separate federated resources with no shared
+     * state, so the host holds this one value as a resource reference.
+     * Deliberately a reference, not an enum of known panels: a keypad or
+     * transfer form differs per provider — one may transfer via a directory and
+     * point at its own resource; one that can't leaves the affordance out.
+     * `communication:CallKeypad`/`communication:CallTransfer` are reusable plain ones.
+     * Both props absent = host does not support overriding; tray must not offer it.
      */
     canvasOverride?: FederatedResourceRef | null;
     onCanvasOverride?: (resource: FederatedResourceRef | null) => void;
@@ -385,18 +351,16 @@ export interface RemoteStreamEvent {
     sessionId: string;
     streamId: string;
     stream: MediaStream | null;
-    speaker?: 'local' | 'remote';
+    speaker?: "local" | "remote";
     label?: string;
 }
 /**
- * Peer-to-peer WebRTC signaling envelope. Exchanged between two users in the
- * same tenant to negotiate a direct call — the media (audio) flows P2P; only
- * these small SDP/ICE setup messages transit the server (relayed 1:1 via
- * `Bridge.sse.push`). Transient: never persisted.
- *
+ * Peer-to-peer WebRTC signaling envelope between two users in the same tenant.
+ * Media flows P2P; only these small SDP/ICE messages transit the server
+ * (relayed 1:1 via `Bridge.sse.push`). Transient: never persisted.
  *  - `offer`/`answer` → `data` is an `RTCSessionDescriptionInit`.
- *  - `ice`            → `data` is an `RTCIceCandidateInit` (or `null` = end-of-candidates).
- *  - `bye`            → `data` omitted; the sender tore the call down.
+ *  - `ice` → `data` is an `RTCIceCandidateInit` (or `null` = end-of-candidates).
+ *  - `bye` → `data` omitted; the sender tore the call down.
  */
 export type WebRtcSignalKind = "offer" | "answer" | "ice" | "bye" | "request";
 /** Request body the initiator/answerer POSTs to the signaling relay. */
@@ -410,17 +374,16 @@ export interface WebRtcSignalRequest {
     /** Sender display name, so the peer can label the call UI without a lookup. */
     fromName?: string;
     /**
-     * Which peer connection this signal belongs to. `call` (default) is an audio
-     * session handled by the transport provider; `file` is an AirDrop-style
-     * RTCDataChannel transfer handled by the file-beam service; `monitor` is a
-     * one-way "listen along" forward handled by the call-monitor service. Lets
-     * one relay serve all three without the connection types colliding.
+     * Which peer connection this signal belongs to: `call` (default) = audio
+     * session via the transport provider; `file` = RTCDataChannel transfer via
+     * the file-beam service; `monitor` = one-way "listen along" via the
+     * call-monitor service. One relay serves all three without collisions.
      */
     channel?: "call" | "file" | "monitor";
 }
 /**
- * Broadcast (event `webrtc:callstate`) telling the tenant whether a user is
- * currently on a call, so a supervisor can see who is available to listen in.
+ * Broadcast (event `webrtc:callstate`) telling the tenant whether a user is on
+ * a call, so a supervisor can see who is available to listen in.
  */
 export interface CallStateChange {
     userId: string;
@@ -428,8 +391,8 @@ export interface CallStateChange {
 }
 /**
  * One ICE server entry. Structurally a subset of the browser's `RTCIceServer`,
- * but kept DOM-free so the comm server can build it too (server tsconfig has no
- * DOM lib). The client passes these straight to `new RTCPeerConnection`.
+ * but kept DOM-free so the comm server (no DOM lib) can build it too. The
+ * client passes these straight to `new RTCPeerConnection`.
  */
 export interface IceServerConfig {
     urls: string | string[];
@@ -437,8 +400,8 @@ export interface IceServerConfig {
     credential?: string;
 }
 /**
- * Response of `GET /webrtc/ice`: the STUN list plus TURN servers with
- * short-lived (per-user, time-limited) credentials, and how long they last.
+ * Response of `GET /webrtc/ice`: STUN list plus TURN servers with short-lived
+ * per-user credentials.
  */
 export interface IceConfigResponse {
     iceServers: IceServerConfig[];
@@ -451,8 +414,8 @@ export interface WebRtcSignalEvent extends WebRtcSignalRequest {
     from: string;
 }
 /**
- * Helper voor compactere intent-declaraties in `/provider/describe`.
- *   defineIntent("mail", { targetSchemes: [MAILTO], transport: { kind: "dispatch" } })
+ * Helper for compact intent declarations in `/provider/describe`:
+ * `defineIntent("mail", { targetSchemes: [MAILTO], transport: { kind: "dispatch" } })`
  */
 export declare const defineIntent: (intent: string, opts: Omit<IntentCapability, "intent">) => IntentCapability;
 export interface ExternalId {
@@ -476,27 +439,26 @@ export interface MessageBody {
     }>;
 }
 /**
- * Adressering-envelope voor message-ops. Mail honoreert cc/bcc;
- * chat/SMS gebruikt alleen `to[0]`. Providers droppen velden die ze
- * niet ondersteunen.
+ * Addressing envelope for message ops. Mail honours cc/bcc; chat/SMS uses only
+ * `to[0]`. Providers drop fields they don't support.
  */
 export interface RecipientList {
-    /** 1+ primary recipients (verplicht). */
+    /** 1+ primary recipients (required). */
     to: Uri[];
-    /** Carbon-copy. Alleen mail-flow. */
+    /** Carbon copy. Mail flow only. */
     cc?: Uri[];
-    /** Blind carbon-copy. Alleen mail-flow. */
+    /** Blind carbon copy. Mail flow only. */
     bcc?: Uri[];
 }
 /**
- * Uitgaande bijlage zoals de client 'm aanlevert: base64-content + naam +
- * mime-type. `content` is kale base64 (geen `data:`-prefix). Providers embedden
- * de string direct (Graph `contentBytes`, Gmail MIME-part) zonder re-encode.
+ * Outgoing attachment as the client supplies it. `content` is bare base64 (no
+ * `data:` prefix); providers embed the string directly (Graph `contentBytes`,
+ * Gmail MIME part) without re-encoding.
  */
 export interface OutgoingAttachment {
     filename: string;
     mimeType: string;
-    /** Kale base64, zonder `data:<mime>;base64,`-prefix. */
+    /** Bare base64, without `data:<mime>;base64,` prefix. */
     content: string;
 }
 export interface NoteBody {
@@ -525,9 +487,9 @@ export interface CalendarEventInput {
     };
 }
 /**
- * Server-side ops uitgevoerd door de provider-app's server, getriggerd
- * door comm-server `provider/dispatch/`. Payloads dragen IDs, geen
- * volledige entities — provider resolved zelf via platform-api.
+ * Server-side ops executed by the provider app's server, triggered by
+ * comm-server `provider/dispatch/`. Payloads carry IDs, not full entities —
+ * the provider resolves them itself via platform-api.
  */
 export type ServerOp = {
     kind: "message.new";
@@ -541,7 +503,7 @@ export type ServerOp = {
     interactionId: string;
     activityId?: string;
     body: MessageBody;
-    /** Override van default reply-targets (bv. reply-all). */
+    /** Overrides the default reply targets (e.g. reply-all). */
     recipients?: RecipientList;
 } | {
     kind: "message.comment";
@@ -624,11 +586,11 @@ export type ServerOp = {
     folderName?: string;
 };
 /**
- * Folder-DTO's — transport-shapes voor de generieke folder-capability.
- * Bewust géén persisted entities: de folder-tree en previews worden live
- * bij de provider opgehaald (TTL-cached client-side), nooit bulk-opgeslagen.
- * Providers mappen hun eigen model hierop: Outlook `mailFolders`,
- * Gmail `labels`, IMAP `folders`.
+ * Folder DTOs — transport shapes for the generic folder capability.
+ * Deliberately NOT persisted entities: the folder tree and previews are
+ * fetched live from the provider (TTL-cached client-side), never bulk-stored.
+ * Providers map their own model onto this (Outlook `mailFolders`, Gmail
+ * `labels`, IMAP `folders`).
  */
 export interface FolderNode {
     id: string;
@@ -652,14 +614,14 @@ export interface FolderMessagePreview {
 }
 export interface FolderMessagePage {
     items: FolderMessagePreview[];
-    /** Opaque provider-cursor (bv. Graph `@odata.nextLink`). Afwezig = laatste pagina. */
+    /** Opaque provider cursor (e.g. Graph `@odata.nextLink`). Absent = last page. */
     nextCursor?: string;
 }
 /**
- * Een zoekbare externe bron (channel) voor de client-fan-out. Retourneerd door
- * `GET /search/sources`: elke door de user toegankelijke, ingeschakelde channel
- * waarvan de provider `FEATURE_REMOTE_SEARCH` declareert. De client vuurt per
- * bron parallel een `POST /search/mailbox` af (non-blocking).
+ * A searchable external source (channel) for the client fan-out. Returned by
+ * `GET /search/sources`: every user-accessible enabled channel whose provider
+ * declares `FEATURE_REMOTE_SEARCH`. The client fires a parallel
+ * `POST /search/mailbox` per source (non-blocking).
  */
 export interface MailboxSearchSource {
     channelId: string;
@@ -667,23 +629,22 @@ export interface MailboxSearchSource {
     displayName: string;
 }
 /**
- * Well-known `ProviderFeature.name` voor de folder-capability. Een provider die
- * folder.list/messages/import/move ondersteunt zet `{ name: FEATURE_FOLDER_MANAGEMENT, value: true }`
- * in `describe().features`; de client toont dan de Folders-nav voor dat channel.
+ * Well-known `ProviderFeature.name` for the folder capability. A provider
+ * supporting folder.list/messages/import/move sets it true in
+ * `describe().features`; the client then shows the Folders nav for that channel.
  */
 export declare const FEATURE_FOLDER_MANAGEMENT = "folder_management";
 /**
- * Well-known `ProviderFeature.name` voor de remote-search-capability. Een provider
- * die `mailbox.search` ondersteunt (de externe bron zelf doorzoeken, bv. Outlook
- * Graph `$search` of IMAP `SEARCH`) zet `{ name: FEATURE_REMOTE_SEARCH, value: true }`
- * in `describe().features`. De comm-server neemt de channels van zo'n provider mee
- * in `GET /search/sources`; de client fan-out er parallel op via `POST /search/mailbox`.
+ * Well-known `ProviderFeature.name` for remote search (`mailbox.search`, e.g.
+ * Outlook Graph `$search` or IMAP SEARCH). The comm-server includes such
+ * channels in `GET /search/sources`; the client fans out via `POST /search/mailbox`.
  */
 export declare const FEATURE_REMOTE_SEARCH = "remote_search";
 /**
- * Result-shape voor `IProvider.dispatch` en de comm-server `dispatchToProvider`-
- * helper. Discriminated op `ok`. Bewust niet strict-null-discriminated zodat
- * narrowing ook werkt zonder strictNullChecks (root tsconfig is non-strict).
+ * Result shape for `IProvider.dispatch` and the comm-server
+ * `dispatchToProvider` helper, discriminated on `ok`. Deliberately not
+ * strict-null-discriminated so narrowing also works without strictNullChecks
+ * (root tsconfig is non-strict).
  */
 export interface ServerResult<T = unknown> {
     ok: boolean;
@@ -694,13 +655,13 @@ export interface ServerResult<T = unknown> {
     message?: string;
 }
 export declare const UNSUPPORTED: ServerResult;
-/**
- * Transport-ops uitgevoerd in de browser-UA (SIP/WebRTC), getriggerd
- * door de frontend via `ITransportProvider.dispatch`. Geen server-
- * roundtrip — directe controle over de lokale stack.
- */
 /** The `kind` of a {@link TransportOp} — what a provider declares support for. */
 export type TransportOpKind = TransportOp["kind"];
+/**
+ * Transport ops executed in the browser UA (SIP/WebRTC), triggered by the
+ * frontend via `ITransportProvider.dispatch`. No server round-trip — direct
+ * control over the local stack.
+ */
 export type TransportOp = {
     kind: "session.invite";
     accountId: string;
@@ -757,10 +718,10 @@ export interface OAuthConfig {
     authorizeEndpoint: string;
     tokenEndpoint: string;
     clientId: string;
-    /** Server-side only — uit provider's secret-store. Mag leeg blijven voor PKCE. */
+    /** Server-side only — from the provider's secret store. May stay empty for PKCE. */
     clientSecret?: string;
     scopes: string[];
-    /** Extra params voor authorize-URL (prompt, access_type, etc.). */
+    /** Extra params for the authorize URL (prompt, access_type, etc.). */
     authorizeParams?: Record<string, string>;
     refresh?: {
         bufferMs?: number;
@@ -791,35 +752,33 @@ export interface FormAuthCtx {
     organizationId: string;
 }
 /**
- * Server-side contract per communication-provider. Provider-apps
- * registreren zich via `Bridge.providers.role({ type: "provider", group: "communication" })`
- * en exposen routes die overeenkomen met deze methods (comm-server roept ze
- * via Bridge.rpc aan).
- *
- * Niet bedoeld voor frontend-consumptie — frontend praat alleen met
- * comm-server's `provider/*` en `account/*` endpoints.
+ * Server-side contract per communication provider. Provider apps register via
+ * `Bridge.providers.role({ type: "provider", group: "communication" })` and
+ * expose routes matching these methods (comm-server calls them via Bridge.rpc).
+ * Not for frontend consumption — the frontend talks only to comm-server's
+ * `provider/*` and `account/*` endpoints.
  */
 export interface IProvider {
     readonly id: string;
     describe(): Promise<ProviderDescription>;
     listChannels(orgId: string, userId?: string): Promise<unknown[]>;
     /**
-     * Comm-server vraagt provider om huidige auth-config. Reden om dit op
-     * IProvider te houden (i.p.v. statische registratie): clientId/secret/
-     * scopes komen vaak uit secret-store of tenant-config — niet code-statisch.
+     * Comm-server asks the provider for its current auth config. Kept on
+     * IProvider (rather than static registration) because clientId/secret/scopes
+     * often come from a secret store or tenant config, not code.
      */
     personalAuth(ctx: PersonalAuthCtx): Promise<PersonalAuthConfig>;
     /**
-     * Voor `mode: "form"` — provider valideert credentials en bouwt het
-     * Account zelf. OAuth-mode hoeft dit niet; comm-server handelt token-
-     * exchange volledig.
+     * For `mode: "form"` — the provider validates credentials and builds the
+     * Account itself. OAuth mode doesn't need this; comm-server handles token
+     * exchange fully.
      */
     completeFormAuth?(fields: Record<string, string>, ctx: FormAuthCtx): Promise<{
         accountId: string;
     }>;
     /**
-     * Post-connect hook — provider mag eigen vervolgwerk doen (bv. MS
-     * user-connection channel-binding) NA dat het Account is opgeslagen.
+     * Post-connect hook — provider may do follow-up work (e.g. MS
+     * user-connection channel binding) AFTER the Account is saved.
      */
     onAccountConnected?(account: {
         id: string;