@opencxh/domain 1.172.1 → 1.173.0

package/dist/entities/assignment/types.d.ts

@@ -1,150 +1,136 @@
 import { ResourceRef } from '../../platform/resource';
-import { Activity } from '../activity/types';
+import { FeedActivity } from '../activity/types';
 import { WaitingOn } from '../playbook/types';
 /**
- * Een **opdracht**: werk dat aan een agent is toegewezen en zo lang leeft als het werk.
+ * An **assignment**: work handed to an agent, living as long as the work does.
  *
- * **Waarom dit een entity is.** Het was er geen: `plans/unify-ai.md` besliste "een opdracht *is*
- * een run met een procedure, een agent als actor en een lange levensduur". Dat is verdedigbaar
- * gedacht, en de code liet zien wat het kostte:
+ * **Why this is an entity.** It was not one — an assignment used to be a run with a procedure, an
+ * agent as actor and a long lifetime. Defensible, and the code showed what it cost: every
+ * procedure run was cut short at `{ status: "done" }`, so an assignment was structurally **one
+ * model turn**; the thread shared no memory with the agent, so what a person wrote in it never
+ * reached the agent and the other way round; `retry` meant "redo the whole assignment from the
+ * original trigger", sensible for a workflow of seconds and nonsense for work running for days;
+ * and "what kind of thing is this" had to be derived from the execution shape.
  *
- * - `resume-playbook.ts` kortte elke procedure-run af op `{ status: "done" }`, dus een opdracht was
- *   structureel **één modelbeurt**;
- * - de draad (een `AIConversation` op `playbook-run:<id>`) deelde géén geheugen met de agent:
- *   `runProcedure` gaf bewust geen `conversationId` mee, dus wat een mens in de draad zei bereikte
- *   de agent nooit en omgekeerd;
- * - `retry` betekende "doe de hele opdracht opnieuw vanaf de originele trigger" — zinnig voor een
- *   workflow van seconden, onzin voor werk dat dagen liep;
- * - en "wat voor ding is dit" moest uit de *uitvoeringsvorm* worden afgeleid
- *   (`decider.kind === "procedure"`), dus de vorm deed dienst als producttype.
- *
- * Nu is een opdracht wat hij is, en een run wat die is: **één beurt**. De opdracht leeft, de runs
- * zijn wat hij deed.
+ * Now an assignment is what it is, and a run is what it is: **one turn**.
  */
 /**
- * Waar een opdracht in verkeert.
+ * The state an assignment is in.
  *
- * Bewust dezelfde woorden als de eindstanden van een run, en bewust minder: een opdracht kan niet
- * `failed` zijn. Een gefaalde beurt is een gefaalde run — de opdracht staat dan nog open, want er
- * is niets afgehandeld. Dat verschil is precies waarom dit een eigen vocabulaire is.
+ * Deliberately the same words as a run's end states, and deliberately fewer: an assignment cannot
+ * be `failed`. A failed turn is a failed run — the assignment is then still open, because nothing
+ * was handled. That difference is exactly why this is its own vocabulary.
  */
 export type AssignmentStatus = "open" | "waiting" | "done" | "escalated";
 export declare const TERMINAL_ASSIGNMENT_STATUSES: readonly ["done", "escalated"];
 export declare function isAssignmentTerminal(status: AssignmentStatus | string): boolean;
 /**
- * De scope-soort waaronder de draad van een opdracht leeft.
- *
- * Was `playbook-run:<id>`, want de draad hing aan een run. Hij hangt nu aan de opdracht, en dat is
- * het hele punt: een draad die stopt zodra één beurt klaar is, is geen draad.
+ * The scope kind an assignment's thread lives under. It hangs on the assignment, not on a
+ * single run — a thread that stops when one turn finishes is no thread.
  *
- * Staat in domain omdat het een **contract tussen client en server** is: de client bouwt de
- * sleutel om de draad te openen, de server autoriseert hem. Twee plekken die het voorvoegsel los
- * uitschrijven lopen bij de eerste typefout stil uiteen — en het gevolg daarvan is "geen toegang
- * tot deze scope", niet een foutmelding die het zegt.
+ * In domain because it is a **contract between client and server**: the client builds the key to
+ * open the thread, the server authorizes it. Two places spelling the prefix out separately drift
+ * apart silently on the first typo — and the result of that is "no access to this scope", not an
+ * error message saying so.
  */
 export declare const ASSIGNMENT_SCOPE_KIND = "assignment";
 export declare function assignmentScopeKey(assignmentId: string): string;
 export interface Assignment {
     id: string;
     organizationId: string;
-    /** De agent die dit doet: het `userId` van een gebruiker met `type: "agent"`. */
+    /** The agent doing this: the `userId` of a user with `type: "agent"`. */
     agentId: string;
-    /** De definitie waar deze opdracht uit voortkomt (een playbook met een procedure). */
+    /** The definition this assignment came from (a playbook with a procedure). */
     jobId: string;
     /**
-     * De versie waarmee hij begon — puur voor de audit.
+     * The version it started on — purely for the audit.
      *
-     * Elke **beurt** pint zijn eigen procedure (`run.decider`), dus een verbeterde prose komt bij de
-     * volgende beurt aan zonder een lopende beurt van opdracht te laten wisselen. Eeuwig pinnen zou
-     * betekenen dat een correctie nooit aankomt; niet pinnen dat een beurt halverwege verandert.
+     * Every **turn** pins its own procedure (`run.decider`), so improved prose arrives on the next
+     * turn without a running turn switching instructions mid-flight. Pinning forever would mean a
+     * correction never arrives; not pinning would mean a turn changes halfway.
      */
     jobVersion: number;
-    /** Waar deze opdracht over gaat. Afwezig = werk zonder resource (een rollup, een klus). */
+    /** What this assignment is about. Absent = work without a resource (a rollup, a chore). */
     subjectKind?: string;
     subjectId?: string;
     status: AssignmentStatus;
     /**
-     * Waarop de **opdracht** wacht tussen twee beurten.
+     * What the **assignment** is waiting on between two turns.
      *
-     * Bewust hier en niet op de run, want het zijn twee verschillende soorten pauze:
+     * Deliberately here and not on the run, because they are two different kinds of pause:
      *
-     * - een **workflow** pauzeert *midden in een flow* en hervat op stap N+1 met dezelfde vars — de
-     *   cursor (`run.resumeAtStep`) is essentieel;
-     * - een **opdracht** heeft geen cursor. "Hervatten" is *nog een beurt nemen*, met de draad als
-     *   geheugen.
+     * - a **workflow** pauses *mid-flow* and resumes at step N+1 with the same vars — the cursor
+     *   (`run.resumeAtStep`) is essential;
+     * - an **assignment** has no cursor. "Resuming" is *taking another turn*, with the thread as
+     *   memory.
      *
-     * Dat die twee in één veld geperst zaten is waarom elke procedure-run `resumeAtStep: 0` opsloeg.
+     * Squeezing those two into one field is why every procedure run stored `resumeAtStep: 0`.
      */
     waitingOn?: WaitingOn | null;
-    /** De soort van `waitingOn` als platte kolom — de store kan niet in een genest object zoeken. */
+    /** The kind of `waitingOn` as a flat column — the store cannot search inside a nested object. */
     waitingOnKind?: WaitingOn["on"] | null;
     /**
-     * Hoeveel beurten deze opdracht al heeft gehad.
-     *
-     * Was `run.rounds`, wat het aantal keer parkeren *binnen één run* telde. Op dit niveau is het de
-     * teller die telt: een agent die met een mens heen en weer blijft pingpongen moet een plafond
-     * hebben.
+     * How many turns this assignment has had — counted at assignment level, because an agent
+     * ping-ponging with a human needs a ceiling.
      */
     turns: number;
-    /** De draad: agent én mens schrijven hierin. Dit is de toestand van de opdracht. */
+    /** The thread: agent and human both write in it. This is the assignment's state. */
     conversationId: string;
-    /** Lijst-index, geen autorisatie — zie `PlaybookRun.visibleTo`. */
+    /** List index, not authorization — see `PlaybookRun.visibleTo`. */
     visibleTo?: string[];
-    /** Waar deze opdracht over gaat, in mensentaal. Voor de lijst. */
+    /** What this assignment is about, in human words. For the list. */
     title?: string;
     /**
-     * Waaróm de opdracht in deze stand staat, als er iets uit te leggen is.
+     * *Why* the assignment is in this state, when there is something to explain.
      *
-     * `decideAssignmentState` rekende dit al uit en niets bewaarde het, dus je zag `escalated` zonder
-     * uitleg — precies de vraag ("waarom heeft hij dit overgedragen?") die dit ontwerp zou moeten
-     * kunnen beantwoorden. De reden van de agent zelf staat hier, en zijn woorden in de draad.
+     * `decideAssignmentState` already computed this and nothing stored it, so you saw `escalated`
+     * without an explanation — exactly the question ("why did it hand this over?") this design should
+     * be able to answer. The agent's own reason goes here, and its words in the thread.
      */
     statusReason?: string;
     createdBy: string;
     lastActivityAt?: number;
 }
 /**
- * Wekt deze activity een opdracht die op een antwoord wacht?
- *
- * **Vier regels, van hard naar zacht.**
+ * Does this activity wake an assignment that is waiting for an answer?
  *
- * 1. **De klant antwoordt** (`inbound`): wekt altijd. Een klant kan niemand @-noemen, en zijn
- *    antwoord is per definitie het antwoord waar de opdracht op wachtte.
- * 2. **De agent zelf schreef dit**: nooit. Zonder deze poort is de vraag die de agent stelt het
- *    signaal waarop hij wakker wordt — een lus die pas bij het beurtplafond stopt.
- * 3. **De agent is genoemd**: wekt, ongeacht waarop hij wacht. Een vermelding is de expliciete
- *    vraag die de engine zelf niet kan beantwoorden: *is dit aan míjn agent gericht?*
- * 4. **Een interne notitie terwijl hij op een antwoord wacht** (`waitingOn === "reply"`): wekt.
+ * **Four rules, hard to soft.**
  *
- * Regel 4 is nieuw en vervangt "alleen als hij genoemd is" voor dit ene geval. **Als een agent
- * expliciet om een antwoord heeft gevraagd, ís het volgende wat een collega schrijft dat antwoord** —
- * dan iemand dwingen zijn eigen agent te @-noemen op de vraag die die agent net zelf stelde is een
- * ritueel, niet een signaal. De oude vrees ("twee collega's die overleggen kosten elk een beurt")
- * blijft gedekt door de rand eromheen: `waitingOn` moet `"reply"` zijn, en zodra hij op een taak
- * wacht of nog bezig is, is de vermelding weer de enige weg naar binnen.
+ * 1. **The customer replies** (`inbound`): always wakes. A customer cannot @-mention anyone, and
+ *    their reply is by definition the answer the assignment was waiting for.
+ * 2. **The agent wrote this itself**: never. Without this gate, the question the agent asks is the
+ *    signal it wakes on — a loop that stops only at the turn ceiling.
+ * 3. **The agent is mentioned**: wakes, whatever it is waiting on. A mention is the explicit answer
+ *    to the question the engine cannot answer itself: *is this addressed to my agent?*
+ * 4. **An internal note while it waits for a reply** (`waitingOn === "reply"`): wakes. If an agent
+ *    explicitly asked for an answer, the next thing a colleague writes *is* that answer; forcing
+ *    someone to @-mention their own agent on the question it just asked is a ritual, not a signal.
+ *    The worry it replaces ("two colleagues conferring cost a turn each") stays covered by the
+ *    edge: `waitingOn` has to be `"reply"`, and once it waits on a task or is still busy, a mention
+ *    is again the only way in.
  *
- * @param waitingOn Waarop de opdracht wacht. Weggelaten = alleen de regels 1-3 (het gedrag van
- *                  vóór regel 4), zodat een beller die het niet weet nooit te ruim wekt.
+ * @param waitingOn What the assignment waits on. Omitted = rules 1-3 only, so a caller that does
+ *                  not know never wakes too eagerly.
  */
