@opencxh/domain 1.172.1 → 1.173.0

package/dist/entities/analytics/source.d.ts

@@ -1,7 +1,7 @@
 import { DashboardDef, LocaleBundle } from './dashboard';
 import { DimensionDefinition } from './dimensions';
-import { MetricDefinition } from './metric';
 import { Grain, MetricFact } from './fact';
+import { MetricDefinition } from './metric';
 /**
  * Source discovery + ingest — the app↔app contract.
  *

package/dist/entities/analytics/usage.d.ts

@@ -1,36 +1,32 @@
 import { MetricDefinition } from './metric';
 /**
- * Gedeeld vocabulaire voor verbruik — wat een app aan externe middelen opmaakt.
+ * Shared vocabulary for usage — what an app spends on external resources.
  *
- * Bewust géén centrale usage-tabel. Apps bezitten hun eigen ruwe rijen (dat is
- * hoe de rest van de analytics-keten al werkt) en rollen die zelf op. Een
- * centrale tabel zou apps die de data al hebben — een voip-app heeft z'n
- * gesprekken al staan — dwingen alles dubbel weg te schrijven.
+ * Deliberately no central usage table. Apps own their own raw rows (which is how the rest of the
+ * analytics chain already works) and roll those up themselves. A central table would force apps
+ * that already have the data — a voip app already has its calls — to write everything twice.
  *
- * Wat hier wél gedeeld wordt is de *taal*: dezelfde assen en dezelfde
- * metric-naamgeving, zodat AI-tokens en belminuten naast elkaar in één
- * dashboard passen en je ze op `provider` tegen elkaar kunt afzetten.
+ * What *is* shared is the *language*: the same axes and the same metric naming, so AI tokens and
+ * call minutes fit side by side in one dashboard and can be compared on `provider`.
  *
- * Een app die verbruik wil rapporteren:
- *   1. rolt z'n eigen rijen op met `FactAccumulator` (platform-api)
- *   2. emit op de assen hieronder + de core-dimensie `provider`
- *   3. declareert `usageMetrics("voip", [{ unit: "call_minutes", ... }])`
- *      in z'n `/analytics/describe`
+ * An app that wants to report usage:
+ *   1. rolls its own rows up with `FactAccumulator` (platform-api)
+ *   2. emits on the axes below plus the core dimension `provider`
+ *   3. declares `usageMetrics("voip", [{ unit: "call_minutes", ... }])` in its `/analytics/describe`
  */
 /**
- * Waar het verbruik in wordt uitgedrukt. Open string — een app mag een eigen
- * eenheid declareren; deze staan hier omdat ze naar verwachting terugkomen.
+ * What usage is expressed in. An open string — an app may declare a unit of its own; these are
+ * here because they are expected to recur.
  */
 export type UsageUnit = "input_tokens" | "output_tokens" | "cached_input_tokens" | "requests" | "seconds" | "bytes" | (string & {});
 /**
- * Verbruiksdimensies die meerdere apps delen. Aanvullend op de core-dimensie
- * `provider` (welke leverancier), die hiervoor al bestond.
+ * Usage dimensions shared by several apps. On top of the core dimension `provider` (which vendor),
+ * which already existed.
  *
- * `resource` — het specifieke ding dat verbruikt is: een model-id bij AI, een
- *   lijn of nummer bij voip, een bucket bij opslag.
- * `origin` — de functie die het verbruik veroorzaakte: een gesprek, een
- *   playbook, een samenvatting. Beantwoordt "waar gaat het geld heen", wat een
- *   andere vraag is dan "bij wie".
+ * `resource` — the specific thing consumed: a model id for AI, a line or number for voip, a bucket
+ *   for storage.
+ * `origin` — the function that caused the usage: a conversation, a playbook, a summary. Answers
+ *   "where does the money go", a different question from "with whom".
  */
 export declare const USAGE_DIMENSIONS: {
     id: string;
@@ -38,19 +34,18 @@ export declare const USAGE_DIMENSIONS: {
     labelSource: "raw";
 }[];
 export declare const USAGE_DIMENSION_IDS: string[];
-/** Metric-id volgens de gedeelde conventie: `<app>.usage.<unit>`. */
+/** Metric id following the shared convention: `<app>.usage.<unit>`. */
 export declare function usageMetricId(app: string, unit: UsageUnit): string;
 export interface UsageMetricSpec {
     unit: UsageUnit;
     label: string;
-    /** Default `count` — tokens, requests en bytes zijn allemaal tellingen. */
+    /** Defaults to `count` — tokens, requests and bytes are all counts. */
     valueType?: MetricDefinition["valueType"];
-    /** Extra assen bovenop provider/resource/origin/time. */
+    /** Extra axes on top of provider/resource/origin/time. */
     extraDimensions?: string[];
 }
 /**
- * Bouwt de `MetricDefinition`s voor een app z'n verbruiksmetrics, met overal
- * dezelfde assen. Scheelt elke app dezelfde zes regels boilerplate en zorgt dat
- * de definities niet per app uiteenlopen.
+ * Builds the `MetricDefinition`s for an app's usage metrics, with the same axes everywhere. Saves
+ * every app the same six lines of boilerplate and keeps the definitions from drifting per app.
  */
 export declare function usageMetrics(app: string, specs: UsageMetricSpec[]): MetricDefinition[];

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

@@ -1,49 +1,38 @@
 /**
- * De blokken waaruit een artefact is opgebouwd.
+ * The blocks an artifact is built from.
  *
- * Dit is een **document**-vocabulaire, niet het rij-vocabulaire van de tijdlijn
- * (`../activity/blocks.ts`). Die twee lijken op elkaar en zijn het bewust niet:
- * een tijdlijnrij staat tussen tientallen andere en mag daarom maar tien blokken
- * tellen, kent geen alinea's of koppen, en zijn tekstknopen zijn *paden* in een
- * activity. Een artefact is een document — het heeft koppen, alinea's, een tabel
- * en een KPI-rij, en zijn tekst is gewoon tekst.
+ * This is a **document** vocabulary, not the row vocabulary of the timeline
+ * (`../activity/blocks.ts`). Those two look alike and deliberately are not: a timeline row sits
+ * among dozens of others and may therefore hold only ten blocks, has no paragraphs or headings,
+ * and its text nodes are *paths* into an activity. An artifact is a document — it has headings,
+ * paragraphs, a table and a KPI row, and its text is just text.
  *
- * Wat wél overgenomen is, is de *discipline* van dat bestand, omdat die zich
- * bewezen heeft:
+ * What is carried over is that file's *discipline*, because it proved itself:
  *
- * - een optionele `block_id`, zodat een blok aan te wijzen is zonder het hele
- *   document te herschrijven;
- * - {@link normalizeArtifactBlocks} **snoeit in plaats van te weigeren** — één
- *   slecht blok mag geen heel document laten verdwijnen — en meldt élke drop,
- *   want stil snoeien maakt "waarom staat mijn tabel er niet?" onbeantwoordbaar;
- * - onbekende bloktypes worden overgeslagen, zodat een nieuwere schrijver naast
- *   een oudere renderer kan bestaan;
- * - alleen semantische tonen, geen vrije kleuren, zodat dark mode blijft kloppen.
+ * - an optional `block_id`, so a block can be pointed at without rewriting the whole document;
+ * - {@link normalizeArtifactBlocks} **prunes instead of refusing** — one bad block must not make a
+ *   whole document disappear — and reports *every* drop, because silent pruning makes "why is my
+ *   table missing?" unanswerable;
+ * - unknown block types are skipped, so a newer writer can coexist with an older renderer;
+ * - semantic tones only, no free colours, so dark mode keeps working.
  *
- * ## De inerte grens
- *
- * Een artefact is opgeslagen data, geen programma. Dat is hier een eigenschap van
- * het *model* en niet de uitkomst van een filter achteraf:
- *
- * - Blokteksten zijn **markdown, nooit HTML**. De renderer geeft ze aan ui-kit's
- *   `RichText` met `as="markdown"`, en die tak (react-markdown + remark-gfm) emit
- *   geen rauwe HTML. Een `<script>` in de tekst komt dus als letterlijke tekens op
- *   het scherm. Daarom strippen we hier géén tags: dat zou "a < b" slopen zonder
- *   iets te winnen.
- * - Wat we wél strippen is het enige dat markdown zélf gevaarlijk maakt: een link
- *   naar een schema buiten {@link ALLOWED_LINK_SCHEMES}, en inline afbeeldingen.
- *   Zie {@link sanitizeInline}.
+ * **The inert boundary.** An artifact is stored data, not a program, and that is a property of the
+ * *model* rather than the outcome of a filter afterwards. Block texts are **markdown, never
+ * HTML**: the renderer hands them to ui-kit's `RichText` with `as="markdown"`, and that branch
+ * (react-markdown + remark-gfm) emits no raw HTML, so a `<script>` in the text reaches the screen
+ * as literal characters. Hence no tag stripping here — that would break "a < b" and win nothing.
+ * What *is* stripped is the only thing markdown itself makes dangerous: a link to a scheme outside
+ * {@link ALLOWED_LINK_SCHEMES}, and inline images. See {@link sanitizeInline}.
  */
-/** Semantische kleur. Geen vrije kleuren, zodat dark mode en de tokens kloppen. */
+/** Semantic colour. No free colours, so dark mode and the tokens keep working. */
 export type ArtifactTone = "info" | "success" | "warning" | "destructive";
 /**
- * Een regel in een opsomming.
+ * One line in a list.
  *
- * `lead` bestaat omdat een bevindingenlijst zijn kern vetgedrukt vooropzet
- * ("**Yealink-storingen domineren.** 14 van de 184 gesprekken..."). Zonder eigen
- * veld moet de schrijver daar markdown-sterretjes voor verzinnen op een plek waar
- * de opmaak juist vastligt — en dan is het aan de tekst te zien of iemand het
- * vergeten is.
+ * `lead` exists because a findings list puts its point up front in bold ("**Yealink outages
+ * dominate.** 14 of the 184 calls..."). Without a field of its own the writer has to invent
+ * markdown asterisks in a place where the formatting is supposed to be fixed — and then the text
+ * shows whether someone forgot.
  */
 export interface ArtifactListItem {
     lead?: string;
@@ -51,14 +40,14 @@ export interface ArtifactListItem {
 }
 export interface ArtifactTableColumn {
     label: string;
-    /** Getallen rechts. Default links. */
+    /** Numbers right. Left by default. */
     align?: "left" | "right";
 }
 export interface ArtifactKpiItem {
-    /** Al opgemaakt door de schrijver ("1u 12m", "184", "-12%"). */
+    /** Already formatted by the writer ("1u 12m", "184", "-12%"). */
     value: string;
     label: string;
-    /** Alleen zetten als dit getal opvalt; een tint op elke tegel is behang. */
+    /** Only set when this number stands out; a tint on every tile is wallpaper. */
     tone?: ArtifactTone;
 }
 export type ArtifactBlock = {
@@ -106,9 +95,9 @@ export type ArtifactBlock = {
 };
 export type ArtifactBlockType = ArtifactBlock["type"];
 /**
- * Plafonds. Ruimer dan de tijdlijn (die staat op 10 blokken) omdat dit een
- * document is, maar niet ongelimiteerd: de body reist als JSON door hetzelfde
- * invoke-kanaal als al het andere en staat straks in één kolom.
+ * Ceilings. Wider than the timeline (which sits at 10 blocks) because this is a document, but not
+ * unlimited: the body travels as JSON through the same invoke channel as everything else and ends
+ * up in a single column.
  */
 export declare const ARTIFACT_MAX_BLOCKS = 200;
 export declare const ARTIFACT_MAX_LIST_ITEMS = 100;
@@ -117,49 +106,45 @@ export declare const ARTIFACT_MAX_TABLE_COLUMNS = 12;
 export declare const ARTIFACT_MAX_KPI_ITEMS = 4;
 export declare const ARTIFACT_MAX_TEXT_LEN = 4000;
 export declare const ARTIFACT_MAX_CELL_LEN = 500;
-/** Harde bovengrens op de geserialiseerde body. */
+/** Hard upper bound on the serialized body. */
 export declare const ARTIFACT_MAX_BODY_BYTES: number;
 /**
- * Schema's die een link in een artefact mag dragen.
+ * Schemes a link in an artifact may carry.
  *
- * `javascript:` en `data:` staan er niet bij, en dat is de hele reden dat deze
- * lijst bestaat: die twee zijn de enige manier waarop markdown iets uitvoerbaars
- * het document in krijgt.
+ * `javascript:` and `data:` are not among them, and that is the entire reason this list exists:
+ * those two are the only way markdown gets something executable into the document.
  */
 export declare const ALLOWED_LINK_SCHEMES: readonly ["http:", "https:", "mailto:", "tel:"];
 /**
- * Maakt één stuk inline markdown veilig en houdt hem leesbaar.
+ * Makes one piece of inline markdown safe while keeping it readable.
  *
- * Drie ingrepen, in deze volgorde:
+ * Three interventions, in this order:
  *
- * 1. **Inline afbeeldingen verdwijnen**, met hun alt-tekst als vervanging. Er is
- *    in deze versie geen `image`-blok, juist omdat dit product geen publiek
- *    laadbare URL kent (bytes komen als base64 door het invoke-kanaal). Een
- *    inline `![](…)` zou dat gat langs de achterdeur openzetten en bovendien een
- *    externe host laten weten wie het document opent.
- * 2. **Links naar een verboden schema worden platte tekst** — het label blijft
- *    staan. Weggooien van het label zou de zin stukmaken om de link.
- * 3. **Referentiedefinities naar een verboden schema verdwijnen.** Zonder deze
- *    stap ontsnapt `[klik][x]` met `[x]: javascript:…` eronder aan stap 2.
+ * 1. **Inline images disappear**, with their alt text as replacement. This version has no `image`
+ *    block precisely because the product has no publicly loadable URL (bytes come through the
+ *    invoke channel as base64). An inline `![](…)` would open that gap through the back door and
+ *    tell an external host who opens the document.
+ * 2. **Links to a forbidden scheme become plain text** — the label stays. Dropping the label would
+ *    break the sentence over the link.
+ * 3. **Reference definitions to a forbidden scheme disappear.** Without this step `[click][x]`
+ *    with `[x]: javascript:…` below it escapes step 2.
  */
 export declare function sanitizeInline(text: string): string;
 /**
- * Snoeit een geschreven blokkenlijst tot iets wat een renderer veilig kan tekenen.
+ * Prunes a written block list down to something a renderer can safely draw.
  *
- * Geeft altijd **nieuwe** objecten terug: de invoer komt van een model of van een
- * API-client, en de gesaniteerde tekst hoort niet in het origineel terug te
- * lekken.
+ * Always returns **new** objects: the input comes from a model or an API client, and the sanitized
+ * text must not leak back into the original.
  *
- * `onDrop` hoort te loggen of terug te koppelen aan de schrijver — een tool die
- * zijn tabel kwijtraakt omdat hij nul kolommen meestuurde, moet dat kunnen horen.
+ * `onDrop` should log or report back to the writer — a tool losing its table because it sent zero
+ * columns has to be able to hear that.
  */
 export declare function normalizeArtifactBlocks(blocks: unknown, onDrop?: (reason: string) => void): ArtifactBlock[];
-/** Hoeveel bytes deze body op de wire kost. */
+/** How many bytes this body costs on the wire. */
 export declare function artifactBodyBytes(blocks: ArtifactBlock[]): number;
 /**
- * Een korte samenvatting van wat erin zit, voor de miniatuur op een kaart en voor
- * wat de assistent te zien krijgt als hij een artefact wil bijwerken zonder de
- * hele body te lezen.
+ * A short summary of what is inside, for the thumbnail on a card and for what the assistant sees
+ * when it wants to update an artifact without reading the whole body.
  */
 export declare function artifactOutline(blocks: ArtifactBlock[]): {
     blocks: number;

package/dist/entities/artifact/markdown.d.ts

@@ -1,7 +1,6 @@
 import { ArtifactBlock } from './blocks';
 /**
- * Het hele document als markdown. `title` komt er als H1 boven te staan wanneer
- * de blokken er zelf geen dragen — een export zonder titel is niet terug te
- * vinden in een downloadmap.
+ * The whole document as markdown. `title` goes on top as an H1 when the blocks carry none
+ * themselves — an export without a title cannot be found back in a downloads folder.
  */
 export declare function artifactToMarkdown(blocks: ArtifactBlock[], title?: string): string;

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

@@ -2,26 +2,24 @@ import { ToolSource } from '../../platform/ai-tools';
 import { OwnerScope } from '../scope/types';
 import { ArtifactBlock } from './blocks';
 /**
- * Een artefact: een afgerond, deelbaar snapshot-document dat de assistent maakt
- * terwijl hij het platform bevraagt.
+ * An artifact: a finished, shareable snapshot document the assistant produces while querying the
+ * platform.
  *
- * De veiligheidsredenering waar dit hele model op rust, in één zin: **de AI
- * gebruikt tools tijdens het genereren, het artefact gebruikt geen tools tijdens
- * het bekijken.** Alle tooltoegang zit aan de generatiekant, in de agent die we
- * al draaien en al vertrouwen. Wat bij de kijker landt is data. Daarom is delen
- * veilig zonder cross-user-executierisico, en daarom hoeft er voor dit genre
- * geen sandbox te zijn.
+ * The safety argument this whole model rests on, in one sentence: **the AI uses tools while
+ * generating, the artifact uses no tools while being viewed.** All tool access sits on the
+ * generation side, in the agent we already run and already trust. What lands with the viewer is
+ * data. That is why sharing is safe without cross-user execution risk, and why this genre needs no
+ * sandbox.
  */
-/** Waar het artefact in de nav onder valt en welk glyph hij krijgt. */
+/** Which nav bucket the artifact falls under and which glyph it gets. */
 export type ArtifactKind = "document" | "table" | "summary";
 /**
- * Wat een gedeelde ontvanger mag.
+ * What a share recipient may do.
  *
- * `commenter` leest en mag het gekoppelde assistent-gesprek voeren — hij kan dus
- * wél een nieuwe versie láten maken, maar niet zelf de titel of het deelmodel
- * omzetten. Dat is bewust: het gesprek is de manier waarop je met een artefact
- * werkt, en dat afknijpen zou de feature halveren voor iedereen behalve de
- * eigenaar.
+ * `commenter` reads and may carry the linked assistant conversation — so they can have a new
+ * version made, but cannot change the title or the sharing themselves. Deliberate: the conversation
+ * is how you work with an artifact, and choking that would halve the feature for everyone but the
+ * owner.
  */
 export type ArtifactShareRole = "viewer" | "commenter" | "owner";
 export interface ArtifactShare {
@@ -29,20 +27,15 @@ export interface ArtifactShare {
     id: string;
     role: ArtifactShareRole;
 }
-/**
- * `"blocks"` nu; `"html"` in de fase waarin de assistent vrije, gesaniteerde
- * opmaak mag schrijven.
- */
+/** `"blocks"` today; `"html"` in the phase where the assistant may write free, sanitized markup. */
 export type ArtifactFormat = "blocks" | "html";
 /**
- * De sandbox-naad, en de enige plek waar het inerte en het latere interactieve
- * pad uit elkaar lopen.
+ * The sandbox seam, and the only place where the inert and the later interactive path diverge.
  *
- * Generatie, opslag, deelmodel en de Drive-omgeving zijn voor beide identiek —
- * alleen de laatste stap in de renderlaag verschilt: gesaniteerde inerte inhoud
- * in onze eigen DOM, of levende code binnen een iframe-grens. De renderer weigert
- * vandaag alles wat niet `"inert"` is, zodat een rij die ooit iets anders draagt
- * niet stilzwijgend als veilig getekend wordt.
+ * Generation, storage, sharing and the Drive surroundings are identical for both — only the last
+ * step in the render layer differs: sanitized inert content in our own DOM, or live code inside an
+ * iframe boundary. The renderer today refuses anything that is not `"inert"`, so a row that ever
+ * carries something else is not silently drawn as safe.
  */
 export type ArtifactRuntime = "inert" | "sandboxed";
 export interface Artifact {
@@ -51,32 +44,31 @@ export interface Artifact {
     title: string;
     kind: ArtifactKind;
     ownerScope: OwnerScope;
-    /** Wie hem expliciet mag zien, náást de scope. */
+    /** Who may see it explicitly, on top of the scope. */
     shares: ArtifactShare[];
     /**
-     * Platgeslagen spiegel van {@link shares} (`user:<id>` / `team:<id>`).
+     * Flattened mirror of {@link shares} (`user:<id>` / `team:<id>`).
      *
-     * Geen duplicatie maar de enige manier om erop te kunnen zoeken: je kunt niet
-     * in een array van objecten queryen. Dezelfde vorm als `Contact.keys` en
-     * `Interaction.partyKeys` — platslaan bij het schrijven, één `$in` bij het
-     * lezen. Bouw hem altijd met {@link buildShareKeys}, nooit met de hand.
+     * Not duplication but the only way to search on it: you cannot query inside an array of objects.
+     * The same shape as `Contact.keys` and `Interaction.partyKeys` — flatten at write time, one `$in`
+     * at read time. Always build it with {@link buildShareKeys}, never by hand.
      */
     shareKeys: string[];
     currentVersion: number;
     /**
-     * De soorten bronnen die de huidige versie raadpleegde ("interaction",
-     * "analytics", "memory"), ontdubbeld.
+     * The kinds of source the current version consulted ("interaction", "analytics", "memory"),
+     * deduplicated.
      *
-     * Afgeleid en meegeschreven bij elke versie, om dezelfde reden als
-     * {@link Artifact.shareKeys}: de lijstpagina wil ze als chips tonen en laadt
-     * geen versies. Zonder dit veld zou die kolom altijd leeg zijn, of zou elke
-     * lijstweergave een versie-fetch per rij kosten.
+     * Derived and written along with every version, for the same reason as
+     * {@link Artifact.shareKeys}: the list page wants to show them as chips and loads no versions.
+     * Without this field that column would always be empty, or every list view would cost a version
+     * fetch per row.
      */
     sourceKinds?: string[];
     createdBy: string;
-    /** Het assistent-gesprek waaruit hij ontstond, als hij zo ontstaan is. */
+    /** The assistant conversation it came out of, when it came about that way. */
     conversationId?: string;
-    /** Dossiersleutels: `interaction:<id>`, `company:<id>`, `contact:<id>`. */
+    /** File keys: `interaction:<id>`, `company:<id>`, `contact:<id>`. */
     keys?: string[];
     createdAt?: number;
     updatedAt?: number;
@@ -85,30 +77,30 @@ export interface ArtifactVersion {
     id: string;
     organizationId: string;
     artifactId: string;
-    /** 1, 2, 3… — oplopend, nooit hergebruikt. */
+    /** 1, 2, 3… — ascending, never reused. */
     n: number;
-    /** Waarom deze versie bestaat: "Eerste generatie", "Ingekort op verzoek". */
+    /** Why this version exists: "Eerste generatie", "Ingekort op verzoek". */
     label: string;
     format: ArtifactFormat;
     runtime: ArtifactRuntime;
-    /** De inhoud zelf, als `format === "blocks"`. */
+    /** The content itself, when `format === "blocks"`. */
     body?: ArtifactBlock[];
-    /** De naad naar de storage-provider, als `format === "html"`. Nu altijd leeg. */
+    /** The seam to the storage provider, when `format === "html"`. Always empty today. */
     storageRef?: {
         fileId: string;
     };
     /**
-     * Wat de assistent raadpleegde toen hij dit schreef.
+     * What the assistant consulted when it wrote this.
      *
-     * Hergebruikt {@link ToolSource} uit het tool-contract, want het is precies
-     * hetzelfde begrip: geraadpleegd, niet geciteerd. Een generatie die vijf
-     * gesprekken las noemt er vijf, ook als de tekst er één gebruikte.
+     * Reuses {@link ToolSource} from the tool contract, because it is exactly the same concept:
+     * consulted, not cited. A generation that read five conversations names five, even if the text
+     * used one.
      */
     sources?: ToolSource[];
     createdBy: string;
     createdAt?: number;
 }
-/** Wat een detailpagina in één keer nodig heeft. */
+/** What a detail page needs in one go. */
 export interface ArtifactWithVersion {
     artifact: Artifact;
     version: ArtifactVersion;
@@ -116,13 +108,13 @@ export interface ArtifactWithVersion {
 export declare const shareKeyForUser: (userId: string) => string;
 export declare const shareKeyForTeam: (teamId: string) => string;
 /**
- * De platte, doorzoekbare vorm van een deellijst.
+ * The flat, searchable form of a share list.
  *
- * Gedupliceerd en gesorteerd zodat twee gelijke deellijsten dezelfde sleutels
- * geven — anders lijkt een opslag zonder wijziging toch een wijziging.
+ * Deduplicated and sorted so two equal share lists yield the same keys — otherwise a save without
+ * a change still looks like a change.
  */
 export declare function buildShareKeys(shares: ArtifactShare[] | undefined): string[];
-/** De sleutels waarmee deze gebruiker gedeelde artefacten kan vinden. */
+/** The keys this user can find shared artifacts with. */
 export declare function shareKeysForViewer(userId: string, teamIds: string[]): string[];
-/** De ontdubbelde bronsoorten, in de volgorde waarin ze voorkwamen. */
+/** The deduplicated source kinds, in the order they occurred. */
 export declare function toolSourceKinds(sources: ToolSource[] | undefined): string[];