-export declare function wakesAssignment(activity: Activity, agentId: string, waitingOn?: WaitingOn["on"]): boolean;
-/** Het onderwerp van een opdracht als één verwijzing, of `undefined`. */
+export declare function wakesAssignment(activity: FeedActivity, agentId: string, waitingOn?: WaitingOn["on"]): boolean;
+/** The subject of an assignment as one reference, or `undefined`. */
 export declare function assignmentSubject(assignment: {
     subjectKind?: string;
     subjectId?: string;
 }): ResourceRef | undefined;
 /**
- * Hoeveel beurten een opdracht mag nemen voordat een mens het overneemt.
+ * How many turns an assignment may take before a human takes over.
  *
- * Niet oneindig, want elke beurt is een modelaanroep en een agent kan met de beste bedoelingen
- * blijven vragen. Bij het plafond escaleert hij, en dat is te zien in de draad — een opdracht die
- * stil ophoudt zou de vraag "waarom doet hij niets meer" onbeantwoordbaar maken.
+ * Not unlimited, because every turn is a model call and an agent can keep asking with the best
+ * intentions. At the ceiling it escalates, and that is visible in the thread — an assignment that
+ * silently stops would make "why is it doing nothing any more" unanswerable.
  */
 export declare const MAX_ASSIGNMENT_TURNS = 12;
 /**
- * Wat een beurt als volgende zet koos. Dit is wat de control-tools vastleggen.
+ * What a turn chose as its next move. This is what the control tools record.
  *
- * Eén union, want de vier uitkomsten sluiten elkaar uit: je wacht op iets, je bent klaar, of je
- * geeft het over aan een mens.
+ * One union, because the outcomes are mutually exclusive: you wait for something, you are done, or
+ * you hand it to a human.
  */
 export type AssignmentControl = {
     kind: "wait";
@@ -157,15 +143,15 @@ export type AssignmentControl = {
     reason: string;
 };
 /**
- * Waar de opdracht na deze beurt in verkeert.
+ * The state the assignment is in after this turn.
  *
- * Puur, zodat de regel op één plek staat en zonder Bridge te testen is — dezelfde vorm als
- * `decideFinalState` voor een run.
+ * Pure, so the rule sits in one place and is testable without Bridge — the same shape as
+ * `decideFinalState` for a run.
  *
- * **Geen control-call betekent escaleren**, niet stil openblijven. Dat is de regel die
- * `decideFinalState` al toepast op een run die wacht zonder geldige reden ("liever luid falen dan
- * stil parkeren"): een agent die zijn beurt afmaakt zonder te zeggen wat hij wil, laat een mens
- * met een opdracht zitten waarvan niemand weet of er nog iets gebeurt.
+ * **No control call means escalate**, not silently stay open. That is the rule `decideFinalState`
+ * already applies to a run waiting without a valid reason ("fail loudly rather than park
+ * silently"): an agent finishing its turn without saying what it wants leaves a human with an
+ * assignment nobody knows is still going anywhere.
  */
 export declare function decideAssignmentState(control: AssignmentControl | undefined, turnsSoFar: number, maxTurns?: number): {
     status: AssignmentStatus;

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

@@ -1,2 +1,2 @@
-export * from './types';
 export * from './signature';
+export * from './types';

package/dist/entities/channel/signature.d.ts

@@ -7,8 +7,8 @@ export interface ChannelSignature {
 }
 export type ChannelSignaturesMap = Partial<Record<CommunicationIntent | string, ChannelSignature>>;
 /**
- * Intents die een handtekening dragen. Enkel deze verschijnen in de
- * signature-editor en worden door `applySignature` van een delimiter voorzien.
+ * Intents that carry a signature. Only these appear in the signature editor and are given a
+ * delimiter by `applySignature`.
  */
 export declare const SIGNATURE_INTENTS: Set<string>;
 /**
@@ -21,12 +21,11 @@ export declare const SIGNATURE_INTENTS: Set<string>;
  */
 export declare function resolveSignature(channel: Channel, intent: CommunicationIntent | string): ChannelSignature | null;
 /**
- * Append de handtekening voor dit channel + intent aan een uitgaande body.
- * Retourneert de body ongewijzigd wanneer er geen (enabled, niet-lege)
- * handtekening is. Centrale plek voor de delimiter-logica zodat elke provider
- * dezelfde opmaak gebruikt i.p.v. 'm per send-pad te dupliceren:
- *  - mail (html)    -> RFC-style "-- " scheider
- *  - message (html) -> dubbele <br>
- *  - text           -> dubbele newline (plain-text varianten / timeline)
+ * Append the signature for this channel + intent to an outgoing body. Returns the body unchanged
+ * when there is no (enabled, non-empty) signature. One place for the delimiter logic so every
+ * provider uses the same formatting instead of duplicating it per send path:
+ *  - mail (html)    -> RFC-style "-- " separator
+ *  - message (html) -> double <br>
+ *  - text           -> double newline (plain-text variants / timeline)
  */
 export declare function applySignature(channel: Channel | undefined, intent: CommunicationIntent | string, body: string, format?: "html" | "text"): string;

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

@@ -1,2 +1,2 @@
-export * from './types';
 export * from './message-template';
+export * from './types';

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

@@ -1,3 +1,3 @@
-export * from './types';
 export * from './endpoints';
 export * from './provider';
+export * from './types';

package/dist/entities/custom-field-def/types.d.ts

@@ -1,16 +1,16 @@
 /**
- * De soorten aangepaste velden.
+ * The kinds of custom field.
  *
- * Begon als `text | select`, want dat was alles wat een gesprek nodig had. Werkitems vragen
- * er meer: een dealwaarde moet als bedrag getoond worden, een doorlooptijd als duur, en een
- * klant als verwijzing naar het bedrijvenregister in plaats van als vrije tekst.
+ * Started as `text | select`, because that was all a conversation needed. Work items ask for more:
+ * a deal value should show as an amount, a lead time as a duration, and a customer as a reference
+ * into the company register instead of as free text.
  *
- * Bewust **geen** `multi_select`: {@link CustomFieldDef.multiValued} bestaat al, wordt al
- * opgeslagen en betekent precies dat. Twee manieren om één ding te zeggen levert een
- * renderer op met een tak die niemand onderhoudt.
+ * Deliberately **no** `multi_select`: {@link CustomFieldDef.multiValued} already exists, is
+ * already stored, and means exactly that. Two ways to say one thing yields a renderer with a
+ * branch nobody maintains.
  */
 export type CustomFieldType = "text" | "textarea" | "number" | "currency" | "date" | "duration" | "select" | "user" | "checkbox"
-/** Verwijst naar een resource elders in het platform; zie {@link CustomFieldDef.refKinds}. */
+/** Points at a resource elsewhere in the platform; see {@link CustomFieldDef.refKinds}. */
  | "resource_ref";
 /** A selectable option for a `select` field. `label` falls back to `value` when absent. */
 export interface CustomFieldOption {
@@ -39,17 +39,17 @@ export interface CustomFieldDef {
     /** Empty/absent = all teams; otherwise only shown when the resource belongs to one of these teams. */
     teamIds?: string[];
     /**
-     * Voor `resource_ref`: welke scope-soorten gekozen mogen worden (`"company"`,
-     * `"contact"`, `"work_item"`). Leeg = alles wat de kiezer aanbiedt.
+     * For `resource_ref`: which scope kinds may be chosen (`"company"`, `"contact"`, `"work_item"`).
+     * Empty = whatever the picker offers.
      */
     refKinds?: string[];
     /**
-     * Welke work-projecten dit veld aanzetten. Leeg/afwezig = elk project, net als bij
+     * Which work projects switch this field on. Empty/absent = every project, as with
      * {@link CustomFieldDef.teamIds}.
      *
-     * Bestaat omdat een velddefinitie platformbreed is maar een veldenset dat niet is: twee
-     * projecten mogen allebei een "Bedrag" kennen met een eigen betekenis. Additief, dus
-     * bestaande definities houden een lege lijst en blijven overal gelden.
+     * Exists because a field definition is platform-wide while a field set is not: two projects may
+     * both know an "Amount" with a meaning of their own. Additive, so existing definitions keep an
+     * empty list and stay valid everywhere.
      */
     projectIds?: string[];
     /**

package/dist/entities/external-identity/types.d.ts

@@ -1,107 +1,102 @@
 /**
- * Wie is "Asana-gebruiker 1203847" hier?
+ * Who is "Asana user 1203847" here?
  *
- * Deze laag bestond niet, en dat is precies waarom `apps/asana` zijn `assignees` leeg laat: een
- * Asana-assignee is een gid, en die één-op-één overnemen zou werk toewijzen aan een id dat in dit
- * platform niemand is — werk op naam van een spook. De enige twee opties waren "veld weglaten" of
- * "per app een hack", en elke volgende connector die assignees, auteurs, reviewers of commenters
- * synct loopt er opnieuw tegenaan.
+ * This layer did not exist, which is exactly why `apps/asana` leaves its `assignees` empty: an
+ * Asana assignee is a gid, and copying it one-to-one would assign work to an id that is nobody in
+ * this platform — work in a ghost's name. The only two options were "leave the field out" or "a
+ * hack per app", and every next connector syncing assignees, authors, reviewers or commenters runs
+ * into it again.
  *
- * ## Waarom dit een eigen store is en geen veld
+ * An external identity is **not** the same as the four things that resemble it:
  *
- * Een externe identiteit is **niet** hetzelfde als de vier dingen die er op lijken:
- *
- * | Lijkt erop | Is | Waarom niet hetzelfde |
+ * | Resembles it | Is | Why it differs |
  * |---|---|---|
- * | `externalId` op een record | dedupe-as voor één rij | zegt niets over personen |
- * | `ManagedAccount.metadata.externalUserId` | de identiteit van een *verbonden account* | één per account, en alleen van wie zelf verbond |
- * | `ManagedAccount.userId` | van wie is dit credential | eigendom, geen mapping |
- * | `Contact` / shadow contact | een persoon *buiten* de organisatie | een assignee is iemand *binnen* de organisatie, in een extern systeem |
- *
- * De vraag hier is de vijfde: welke platform-gebruiker hóórt bij dit externe account. Die heeft
- * een eigen levensduur (je koppelt hem één keer, hij geldt voor elke connector-ronde daarna) en
- * een eigen beheer-oppervlak ("3 van de 12 Asana-gebruikers gekoppeld").
+ * | `externalId` on a record | dedupe axis for one row | says nothing about people |
+ * | `ManagedAccount.metadata.externalUserId` | the identity of a *connected account* | one per account, and only of whoever connected themselves |
+ * | `ManagedAccount.userId` | whose credential this is | ownership, not a mapping |
+ * | `Contact` / shadow contact | a person *outside* the organisation | an assignee is someone *inside* the organisation, in an external system |
  *
- * ## Waarom in `apps/user`
+ * The question here is the fifth: which platform user *belongs* to this external account. It has a
+ * lifetime of its own (you link it once, it holds for every connector round after) and an admin
+ * surface of its own ("3 of the 12 Asana users linked").
  *
- * Bij de app die gebruikers bezit. De e-mail-bootstrap heeft de tenant-roster nodig en die staat
- * daar; en niet-sync-consumenten (AI-tools, webhooks, companion-apps) kunnen hem net zo goed
- * gebruiken. In de sync-pijplijn zetten zou hem onbruikbaar maken buiten sync.
+ * It lives in `apps/user`, with the app that owns users: the email bootstrap needs the tenant
+ * roster, which is there, and non-sync consumers (AI tools, webhooks, companion apps) can use it
+ * just as well. Putting it in the sync pipeline would make it unusable outside sync.
  */
 /**
- * Hoe zeker weten we dat deze koppeling klopt?
+ * How sure are we this link is right?
  *
- * De drie waarden zijn geen kwaliteitslabel maar een **beslissingsas**: alleen bij `confirmed` en
- * `email-match` mag er een `userId` aan hangen, en een `unmatched`-rij bestaat juist om zichtbaar
- * te maken dat er iets te koppelen valt.
+ * The three values are not a quality label but a **decision axis**: only `confirmed` and
+ * `email-match` may carry a `userId`, and an `unmatched` row exists precisely to make visible that
+ * there is something to link.
  */
 export type ExternalIdentityConfidence = 
-/** Een mens heeft dit gekoppeld. Wordt nooit door een bootstrap overschreven. */
+/** A person linked this. Never overwritten by a bootstrap. */
 "confirmed"
-/** Het externe adres matchte exact op het adres van een actieve gebruiker. */
+/** The external address matched an active user's address exactly. */
  | "email-match"
-/** Bekend extern account, geen platform-gebruiker gevonden. `userId` is leeg. */
+/** Known external account, no platform user found. `userId` is empty. */
  | "unmatched";
 export interface ExternalIdentity {
     id: string;
     organizationId: string;
     /**
-     * Welk extern systeem. De catalogus-sleutel van de connector (`"asana"`) of de app-namespace
-     * (`"microsoft"`) — hetzelfde vocabulaire als `SyncSourceDefinition.connectorHint`.
+     * Which external system. The connector's catalog key (`"asana"`) or the app namespace
+     * (`"microsoft"`) — the same vocabulary as `SyncSourceDefinition.connectorHint`.
      *
-     * Bewust niet het connector-**id**: twee organisatie-verbindingen naar hetzelfde product delen
-     * dezelfde gebruikers, en dan zou je de mapping twee keer moeten doen.
+     * Deliberately not the connector **id**: two organisation connections to the same product share
+     * the same users, and you would then have to do the mapping twice.
      */
     connectorKey: string;
-    /** Het id van deze persoon in dat systeem: een Asana-gid, een Graph-`oid`, een Slack-user-id. */
+    /** This person's id in that system: an Asana gid, a Graph `oid`, a Slack user id. */
     externalId: string;
-    /** De platform-gebruiker. Leeg bij `confidence: "unmatched"`. */
+    /** The platform user. Empty with `confidence: "unmatched"`. */
     userId?: string;
-    /** Wat het externe systeem als adres gaf. Bewaard zodat een latere bootstrap kan matchen. */
+    /** The address the external system gave. Kept so a later bootstrap can match. */
     externalEmail?: string;
-    /** Wat het externe systeem als naam gaf. Alleen om de beheerlijst leesbaar te maken. */
+    /** The name the external system gave. Only to keep the admin list readable. */
     externalName?: string;
     confidence: ExternalIdentityConfidence;
     createdAt?: number;
     updatedAt?: number;
 }
-/** Eén extern account waarover een connector een vraag stelt. */
+/** One external account a connector is asking about. */
 export interface ExternalIdentityQuery {
     externalId: string;
-    /** Als het externe systeem een adres geeft. Zonder dit kan de bootstrap niets matchen. */
+    /** When the external system gives an address. Without it the bootstrap can match nothing. */
     email?: string;
     name?: string;
 }
 /**
- * `POST /external-identity/resolve` — **batch**, want één sync-pagina draagt er tientallen.
+ * `POST /external-identity/resolve` — **batched**, because one sync page carries dozens.
  *
- * Per record vragen zou per pagina tientallen app-grenzen kosten, en dat is precies de fout die
- * `landRecords` al vermijdt door per soort te groeperen.
+ * Asking per record would cost dozens of app boundary crossings per page, exactly the mistake
+ * `landRecords` already avoids by grouping per kind.
  */
 export interface ResolveExternalIdentitiesRequest {
     connectorKey: string;
     externals: ExternalIdentityQuery[];
 }
-/** Wat de resolve teruggeeft per extern id. `userId` afwezig = niets om aan toe te wijzen. */
+/** What the resolve returns per external id. `userId` absent = nothing to assign to. */
 export interface ResolvedExternalIdentity {
     userId?: string;
     confidence: ExternalIdentityConfidence;
 }
 export interface ResolveExternalIdentitiesResponse {
     /**
-     * Op `externalId`. Elk gevraagd id staat erin, ook de niet-gematchte — een ontbrekende sleutel
-     * en "geen match" zijn twee verschillende dingen, en de beller mag ze niet hoeven raden.
+     * Keyed on `externalId`. Every requested id is in there, the unmatched ones included — a missing
+     * key and "no match" are two different things, and the caller must not have to guess.
      *
-     * Een gewone map is hier veilig: sinds de camelCase-transform op antwoorden verwijderd is
-     * (17-08-2026) reizen sleutels ongeschonden, dus een gid met een punt of een streep erin komt
-     * heel aan.
+     * A plain map is safe here: keys travel intact, so a gid with a dot or a dash in it arrives
+     * whole.
      */
     resolved: Record<string, ResolvedExternalIdentity>;
 }
-/** `POST /external-identity/link` — een mens wijst de koppeling aan. */
+/** `POST /external-identity/link` — a person points out the link. */
 export interface LinkExternalIdentityRequest {
     connectorKey: string;
     externalId: string;
-    /** Leeg = ontkoppelen; de rij blijft bestaan als `unmatched`. */
+    /** Empty = unlink; the row stays as `unmatched`. */
     userId?: string;
 }

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

@@ -1,3 +1,3 @@
-export * from './types';
 export * from './logic';
 export * from './seen';
+export * from './types';