@larc-iu/plaid-client 0.2.0-alpha.26 → 0.2.0-alpha.29

package/src/index.d.ts

@@ -163,6 +163,29 @@ export type ConstraintRepair = {
     deleted: number;
     joined: number;
 };
+/**
+ * A value-set rule as `refusedValues` takes it: the list, the characters a
+ * value is split on, and whether every part (`"all"`, the default) or only
+ * the first must be listed.
+ */
+export type ValueSetRule = {
+    values: string[];
+    delimiters?: string;
+    parts?: "all" | "first";
+};
+/**
+ * What a value-set rule would refuse in a layer's stored values: how many,
+ * how many distinct, and the most frequent with the parts not listed.
+ */
+export type RefusedValues = {
+    count: number;
+    valueCount: number;
+    values: Array<{
+        value: any;
+        parts: string[];
+        count: number;
+    }>;
+};
 /**
  * Entities that can carry a comment.
  */
@@ -257,6 +280,7 @@ export type ServerLimits = {
     userDataValueBytes?: number;
     guidelineTitleLength?: number;
     guidelineBodyLength?: number;
+    commentBodyLength?: number;
     passwordMinLength?: number;
     lockExpirationMs?: number;
 };
@@ -354,12 +378,496 @@ export type LiveLog = {
  */
 export type SSEConnection = {
     close: () => void;
-    getStats: () => any;
+    getStats: () => SSEStats;
     readyState: number;
     error: (Error & {
         status?: number;
     }) | null;
 };
+/**
+ * How an SSE connection has fared so far. `events` counts what arrived by
+ * event type ("audit-log", "message", "heartbeat", "connected", "other").
+ */
+export type SSEStats = {
+    durationSeconds: number;
+    isConnected: boolean;
+    isClosed: boolean;
+    clientId: string | null;
+    events: Record<string, number>;
+    readyState: number;
+};
+/**
+ * A value a span or relation holds: a JSON scalar.
+ */
+export type AtomicValue = string | number | boolean | null;
+/**
+ * What a create answers: the new record's id.
+ */
+export type Created = {
+    id: string;
+};
+/**
+ * A project. `textLayers` nests its layers in their display order, each
+ * with the layers built on it, and `vocabs` lists the vocabularies linked to
+ * it.
+ */
+export type Project = {
+    id: string;
+    name: string;
+    config: Record<string, any>;
+    readers: string[];
+    writers: string[];
+    maintainers: string[];
+    textLayers: ProjectTextLayer[];
+    vocabs: ProjectVocab[];
+};
+export type ProjectTextLayer = {
+    id: string;
+    name: string;
+    config: Record<string, any>;
+    tokenLayers: ProjectTokenLayer[];
+};
+export type ProjectTokenLayer = {
+    id: string;
+    name: string;
+    config: Record<string, any>;
+    constraints: Record<string, LayerConstraint[]>;
+    spanLayers: ProjectSpanLayer[];
+};
+export type ProjectSpanLayer = {
+    id: string;
+    name: string;
+    config: Record<string, any>;
+    constraints: Record<string, LayerConstraint[]>;
+    relationLayers: ProjectRelationLayer[];
+};
+export type ProjectRelationLayer = {
+    id: string;
+    name: string;
+    config: Record<string, any>;
+    constraints: Record<string, LayerConstraint[]>;
+};
+export type ProjectVocab = {
+    id: string;
+    name: string;
+    maintainers: string[];
+    config: Record<string, any>;
+};
+/**
+ * A document. `version` rises by one on every write to it or its layers.
+ * A read with `includeBody` also carries `textLayers`, the document's
+ * annotation nested under each layer.
+ */
+export type PlaidDocument = {
+    id: string;
+    name: string;
+    project: string;
+    version: number;
+    timeCreated: string;
+    timeModified: string;
+    metadata?: Record<string, any>;
+    textLayers?: DocumentTextLayer[];
+};
+/**
+ * A text layer as a document read nests it: `text` is null where the
+ * document has no text in this layer.
+ */
+export type DocumentTextLayer = {
+    id: string;
+    name: string;
+    config: Record<string, any>;
+    text: {
+        id: string;
+        document: string;
+        body: string;
+        digest: string;
+        metadata?: Record<string, any>;
+    } | null;
+    tokenLayers: DocumentTokenLayer[];
+};
+export type DocumentTokenLayer = {
+    id: string;
+    name: string;
+    config: Record<string, any>;
+    constraints: Record<string, LayerConstraint[]>;
+    overlapMode: string;
+    parentTokenLayer: string | null;
+    tokens: Array<{
+        id: string;
+        begin: number;
+        end: number;
+        precedence: number | null;
+        metadata?: Record<string, any>;
+    }>;
+    spanLayers: DocumentSpanLayer[];
+    vocabs: Array<ProjectVocab & {
+        vocabLinks: Array<{
+            id: string;
+            vocabItem: VocabItem;
+            tokens: string[];
+            metadata?: Record<string, any>;
+        }>;
+    }>;
+};
+export type DocumentSpanLayer = {
+    id: string;
+    name: string;
+    config: Record<string, any>;
+    constraints: Record<string, LayerConstraint[]>;
+    spans: Array<{
+        id: string;
+        value: AtomicValue;
+        tokens: string[];
+        metadata?: Record<string, any>;
+    }>;
+    relationLayers: Array<ProjectRelationLayer & {
+        relations: Array<{
+            id: string;
+            source: string;
+            target: string;
+            value: AtomicValue;
+            metadata?: Record<string, any>;
+        }>;
+    }>;
+};
+/**
+ * A text: one document's body in one text layer. `digest` names the body,
+ * as an edit's `base`.
+ */
+export type PlaidText = {
+    id: string;
+    body: string;
+    document: string;
+    layer: string;
+    digest: string;
+    metadata?: Record<string, any>;
+};
+/**
+ * What a text write changed besides the body: the tokens whose extent
+ * moved (with `layer` and `text` on one the write made), the spans and
+ * vocabulary links whose tokens or value changed, and the ids of what it
+ * deleted.
+ */
+export type TextReshape = {
+    tokens: Array<{
+        id: string;
+        begin: number;
+        end: number;
+        layer?: string;
+        text?: string;
+    }>;
+    spans: Array<{
+        id: string;
+        tokens?: string[];
+        value?: AtomicValue;
+    }>;
+    vocabLinks: Array<{
+        id: string;
+        tokens: string[];
+    }>;
+    deleted: {
+        tokens: string[];
+        spans: string[];
+        relations: string[];
+        vocabLinks: string[];
+    };
+};
+/**
+ * A token. `value` is the text it covers.
+ */
+export type Token = {
+    id: string;
+    text: string;
+    begin: number;
+    end: number;
+    layer: string;
+    document: string;
+    precedence: number | null;
+    value: string;
+    metadata?: Record<string, any>;
+};
+export type Span = {
+    id: string;
+    layer: string;
+    document: string;
+    value: AtomicValue;
+    tokens: string[];
+    metadata?: Record<string, any>;
+};
+/**
+ * A relation, from the span `source` to the span `target`.
+ */
+export type Relation = {
+    id: string;
+    layer: string;
+    document: string;
+    source: string;
+    target: string;
+    value: AtomicValue;
+    metadata?: Record<string, any>;
+};
+export type VocabItem = {
+    id: string;
+    layer: string;
+    form: string;
+    metadata?: Record<string, any>;
+};
+/**
+ * A link from a vocabulary entry to the tokens of one occurrence.
+ */
+export type VocabLink = {
+    id: string;
+    vocabItem: string;
+    document: string;
+    tokens: string[];
+    metadata?: Record<string, any>;
+};
+/**
+ * A vocabulary. `items` is there on a read made with `includeItems`.
+ */
+export type VocabLayer = {
+    id: string;
+    name: string;
+    timeCreated: string;
+    timeModified: string;
+    config: Record<string, any>;
+    maintainers: string[];
+    items?: VocabItem[];
+};
+export type TextLayer = {
+    id: string;
+    name: string;
+    project: string;
+    config: Record<string, any>;
+};
+export type TokenLayer = {
+    id: string;
+    name: string;
+    textLayer: string;
+    project: string;
+    overlapMode: string;
+    parentTokenLayer: string | null;
+    config: Record<string, any>;
+    constraints: Record<string, LayerConstraint[]>;
+};
+export type SpanLayer = {
+    id: string;
+    name: string;
+    tokenLayer: string;
+    project: string;
+    config: Record<string, any>;
+    constraints: Record<string, LayerConstraint[]>;
+};
+export type RelationLayer = {
+    id: string;
+    name: string;
+    spanLayer: string;
+    project: string;
+    config: Record<string, any>;
+    constraints: Record<string, LayerConstraint[]>;
+};
+/**
+ * The records with metadata, by the path segment of their routes.
+ */
+export type MetadataRecords = {
+    documents: PlaidDocument;
+    texts: PlaidText;
+    tokens: Token;
+    spans: Span;
+    relations: Relation;
+    "vocab-items": VocabItem;
+    "vocab-links": VocabLink;
+};
+/**
+ * The four layer kinds, by the path segment of their routes.
+ */
+export type LayerRecords = {
+    "text-layers": TextLayer;
+    "token-layers": TokenLayer;
+    "span-layers": SpanLayer;
+    "relation-layers": RelationLayer;
+};
+export type User = {
+    id: string;
+    displayName: string;
+    isAdmin: boolean;
+    deactivatedAt: string | null;
+    avatarHash: string | null;
+};
+/**
+ * A project as the project list gives it: the project, with how many
+ * documents it has and when the newest of them last changed.
+ */
+export type ProjectListEntry = Project & {
+    documentCount: number;
+    lastModified: string | null;
+};
+/**
+ * A document as a project's document list gives it.
+ */
+export type DocumentListEntry = {
+    id: string;
+    name: string;
+    version: number;
+    timeCreated: string;
+    timeModified: string;
+};
+/**
+ * A named API token, without the signed token itself, which only `create`
+ * returns.
+ */
+export type ApiToken = {
+    id: string;
+    userId: string;
+    name: string;
+    createdAt: string;
+    lastUsedAt: string | null;
+    revokedAt: string | null;
+};
+/**
+ * Who made an operation, as the audit log names them.
+ */
+export type AuditUser = {
+    id: string;
+    displayName: string;
+    avatarHash: string | null;
+};
+/**
+ * A project or a document an audit entry names, while it exists.
+ */
+export type AuditTarget = {
+    id: string;
+    name: string;
+};
+/**
+ * One operation of an audit entry.
+ */
+export type AuditOp = {
+    id: string;
+    /**
+     * The kind of write, such as "document/update".
+     */
+    type: string;
+    description: string;
+    time: string;
+    /**
+     * The time to read at to see the operation done.
+     */
+    endTime: string;
+    user: AuditUser | null;
+    credential?: string;
+    project?: AuditTarget;
+    document?: AuditTarget;
+    batchId?: string;
+};
+/**
+ * One entry of an audit log: a logical operation, an atomic batch or a lone
+ * write, with its operations oldest first (`ops`, cut to `opsLimit` when one
+ * was asked for, while `opCount` counts them all).
+ */
+export type AuditEntry = {
+    id: string;
+    time: string;
+    endTime: string;
+    user: AuditUser | null;
+    projects: AuditTarget[];
+    documents: AuditTarget[];
+    ops: AuditOp[];
+    opCount: number;
+    groupId?: string;
+    message?: string;
+    kind?: OperationKind;
+    ref?: string;
+    batchId?: string;
+    apiToken?: {
+        id: string;
+        name: string;
+    };
+    credential?: string;
+};
+/**
+ * A document lock as its holder sees it. `expiresAt` is in epoch
+ * milliseconds.
+ */
+export type LockGrant = {
+    lockId: string;
+    userId: string;
+    expiresAt: number;
+};
+/**
+ * What `documents.restore` did, or with `dryRun` would do: per kind of
+ * record, how many come back, are set back and are removed (per layer for
+ * the layered kinds), and what could not come back, with why.
+ */
+export type DocumentRestoreSummary = {
+    name: boolean;
+    documentMetadata: boolean;
+    texts: RestoreCounts;
+    tokens: RestoreCounts & {
+        byLayer: Array<RestoreCounts & {
+            layerId: string;
+        }>;
+    };
+    spans: RestoreCounts & {
+        byLayer: Array<RestoreCounts & {
+            layerId: string;
+        }>;
+    };
+    relations: RestoreCounts & {
+        byLayer: Array<RestoreCounts & {
+            layerId: string;
+        }>;
+    };
+    vocabLinks: RestoreCounts;
+    skipped: Array<{
+        kind: string;
+        count: number;
+        reason: string;
+    }>;
+    /**
+     * When the name the
+     * document had then belongs to another document now: the name it keeps,
+     * and that other document's name.
+     */
+    nameKept?: {
+        name: string;
+        taken: string;
+    };
+    /**
+     * 0 when nothing changes.
+     */
+    total: number;
+};
+export type RestoreCounts = {
+    inserted: number;
+    updated: number;
+    deleted: number;
+};
+/**
+ * A logical-operation group: its label, who made it and when, and the kind
+ * and reference of the operation when it has them.
+ */
+export type OperationGroup = {
+    id: string;
+    message: string | null;
+    user: string;
+    createdAt: string;
+    kind?: string;
+    ref?: string;
+};
+/**
+ * A query's answer. For "ids" and "entities", one row of `results` per
+ * match, a cell per `columns` entry: an id, or the entity as its GET
+ * answers it. For "count", only the count. `truncated`: the rows or the
+ * count stopped at the server's cap.
+ */
+export type QueryResult = {
+    return: string;
+    count: number;
+    truncated: boolean;
+    columns?: string[];
+    results?: any[][];
+};
 export class PlaidClient {
     /**
      * Liveness, version and database size, with NO authentication and no client
@@ -571,34 +1079,39 @@ export class PlaidClient {
         /**
          * Get a vocab link by ID
          * @param {string} id - The resource ID
+         * @returns {Promise<VocabLink>}
          */
-        get: (id: string) => Promise<any>;
+        get: (id: string) => Promise<VocabLink>;
         /**
          * Delete a vocab link
          * @param {string} id - The resource ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (id: string, auditMessage?: string) => Promise<any>;
+        delete: (id: string, auditMessage?: string) => Promise<void>;
         /**
          * Replace all metadata of an entity. Keys left out of the new map are removed.
          * @param {string} id - The entity's ID
          * @param {object} body - The new metadata map
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<any>;
+        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<VocabLink>;
         /**
          * Remove all metadata from an entity.
          * @param {string} id - The entity's ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        deleteMetadata: (id: string, auditMessage?: string) => Promise<any>;
+        deleteMetadata: (id: string, auditMessage?: string) => Promise<VocabLink>;
         /**
          * Edit an entity's metadata with a list of ops applied in order, in one operation. `{op: 'set', path, value}` writes value at path, creating missing objects along it; `{op: 'delete', path}` removes the key at path (a no-op when absent). A path is a non-empty array of keys, the first a top-level key. A path through a non-object is refused (400). See metadataOps and applyMetadataOps.
          * @param {string} id - The entity's ID
          * @param {MetadataOp[]} body - The metadata ops
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<any>;
+        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<VocabLink>;
         /**
          * Create a new vocab link between tokens and a vocab item.
          * @param {string} vocabItem - The vocab item to link
@@ -607,10 +1120,11 @@ export class PlaidClient {
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @returns {Promise<Created>}
          */
         create: (vocabItem: string, tokens: any[], metadata?: any, auditMessage?: string, { id }?: {
             id?: string;
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Create multiple vocab links in a single operation. Entries may
          * reference different vocab items, but all tokens across the call must
@@ -638,55 +1152,56 @@ export class PlaidClient {
         /**
          * List all vocab layers accessible to user. Transparently follows
          * pagination cursors and returns the full flat array.
+         * @returns {Promise<VocabLayer[]>}
          */
-        list: () => Promise<any[]>;
+        list: () => Promise<VocabLayer[]>;
         /**
          * Fetch a single page of vocab layers.
          * @param {object} [opts]
          * @param {number} [opts.limit] - Page size (1..1000; server default 100)
          * @param {string} [opts.cursor] - Opaque cursor from a previous page
-         * @returns {Promise<{entries: Array, nextCursor: (string|null)}>}
+         * @returns {Promise<Page<VocabLayer>>}
          */
         listPage: ({ limit, cursor }?: {
             limit?: number;
             cursor?: string;
-        }) => Promise<{
-            entries: any[];
-            nextCursor: (string | null);
-        }>;
+        }) => Promise<Page<VocabLayer>>;
         /**
          * Async-iterate vocab layers page by page; yields each page's entries array.
          * @param {object} [opts]
          * @param {number} [opts.pageSize] - Per-request page size
-         * @returns {AsyncGenerator<Array>}
+         * @returns {AsyncGenerator<VocabLayer[]>}
          */
         iterPages: ({ pageSize }?: {
             pageSize?: number;
-        }) => AsyncGenerator<any[]>;
+        }) => AsyncGenerator<VocabLayer[]>;
         /**
          * Create a new vocab layer. Note: this also registers the user as a maintainer.
          * @param {string} name - The name
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @returns {Promise<Created>}
          */
         create: (name: string, auditMessage?: string, { id }?: {
             id?: string;
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Assign a user as a maintainer for this vocab layer.
          * @param {string} id - The resource ID
          * @param {string} userId - The user ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        addMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<any>;
+        addMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<void>;
         /**
          * Remove a user's maintainer privileges for this vocab layer.
          * @param {string} id - The resource ID
          * @param {string} userId - The user ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        removeMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<any>;
+        removeMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<void>;
         /**
          * Set a configuration value in an editor namespace.
          * @param {string} id - The record's ID
@@ -695,22 +1210,27 @@ export class PlaidClient {
          * @param {any} configValue - Configuration value to set
          * @param {string} [auditMessage] - Audit message for this write
          * @param {{expected?: any}} [options] - `expected`: the value read for this key (null or undefined when it
-         *   was absent). The write is then refused with a 409 when the stored value differs.
+         *   was absent). The write is then refused with a 409 when the stored value differs. A value the key
+         *   already holds is not written and leaves no audit row, so the value read, expecting it, states in a
+         *   batch that the key is unchanged.
+         * @returns {Promise<void>}
          */
         setConfig: (id: string, namespace: string, configKey: string, configValue: any, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * Remove a configuration value.
          * @param {string} id - The record's ID
          * @param {string} namespace - The config namespace
          * @param {string} configKey - The config key
          * @param {string} [auditMessage] - Audit message for this write
-         * @param {{expected?: any}} [options] - `expected`, as on setConfig.
+         * @param {{expected?: any}} [options] - `expected`, as on setConfig. A key that is absent is not
+         *   written, so expecting null states in a batch that it is still absent.
+         * @returns {Promise<void>}
          */
         deleteConfig: (id: string, namespace: string, configKey: string, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * Get a vocab layer by ID. With `asOf`, the vocabulary as it was at that
          * instant, read from its history: the same shape as the live read, its
@@ -719,8 +1239,9 @@ export class PlaidClient {
          * @param {string} id - The resource ID
          * @param {boolean} [includeItems] - Include vocab items
          * @param {string} [asOf] - The moment to read at (ISO-8601 instant)
+         * @returns {Promise<VocabLayer>}
          */
-        get: (id: string, includeItems?: boolean, asOf?: string) => Promise<any>;
+        get: (id: string, includeItems?: boolean, asOf?: string) => Promise<VocabLayer>;
         /**
          * One entry of the vocabulary as it was at `asOf`, also when it has
          * been deleted since. The same shape as `vocabItems.get`. A 404 when
@@ -728,8 +1249,9 @@ export class PlaidClient {
          * @param {string} id - The vocabulary ID
          * @param {string} itemId - The entry ID
          * @param {string} asOf - The moment to read at (ISO-8601 instant)
+         * @returns {Promise<VocabItem>}
          */
-        getItemAt: (id: string, itemId: string, asOf: string) => Promise<any>;
+        getItemAt: (id: string, itemId: string, asOf: string) => Promise<VocabItem>;
         /**
          * Get the audit log of a vocabulary: every change to it or to its
          * entries, folded into entries as the document log is. Links are not
@@ -745,8 +1267,9 @@ export class PlaidClient {
          *   each with only its operations that did
          * @param {string[]|string} [kinds] - Only the entries of operations of
          *   these kinds (e.g. `['review', 'guess-adoption']`), each whole
+         * @returns {Promise<AuditEntry[]>}
          */
-        audit: (id: string, startTime?: string, endTime?: string, opTypes?: string[] | string, itemId?: string, kinds?: string[] | string) => Promise<any[]>;
+        audit: (id: string, startTime?: string, endTime?: string, opTypes?: string[] | string, itemId?: string, kinds?: string[] | string) => Promise<AuditEntry[]>;
         /**
          * One page of the same log, newest-first with `order: "desc"`. Use this
          * rather than audit() wherever the caller wants the recent end of a log
@@ -766,7 +1289,7 @@ export class PlaidClient {
          * @param {string} [opts.entryId] - Read only this entry, not a page
          * @param {string} [opts.itemId] - Only the changes that wrote this one
          *   entry, each with only its operations that did
-         * @returns {Promise<{entries: Array, nextCursor: (string|null)}>}
+         * @returns {Promise<Page<AuditEntry>>}
          */
         auditPage: (id: string, { startTime, endTime, opTypes, kinds, order, limit, cursor, opsLimit, entryId, itemId }?: {
             startTime?: string;
@@ -779,10 +1302,7 @@ export class PlaidClient {
             opsLimit?: number;
             entryId?: string;
             itemId?: string;
-        }) => Promise<{
-            entries: any[];
-            nextCursor: (string | null);
-        }>;
+        }) => Promise<Page<AuditEntry>>;
         /**
          * Put one entry of the vocabulary back as it was at `asOf`, as one
          * operation. A deleted entry comes back under its original id with its
@@ -811,15 +1331,17 @@ export class PlaidClient {
          * Delete a vocab layer.
          * @param {string} id - The resource ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (id: string, auditMessage?: string) => Promise<any>;
+        delete: (id: string, auditMessage?: string) => Promise<void>;
         /**
          * Update a vocab layer's name.
          * @param {string} id - The resource ID
          * @param {string} name - The name
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<VocabLayer>}
          */
-        update: (id: string, name: string, auditMessage?: string) => Promise<any>;
+        update: (id: string, name: string, auditMessage?: string) => Promise<VocabLayer>;
     };
     relations: {
         /**
@@ -827,49 +1349,55 @@ export class PlaidClient {
          * @param {string} relationId - The relation ID
          * @param {string} spanId - The span ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<Relation>}
          */
-        setTarget: (relationId: string, spanId: string, auditMessage?: string) => Promise<any>;
+        setTarget: (relationId: string, spanId: string, auditMessage?: string) => Promise<Relation>;
         /**
          * Get a relation by ID.
          * @param {string} relationId - The relation ID
+         * @returns {Promise<Relation>}
          */
-        get: (relationId: string) => Promise<any>;
+        get: (relationId: string) => Promise<Relation>;
         /**
          * Delete a relation.
          * @param {string} relationId - The relation ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (relationId: string, auditMessage?: string) => Promise<any>;
+        delete: (relationId: string, auditMessage?: string) => Promise<void>;
         /**
          * Update a relation's value.
          * @param {string} relationId - The relation ID
          * @param {any} value - The value
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<Relation>}
          */
-        update: (relationId: string, value: any, auditMessage?: string) => Promise<any>;
+        update: (relationId: string, value: any, auditMessage?: string) => Promise<Relation>;
         /**
          * Update the source span of a relation.
          * @param {string} relationId - The relation ID
          * @param {string} spanId - The span ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<Relation>}
          */
-        setSource: (relationId: string, spanId: string, auditMessage?: string) => Promise<any>;
+        setSource: (relationId: string, spanId: string, auditMessage?: string) => Promise<Relation>;
         /**
          * Create a new relation. A relation is a directed edge between two spans
          * with a value, useful for expressing phenomena such as syntactic or
          * semantic relations.
-         * @param {string} layerId - The relation layer ID
-         * @param {string} sourceId - The source span ID
-         * @param {string} targetId - The target span ID
+         * @param {string} relationLayerId - The relation layer ID
+         * @param {string} source - The source span ID
+         * @param {string} target - The target span ID
          * @param {any} value - The value
          * @param {any} [metadata] - Metadata map. Omit to leave unset; pass null to send JSON null.
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @returns {Promise<Created>}
          */
-        create: (layerId: string, sourceId: string, targetId: string, value: any, metadata?: any, auditMessage?: string, { id }?: {
+        create: (relationLayerId: string, source: string, target: string, value: any, metadata?: any, auditMessage?: string, { id }?: {
             id?: string;
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Create multiple relations in a single operation.
          * @param {Array} body - The request body
@@ -900,21 +1428,24 @@ export class PlaidClient {
          * @param {string} id - The entity's ID
          * @param {object} body - The new metadata map
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<any>;
+        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<Relation>;
         /**
          * Remove all metadata from an entity.
          * @param {string} id - The entity's ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        deleteMetadata: (id: string, auditMessage?: string) => Promise<any>;
+        deleteMetadata: (id: string, auditMessage?: string) => Promise<Relation>;
         /**
          * Edit an entity's metadata with a list of ops applied in order, in one operation. `{op: 'set', path, value}` writes value at path, creating missing objects along it; `{op: 'delete', path}` removes the key at path (a no-op when absent). A path is a non-empty array of keys, the first a top-level key. A path through a non-object is refused (400). See metadataOps and applyMetadataOps.
          * @param {string} id - The entity's ID
          * @param {MetadataOp[]} body - The metadata ops
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<any>;
+        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<Relation>;
     };
     spanLayers: {
         /**
@@ -924,35 +1455,55 @@ export class PlaidClient {
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @returns {Promise<Created>}
          */
         create: (tokenLayerId: string, name: string, auditMessage?: string, { id }?: {
             id?: string;
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Get a layer by ID.
          * @param {string} layerId - The layer ID
+         * @returns {Promise<LayerRecords[K]>}
          */
-        get: (layerId: string) => Promise<any>;
+        get: (layerId: string) => Promise<SpanLayer>;
         /**
          * Delete a layer.
          * @param {string} layerId - The layer ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (layerId: string, auditMessage?: string) => Promise<any>;
+        delete: (layerId: string, auditMessage?: string) => Promise<void>;
         /**
          * Rename a layer.
          * @param {string} layerId - The layer ID
          * @param {string} name - The new name
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<LayerRecords[K]>}
          */
-        update: (layerId: string, name: string, auditMessage?: string) => Promise<any>;
+        update: (layerId: string, name: string, auditMessage?: string) => Promise<SpanLayer>;
         /**
          * Move a layer one place in its display order.
          * @param {string} layerId - The layer ID
          * @param {string} direction - The direction ("up" or "down")
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<any>;
+        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<void>;
+        /**
+         * The stored values of this layer that a value-set rule would refuse,
+         * before it is declared: exactly what a declaration of it would meet,
+         * with the rule's exemptions (an unconfirmed machine value, a value an
+         * import, a document copy or a restore set). Writes nothing, and a
+         * reader may ask.
+         * @param {string} layerId - The layer ID
+         * @param {ValueSetRule} rule - The list as a value-set declaration takes it
+         * @param {{limit?: number}} [options] - `limit`: how many values to list, the most frequent first
+         *   (default 20, at most 100)
+         * @returns {Promise<RefusedValues>}
+         */
+        refusedValues: (layerId: string, rule: ValueSetRule, options?: {
+            limit?: number;
+        }) => Promise<RefusedValues>;
         /**
          * Declare an app namespace's constraints on this layer, replacing that
          * namespace's list. Refused with 422 and the violations when the layer's
@@ -977,18 +1528,22 @@ export class PlaidClient {
          * @param {string} namespace - The declaring app's namespace
          * @param {string} [auditMessage] - Audit message for this write
          * @param {{expected?: Array<object>|null}} [options] - `expected`, as on setConstraints.
+         * @returns {Promise<void>}
          */
         deleteConstraints: (layerId: string, namespace: string, auditMessage?: string, options?: {
             expected?: Array<object> | null;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * The violations the given constraints would meet in this layer's stored
          * data. Writes nothing.
          * @param {string} layerId - The layer ID
          * @param {LayerConstraint[]} constraints - The list to check
+         * @param {{limit?: number}} [options] - `limit`: how many violations to list (default 100)
          * @returns {Promise<{violations: ConstraintViolation[], violationCount: number}>}
          */
-        checkConstraints: (layerId: string, constraints: LayerConstraint[]) => Promise<{
+        checkConstraints: (layerId: string, constraints: LayerConstraint[], options?: {
+            limit?: number;
+        }) => Promise<{
             violations: ConstraintViolation[];
             violationCount: number;
         }>;
@@ -1024,22 +1579,27 @@ export class PlaidClient {
          * @param {any} configValue - Configuration value to set
          * @param {string} [auditMessage] - Audit message for this write
          * @param {{expected?: any}} [options] - `expected`: the value read for this key (null or undefined when it
-         *   was absent). The write is then refused with a 409 when the stored value differs.
+         *   was absent). The write is then refused with a 409 when the stored value differs. A value the key
+         *   already holds is not written and leaves no audit row, so the value read, expecting it, states in a
+         *   batch that the key is unchanged.
+         * @returns {Promise<void>}
          */
         setConfig: (id: string, namespace: string, configKey: string, configValue: any, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * Remove a configuration value.
          * @param {string} id - The record's ID
          * @param {string} namespace - The config namespace
          * @param {string} configKey - The config key
          * @param {string} [auditMessage] - Audit message for this write
-         * @param {{expected?: any}} [options] - `expected`, as on setConfig.
+         * @param {{expected?: any}} [options] - `expected`, as on setConfig. A key that is absent is not
+         *   written, so expecting null states in a batch that it is still absent.
+         * @returns {Promise<void>}
          */
         deleteConfig: (id: string, namespace: string, configKey: string, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
     };
     spans: {
         /**
@@ -1047,28 +1607,32 @@ export class PlaidClient {
          * @param {string} id - The entity's ID
          * @param {object} body - The new metadata map
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<any>;
+        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<Span>;
         /**
          * Remove all metadata from an entity.
          * @param {string} id - The entity's ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        deleteMetadata: (id: string, auditMessage?: string) => Promise<any>;
+        deleteMetadata: (id: string, auditMessage?: string) => Promise<Span>;
         /**
          * Edit an entity's metadata with a list of ops applied in order, in one operation. `{op: 'set', path, value}` writes value at path, creating missing objects along it; `{op: 'delete', path}` removes the key at path (a no-op when absent). A path is a non-empty array of keys, the first a top-level key. A path through a non-object is refused (400). See metadataOps and applyMetadataOps.
          * @param {string} id - The entity's ID
          * @param {MetadataOp[]} body - The metadata ops
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<any>;
+        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<Span>;
         /**
          * Replace tokens for a span.
          * @param {string} spanId - The span ID
          * @param {Array} tokens - The tokens
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<Span>}
          */
-        setTokens: (spanId: string, tokens: any[], auditMessage?: string) => Promise<any>;
+        setTokens: (spanId: string, tokens: any[], auditMessage?: string) => Promise<Span>;
         /**
          * Create a new span. A span holds a primary atomic value and optional
          * metadata, and must at all times be associated with one or more tokens.
@@ -1079,28 +1643,32 @@ export class PlaidClient {
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @returns {Promise<Created>}
          */
         create: (spanLayerId: string, tokens: any[], value: any, metadata?: any, auditMessage?: string, { id }?: {
             id?: string;
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Get a span by ID.
          * @param {string} spanId - The span ID
+         * @returns {Promise<Span>}
          */
-        get: (spanId: string) => Promise<any>;
+        get: (spanId: string) => Promise<Span>;
         /**
          * Delete a span.
          * @param {string} spanId - The span ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (spanId: string, auditMessage?: string) => Promise<any>;
+        delete: (spanId: string, auditMessage?: string) => Promise<void>;
         /**
          * Update a span's value.
          * @param {string} spanId - The span ID
          * @param {any} value - The value
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<Span>}
          */
-        update: (spanId: string, value: any, auditMessage?: string) => Promise<any>;
+        update: (spanId: string, value: any, auditMessage?: string) => Promise<Span>;
         /**
          * Create multiple spans in a single operation.
          * @param {Array} body - The request body
@@ -1181,26 +1749,32 @@ export class PlaidClient {
          * @param {string} body - The request body
          * @param {any} [metadata] - Metadata map. Omit to leave unset; pass null to send JSON null.
          * @param {string} [auditMessage]
-         * @param {{id?: string, tokenEdges?: number[]}} [options] - `id`: the new text's id, a UUIDv7
-         *   this client minted. `tokenEdges`: the code-point offsets where the tokens made next on
-         *   this text begin and end. The body is stored composed, except a character one of them
-         *   falls inside, which stays as sent (see composeText).
-         */
-        create: (textLayerId: string, documentId: string, body: string, metadata?: any, auditMessage?: string, { id, tokenEdges }?: {
+         * @param {{id?: string, tokenEdges?: number[], tokenizeLayer?: string}} [options] - `id`: the
+         *   new text's id, a UUIDv7 this client minted. `tokenEdges`: the code-point offsets where
+         *   the tokens made next on this text begin and end. The body is stored composed, except a
+         *   character one of them falls inside, which stays as sent (see composeText).
+         *   `tokenizeLayer`: a word layer of the text, which gets the body's words, cut by the
+         *   server ("Tokenize new text").
+         * @returns {Promise<Created>}
+         */
+        create: (textLayerId: string, documentId: string, body: string, metadata?: any, auditMessage?: string, { id, tokenEdges, tokenizeLayer }?: {
             id?: string;
             tokenEdges?: number[];
-        }) => Promise<any>;
+            tokenizeLayer?: string;
+        }) => Promise<Created>;
         /**
          * Get a text.
          * @param {string} textId - The text ID
+         * @returns {Promise<PlaidText>}
          */
-        get: (textId: string) => Promise<any>;
+        get: (textId: string) => Promise<PlaidText>;
         /**
          * Delete a text and all dependent data.
          * @param {string} textId - The text ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (textId: string, auditMessage?: string) => Promise<any>;
+        delete: (textId: string, auditMessage?: string) => Promise<void>;
         /**
          * Update a text's body. A diff is computed and token indices are updated
          * so that tokens remain intact. Alternatively, `body` can be a list of
@@ -1219,12 +1793,19 @@ export class PlaidClient {
          * @param {string} textId - The text ID
          * @param {any} body - The request body
          * @param {string} [auditMessage]
-         * @param {{base?: string, versioned?: boolean}} [options]
+         * `tokenizeLayer`: a word layer of the text, whose words the server makes for the text the
+         * update types, after it places the old tokens ("Tokenize new text"). They come in the
+         * answer's `reshape`.
+         * @param {{base?: string, versioned?: boolean, tokenizeLayer?: string}} [options]
+         * @returns {Promise<PlaidText & {reshape: TextReshape}>}
          */
-        update: (textId: string, body: any, auditMessage?: string, { base, versioned }?: {
+        update: (textId: string, body: any, auditMessage?: string, { base, versioned, tokenizeLayer }?: {
             base?: string;
             versioned?: boolean;
-        }) => Promise<any>;
+            tokenizeLayer?: string;
+        }) => Promise<PlaidText & {
+            reshape: TextReshape;
+        }>;
         /**
          * Change a text's body by the edits made at the caret: a list of edit
          * directives as `update` takes them (code-point indices, applied in
@@ -1236,36 +1817,43 @@ export class PlaidClient {
          * `base`, the digest of the body the edits were made on, the edit
          * applies only to that body and is refused with 409 and `text-changed`
          * otherwise, and strict mode does not stamp it unless `versioned` is
-         * true. See composeTextEdits and gapsToOps.
+         * true. `tokenizeLayer` is as `update` takes it. See composeTextEdits and gapsToOps.
          * @param {string} textId - The text ID
          * @param {Array<object>} edits - The edit directives
          * @param {string} [auditMessage]
-         * @param {{base?: string, versioned?: boolean}} [options]
+         * @param {{base?: string, versioned?: boolean, tokenizeLayer?: string}} [options]
+         * @returns {Promise<PlaidText & {reshape: TextReshape}>}
          */
-        edit: (textId: string, edits: Array<object>, auditMessage?: string, { base, versioned }?: {
+        edit: (textId: string, edits: Array<object>, auditMessage?: string, { base, versioned, tokenizeLayer }?: {
             base?: string;
             versioned?: boolean;
-        }) => Promise<any>;
+            tokenizeLayer?: string;
+        }) => Promise<PlaidText & {
+            reshape: TextReshape;
+        }>;
         /**
          * Replace all metadata of an entity. Keys left out of the new map are removed.
          * @param {string} id - The entity's ID
          * @param {object} body - The new metadata map
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<any>;
+        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<PlaidText>;
         /**
          * Remove all metadata from an entity.
          * @param {string} id - The entity's ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        deleteMetadata: (id: string, auditMessage?: string) => Promise<any>;
+        deleteMetadata: (id: string, auditMessage?: string) => Promise<PlaidText>;
         /**
          * Edit an entity's metadata with a list of ops applied in order, in one operation. `{op: 'set', path, value}` writes value at path, creating missing objects along it; `{op: 'delete', path}` removes the key at path (a no-op when absent). A path is a non-empty array of keys, the first a top-level key. A path through a non-object is refused (400). See metadataOps and applyMetadataOps.
          * @param {string} id - The entity's ID
          * @param {MetadataOp[]} body - The metadata ops
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<any>;
+        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<PlaidText>;
     };
     users: {
         /**
@@ -1273,37 +1861,35 @@ export class PlaidClient {
          * returns the full flat array. Admin-or-maintainer only.
          * @param {object} [opts]
          * @param {string} [opts.q] - Filter to users whose display name contains this text, or whose email starts with it (contains it, when the text holds an at sign), case-insensitive
+         * @returns {Promise<User[]>}
          */
         list: ({ q }?: {
             q?: string;
-        }) => Promise<any[]>;
+        }) => Promise<User[]>;
         /**
          * Fetch a single page of users (optionally filtered by `q`).
          * @param {object} [opts]
          * @param {string} [opts.q] - Filter to users whose display name contains this text, or whose email starts with it (contains it, when the text holds an at sign), case-insensitive
          * @param {number} [opts.limit] - Page size (1..1000; server default 100)
          * @param {string} [opts.cursor] - Opaque cursor from a previous page
-         * @returns {Promise<{entries: Array, nextCursor: (string|null)}>}
+         * @returns {Promise<Page<User>>}
          */
         listPage: ({ q, limit, cursor }?: {
             q?: string;
             limit?: number;
             cursor?: string;
-        }) => Promise<{
-            entries: any[];
-            nextCursor: (string | null);
-        }>;
+        }) => Promise<Page<User>>;
         /**
          * Async-iterate users page by page; yields each page's entries array.
          * @param {object} [opts]
          * @param {string} [opts.q] - Filter to users whose display name contains this text, or whose email starts with it (contains it, when the text holds an at sign), case-insensitive
          * @param {number} [opts.pageSize] - Per-request page size
-         * @returns {AsyncGenerator<Array>}
+         * @returns {AsyncGenerator<User[]>}
          */
         iterPages: ({ q, pageSize }?: {
             q?: string;
             pageSize?: number;
-        }) => AsyncGenerator<any[]>;
+        }) => AsyncGenerator<User[]>;
         /**
          * Create a new user. Admin only, and not with a named API token (403):
          * it needs a sign-in token.
@@ -1314,8 +1900,9 @@ export class PlaidClient {
          * @param {string} [displayName] - How the user is shown in the UI.
          *   Defaults to the local part of the email.
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<Created>}
          */
-        create: (email: string, password: string, isAdmin: boolean, displayName?: string, auditMessage?: string) => Promise<any>;
+        create: (email: string, password: string, isAdmin: boolean, displayName?: string, auditMessage?: string) => Promise<Created>;
         /**
          * Get audit log for a user's actions. Transparently follows pagination
          * cursors and returns the full flat array.
@@ -1328,8 +1915,9 @@ export class PlaidClient {
          *   one of its operations matches, carrying only the ones that did.
          * @param {string[]|string} [kinds] - Only the entries of operations of
          *   these kinds (e.g. `['review', 'guess-adoption']`), each whole
+         * @returns {Promise<AuditEntry[]>}
          */
-        audit: (userId: string, startTime?: string, endTime?: string, opTypes?: string[] | string, kinds?: string[] | string) => Promise<any[]>;
+        audit: (userId: string, startTime?: string, endTime?: string, opTypes?: string[] | string, kinds?: string[] | string) => Promise<AuditEntry[]>;
         /**
          * One page of the same log, newest-first with `order: "desc"`. Use this
          * rather than audit() wherever the caller wants the recent end of a log
@@ -1347,7 +1935,7 @@ export class PlaidClient {
          *   operations in `ops` (1..1000). `opCount` on every entry says how
          *   many it has
          * @param {string} [opts.entryId] - Read only this entry, not a page
-         * @returns {Promise<{entries: Array, nextCursor: (string|null)}>}
+         * @returns {Promise<Page<AuditEntry>>}
          */
         auditPage: (userId: string, { startTime, endTime, opTypes, kinds, order, limit, cursor, opsLimit, entryId }?: {
             startTime?: string;
@@ -1359,15 +1947,13 @@ export class PlaidClient {
             cursor?: string;
             opsLimit?: number;
             entryId?: string;
-        }) => Promise<{
-            entries: any[];
-            nextCursor: (string | null);
-        }>;
+        }) => Promise<Page<AuditEntry>>;
         /**
          * Get a user by ID
          * @param {string} id - The resource ID
+         * @returns {Promise<User>}
          */
-        get: (id: string) => Promise<any>;
+        get: (id: string) => Promise<User>;
         /**
          * Deactivate a user. Users are never hard-deleted: deactivation
          * rejects their logins and tokens, strips their project memberships
@@ -1376,16 +1962,18 @@ export class PlaidClient {
          * Reversible via activate(), which restores login only.
          * @param {string} id - The resource ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (id: string, auditMessage?: string) => Promise<any>;
+        delete: (id: string, auditMessage?: string) => Promise<void>;
         /**
          * Reactivate a deactivated user, restoring their ability to log in.
          * Project memberships, vocab maintainerships, and API tokens removed
          * at deactivation are NOT restored — re-grant them deliberately.
          * @param {string} id - The resource ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<User>}
          */
-        activate: (id: string, auditMessage?: string) => Promise<any>;
+        activate: (id: string, auditMessage?: string) => Promise<User>;
         /**
          * Modify a user. Admins may change the display name, password, and admin
          * status of any user. All other users may only modify their own display
@@ -1399,8 +1987,9 @@ export class PlaidClient {
          * @param {string} [displayName] - New display name
          * @param {boolean} [isAdmin] - New admin status
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<User>}
          */
-        update: (id: string, password?: string, displayName?: string, isAdmin?: boolean, auditMessage?: string) => Promise<any>;
+        update: (id: string, password?: string, displayName?: string, isAdmin?: boolean, auditMessage?: string) => Promise<User>;
         /**
          * A token that shows any user's profile picture without an
          * Authorization header, for an `<img>`, which cannot send one. Resolves
@@ -1449,8 +2038,9 @@ export class PlaidClient {
          * Fetch a user's profile picture as raw bytes. Most callers want
          * avatarUrl() instead. This one is for non-browser consumers.
          * @param {string} id - The user ID
+         * @returns {Promise<ArrayBuffer>}
          */
-        getAvatar: (id: string) => Promise<any>;
+        getAvatar: (id: string) => Promise<ArrayBuffer>;
         /**
          * Upload a profile picture. Your own, or anyone's if you are an admin.
          * The server center-crops to a square, scales to the configured edge
@@ -1459,14 +2049,16 @@ export class PlaidClient {
          * @param {string} id - The user ID
          * @param {File} file - The image to upload
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<User>}
          */
-        setAvatar: (id: string, file: File, auditMessage?: string) => Promise<any>;
+        setAvatar: (id: string, file: File, auditMessage?: string) => Promise<User>;
         /**
          * Remove a profile picture. Your own, or anyone's if you are an admin.
          * @param {string} id - The user ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        deleteAvatar: (id: string, auditMessage?: string) => Promise<any>;
+        deleteAvatar: (id: string, auditMessage?: string) => Promise<void>;
     };
     userData: {
         /**
@@ -1579,8 +2171,9 @@ export class PlaidClient {
          * Delete one private data entry; 404 if absent.
          * @param {string} userId
          * @param {string} key
+         * @returns {Promise<void>}
          */
-        delete: (userId: string, key: string) => Promise<any>;
+        delete: (userId: string, key: string) => Promise<void>;
     };
     apiTokens: {
         /**
@@ -1588,34 +2181,32 @@ export class PlaidClient {
          * string itself — that is only returned once, by create().
          * Transparently follows pagination cursors and returns the full flat array.
          * @param {string} userId - The user ID who owns the tokens
+         * @returns {Promise<ApiToken[]>}
          */
-        list: (userId: string) => Promise<any[]>;
+        list: (userId: string) => Promise<ApiToken[]>;
         /**
          * Fetch a single page of a user's named API tokens.
          * @param {string} userId - The user ID who owns the tokens
          * @param {object} [opts]
          * @param {number} [opts.limit] - Page size (1..1000; server default 100)
          * @param {string} [opts.cursor] - Opaque cursor from a previous page
-         * @returns {Promise<{entries: Array, nextCursor: (string|null)}>}
+         * @returns {Promise<Page<ApiToken>>}
          */
         listPage: (userId: string, { limit, cursor }?: {
             limit?: number;
             cursor?: string;
-        }) => Promise<{
-            entries: any[];
-            nextCursor: (string | null);
-        }>;
+        }) => Promise<Page<ApiToken>>;
         /**
          * Async-iterate a user's named API tokens page by page; yields each
          * page's entries array.
          * @param {string} userId - The user ID who owns the tokens
          * @param {object} [opts]
          * @param {number} [opts.pageSize] - Per-request page size
-         * @returns {AsyncGenerator<Array>}
+         * @returns {AsyncGenerator<ApiToken[]>}
          */
         iterPages: (userId: string, { pageSize }?: {
             pageSize?: number;
-        }) => AsyncGenerator<any[]>;
+        }) => AsyncGenerator<ApiToken[]>;
         /**
          * Mint a named API token for a user. The returned `token` is the signed
          * credential and is shown ONLY here — store it immediately. API tokens
@@ -1639,8 +2230,9 @@ export class PlaidClient {
          * @param {string} userId - The user ID who owns the token
          * @param {string} tokenId - The token ID to revoke
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        revoke: (userId: string, tokenId: string, auditMessage?: string) => Promise<any>;
+        revoke: (userId: string, tokenId: string, auditMessage?: string) => Promise<void>;
     };
     invites: {
         /**
@@ -1731,8 +2323,9 @@ export class PlaidClient {
          * the creator, an admin, or a maintainer of the invite's project.
          * @param {string} id - The invite ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        revoke: (id: string, auditMessage?: string) => Promise<any>;
+        revoke: (id: string, auditMessage?: string) => Promise<void>;
     };
     admin: {
         /**
@@ -1902,13 +2495,14 @@ export class PlaidClient {
          *   matches, carrying only the ones that did.
          * @param {string[]|string} [opts.kinds] - Only the entries of operations
          *   of these kinds (e.g. `['review']`), each whole
+         * @returns {Promise<AuditEntry[]>}
          */
         list: ({ startTime, endTime, opTypes, kinds }?: {
             startTime?: string;
             endTime?: string;
             opTypes?: string[] | string;
             kinds?: string[] | string;
-        }) => Promise<any[]>;
+        }) => Promise<AuditEntry[]>;
         /**
          * Fetch a single page of the instance-wide audit log. Admin only.
          * @param {object} [opts]
@@ -1924,7 +2518,7 @@ export class PlaidClient {
          *   operations in `ops` (1..1000). `opCount` on every entry says how
          *   many it has
          * @param {string} [opts.entryId] - Read only this entry, not a page
-         * @returns {Promise<{entries: Array, nextCursor: (string|null)}>}
+         * @returns {Promise<Page<AuditEntry>>}
          */
         listPage: ({ startTime, endTime, opTypes, kinds, order, limit, cursor, opsLimit, entryId }?: {
             startTime?: string;
@@ -1936,10 +2530,7 @@ export class PlaidClient {
             cursor?: string;
             opsLimit?: number;
             entryId?: string;
-        }) => Promise<{
-            entries: any[];
-            nextCursor: (string | null);
-        }>;
+        }) => Promise<Page<AuditEntry>>;
         /**
          * Async-iterate the instance-wide audit log page by page. Admin only.
          * @param {object} [opts]
@@ -1948,7 +2539,7 @@ export class PlaidClient {
          * @param {string[]|string} [opts.opTypes] - Only these op types
          * @param {OperationKind[]|string} [opts.kinds] - Only the entries of operations of these kinds, each whole
          * @param {number} [opts.pageSize] - Per-request page size
-         * @returns {AsyncGenerator<Array>}
+         * @returns {AsyncGenerator<AuditEntry[]>}
          */
         iterPages: ({ startTime, endTime, opTypes, kinds, pageSize }?: {
             startTime?: string;
@@ -1956,7 +2547,7 @@ export class PlaidClient {
             opTypes?: string[] | string;
             kinds?: OperationKind[] | string;
             pageSize?: number;
-        }) => AsyncGenerator<any[]>;
+        }) => AsyncGenerator<AuditEntry[]>;
         /**
          * Per-user activity counts. `changes` is the number of logical actions,
          * folded the way the audit feed folds them, so one "Confirm word
@@ -2007,18 +2598,22 @@ export class PlaidClient {
          * @param {string} namespace - The declaring app's namespace
          * @param {string} [auditMessage] - Audit message for this write
          * @param {{expected?: Array<object>|null}} [options] - `expected`, as on setConstraints.
+         * @returns {Promise<void>}
          */
         deleteConstraints: (layerId: string, namespace: string, auditMessage?: string, options?: {
             expected?: Array<object> | null;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * The violations the given constraints would meet in this layer's stored
          * data. Writes nothing.
          * @param {string} layerId - The layer ID
          * @param {LayerConstraint[]} constraints - The list to check
+         * @param {{limit?: number}} [options] - `limit`: how many violations to list (default 100)
          * @returns {Promise<{violations: ConstraintViolation[], violationCount: number}>}
          */
-        checkConstraints: (layerId: string, constraints: LayerConstraint[]) => Promise<{
+        checkConstraints: (layerId: string, constraints: LayerConstraint[], options?: {
+            limit?: number;
+        }) => Promise<{
             violations: ConstraintViolation[];
             violationCount: number;
         }>;
@@ -2054,22 +2649,44 @@ export class PlaidClient {
          * @param {any} configValue - Configuration value to set
          * @param {string} [auditMessage] - Audit message for this write
          * @param {{expected?: any}} [options] - `expected`: the value read for this key (null or undefined when it
-         *   was absent). The write is then refused with a 409 when the stored value differs.
+         *   was absent). The write is then refused with a 409 when the stored value differs. A value the key
+         *   already holds is not written and leaves no audit row, so the value read, expecting it, states in a
+         *   batch that the key is unchanged.
+         * @returns {Promise<void>}
          */
         setConfig: (id: string, namespace: string, configKey: string, configValue: any, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * Remove a configuration value.
          * @param {string} id - The record's ID
          * @param {string} namespace - The config namespace
          * @param {string} configKey - The config key
          * @param {string} [auditMessage] - Audit message for this write
-         * @param {{expected?: any}} [options] - `expected`, as on setConfig.
+         * @param {{expected?: any}} [options] - `expected`, as on setConfig. A key that is absent is not
+         *   written, so expecting null states in a batch that it is still absent.
+         * @returns {Promise<void>}
          */
         deleteConfig: (id: string, namespace: string, configKey: string, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
+        /**
+         * Count, per document, the tokens of each layer whose surface matches a
+         * regex, as a query's `value: {regex}` on a token decides. Each text is
+         * read once, so it stays fast on a long document. Layers you cannot read
+         * are left out.
+         * @param {string[]} layerIds - The token layer ids
+         * @param {{regex: string, flags?: string}} value - The regex spec
+         * @returns {Promise<{results: Array<[string, string, number]>}>} [layerId,
+         *   documentId, count] rows, a document with tokens of the layer and no
+         *   match counting 0.
+         */
+        countMatching: (layerIds: string[], value: {
+            regex: string;
+            flags?: string;
+        }) => Promise<{
+            results: Array<[string, string, number]>;
+        }>;
         /**
          * Create a new token layer.
          * @param {string} textLayerId - The text layer ID
@@ -2079,35 +2696,40 @@ export class PlaidClient {
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @returns {Promise<Created>}
          */
         create: (textLayerId: string, name: string, overlapMode?: string, parentTokenLayerId?: string, auditMessage?: string, { id }?: {
             id?: string;
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Get a layer by ID.
          * @param {string} layerId - The layer ID
+         * @returns {Promise<LayerRecords[K]>}
          */
-        get: (layerId: string) => Promise<any>;
+        get: (layerId: string) => Promise<TokenLayer>;
         /**
          * Delete a layer.
          * @param {string} layerId - The layer ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (layerId: string, auditMessage?: string) => Promise<any>;
+        delete: (layerId: string, auditMessage?: string) => Promise<void>;
         /**
          * Rename a layer.
          * @param {string} layerId - The layer ID
          * @param {string} name - The new name
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<LayerRecords[K]>}
          */
-        update: (layerId: string, name: string, auditMessage?: string) => Promise<any>;
+        update: (layerId: string, name: string, auditMessage?: string) => Promise<TokenLayer>;
         /**
          * Move a layer one place in its display order.
          * @param {string} layerId - The layer ID
          * @param {string} direction - The direction ("up" or "down")
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<any>;
+        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<void>;
     };
     documents: {
         /**
@@ -2126,8 +2748,9 @@ export class PlaidClient {
          *   one of its operations matches, carrying only the ones that did.
          * @param {string[]|string} [kinds] - Only the entries of operations of
          *   these kinds (e.g. `['review', 'guess-adoption']`), each whole
+         * @returns {Promise<AuditEntry[]>}
          */
-        audit: (documentId: string, startTime?: string, endTime?: string, opTypes?: string[] | string, kinds?: string[] | string) => Promise<any[]>;
+        audit: (documentId: string, startTime?: string, endTime?: string, opTypes?: string[] | string, kinds?: string[] | string) => Promise<AuditEntry[]>;
         /**
          * One page of the same log, newest-first with `order: "desc"`. Use this
          * rather than audit() wherever the caller wants the recent end of a log
@@ -2145,7 +2768,7 @@ export class PlaidClient {
          *   operations in `ops` (1..1000). `opCount` on every entry says how
          *   many it has
          * @param {string} [opts.entryId] - Read only this entry, not a page
-         * @returns {Promise<{entries: Array, nextCursor: (string|null)}>}
+         * @returns {Promise<Page<AuditEntry>>}
          */
         auditPage: (documentId: string, { startTime, endTime, opTypes, kinds, order, limit, cursor, opsLimit, entryId }?: {
             startTime?: string;
@@ -2157,16 +2780,15 @@ export class PlaidClient {
             cursor?: string;
             opsLimit?: number;
             entryId?: string;
-        }) => Promise<{
-            entries: any[];
-            nextCursor: (string | null);
-        }>;
+        }) => Promise<Page<AuditEntry>>;
         /**
          * Restore a document to its state at an earlier time, as one
          * operation: what was deleted since then comes back under its original
          * id, what was added since is removed, and what changed is set back,
          * across every layer. A layer deleted since then, or a vocabulary entry
-         * that no longer exists, is skipped and reported under `skipped`.
+         * that no longer exists, is skipped and reported under `skipped`. A name
+         * another document holds now stays with it, and the document keeps its
+         * current name, reported under `nameKept` (`{name, taken}`).
          * Resolves to a summary of the changes. Maintainers only.
          * @param {string} documentId - The document ID
          * @param {string} asOf - The moment to go back to (ISO-8601 instant),
@@ -2174,13 +2796,18 @@ export class PlaidClient {
          * @param {{dryRun?: boolean}} [options] - `{ dryRun }`: with `dryRun` true nothing
          *   is written and the summary says what would change
          * @param {string} [auditMessage] - Custom audit message for this operation
+         * @returns {Promise<DocumentRestoreSummary>}
          */
         restore: (documentId: string, asOf: string, { dryRun }?: {
             dryRun?: boolean;
-        }, auditMessage?: string) => Promise<any>;
+        }, auditMessage?: string) => Promise<DocumentRestoreSummary>;
         /**
          * Get a document. Set `includeBody` to true to include all data.
          *
+         * A document with a recording has `mediaUrl`, and `mediaDuration`, the
+         * recording's length in seconds, when the server could read it from the
+         * file at upload (WAV, MP4, M4A, MOV, FLAC, MP3).
+         *
          * `layers` narrows a body read to the layers you name (ids of any kind:
          * text, token, span, or relation). A layer comes back when it is named
          * or is an ancestor of a named layer, and carries its own
@@ -2192,21 +2819,26 @@ export class PlaidClient {
          * @param {boolean} [includeBody] - Include document body data
          * @param {string} [asOf] - Temporal query timestamp
          * @param {string[]|string} [layers] - Layer ids to restrict a body read to
+         * @returns {Promise<PlaidDocument>}
          */
-        get: (documentId: string, includeBody?: boolean, asOf?: string, layers?: string[] | string) => Promise<any>;
+        get: (documentId: string, includeBody?: boolean, asOf?: string, layers?: string[] | string) => Promise<PlaidDocument>;
         /**
          * Delete a document and all data contained.
          * @param {string} documentId - The document ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (documentId: string, auditMessage?: string) => Promise<any>;
+        delete: (documentId: string, auditMessage?: string) => Promise<void>;
         /**
-         * Update a document's name.
+         * Update a document's name. A name another document of the project holds,
+         * ignoring case,
+         * is refused with 422 and `name-taken`.
          * @param {string} documentId - The document ID
          * @param {string} name - The name
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<PlaidDocument>}
          */
-        update: (documentId: string, name: string, auditMessage?: string) => Promise<any>;
+        update: (documentId: string, name: string, auditMessage?: string) => Promise<PlaidDocument>;
         /**
          * Create a new document in a project.
          * @param {string} projectId - The project ID
@@ -2215,30 +2847,43 @@ export class PlaidClient {
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @param {boolean} [opts.freeName] - A name another document of the project holds, ignoring case, becomes
+         *   the first free "name (2)", "name (3)" and on. Without it such a name is refused with 422
+         *   and `name-taken`.
+         * @returns {Promise<{id: string, name: string}>} The new id and the name stored
          */
-        create: (projectId: string, name: string, metadata?: any, auditMessage?: string, { id }?: {
+        create: (projectId: string, name: string, metadata?: any, auditMessage?: string, { id, freeName }?: {
             id?: string;
-        }) => Promise<any>;
+            freeName?: boolean;
+        }) => Promise<{
+            id: string;
+            name: string;
+        }>;
         /**
          * Copy a document and everything in it into a new document of the same
          * project, as one operation. The copy shares the source's layers and
          * the vocabulary entries its links name, and holds the source's texts,
          * tokens, spans, relations and vocab links under fresh ids, with their
          * metadata. Comments do not travel. The media file does, unless
-         * `includeMedia` is false. Resolves to `{ id }`, plus `mediaError` when
-         * the source had media the copy could not take with it.
+         * `includeMedia` is false. Resolves to `{ id, name }`, plus `mediaError` when
+         * the source had media the copy could not take with it. A name another
+         * document of the project holds, ignoring case, is refused with 422 and `name-taken`,
+         * unless `freeName`, which takes the first free "name (2)", "name (3)"
+         * and on.
          * @param {string} documentId - The document to copy
          * @param {string} name - The new document's name
-         * @param {{includeMedia?: boolean, id?: string}} [options] - `{ includeMedia }`: false leaves the media
+         * @param {{includeMedia?: boolean, id?: string, freeName?: boolean}} [options] - `{ includeMedia }`: false leaves the media
          *   file behind
          * @param {string} [auditMessage] - Custom audit message for this operation
-         * @returns {Promise<{id: string, mediaError?: string}>}
+         * @returns {Promise<{id: string, name: string, mediaError?: string}>}
          */
-        copy: (documentId: string, name: string, { includeMedia, id }?: {
+        copy: (documentId: string, name: string, { includeMedia, id, freeName }?: {
             includeMedia?: boolean;
             id?: string;
+            freeName?: boolean;
         }, auditMessage?: string) => Promise<{
             id: string;
+            name: string;
             mediaError?: string;
         }>;
         /**
@@ -2246,26 +2891,33 @@ export class PlaidClient {
          * @param {string} id - The entity's ID
          * @param {object} body - The new metadata map
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<any>;
+        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<PlaidDocument>;
         /**
          * Remove all metadata from an entity.
          * @param {string} id - The entity's ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        deleteMetadata: (id: string, auditMessage?: string) => Promise<any>;
+        deleteMetadata: (id: string, auditMessage?: string) => Promise<PlaidDocument>;
         /**
          * Edit an entity's metadata with a list of ops applied in order, in one operation. `{op: 'set', path, value}` writes value at path, creating missing objects along it; `{op: 'delete', path}` removes the key at path (a no-op when absent). A path is a non-empty array of keys, the first a top-level key. A path through a non-object is refused (400). See metadataOps and applyMetadataOps.
          * @param {string} id - The entity's ID
          * @param {MetadataOp[]} body - The metadata ops
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<any>;
+        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<PlaidDocument>;
         /**
          * Check the lock status of a document.
          * @param {string} documentId - The document ID
+         * @returns {Promise<{userId: string, expiresAt: number} | void>}
          */
-        checkLock: (documentId: string) => Promise<any>;
+        checkLock: (documentId: string) => Promise<{
+            userId: string;
+            expiresAt: number;
+        } | void>;
         /**
          * Acquire a document lock as a new holder.
          *
@@ -2287,8 +2939,9 @@ export class PlaidClient {
          * @param {string} documentId - The document ID
          * @param {string} [auditMessage]
          * @param {string} [newLockId] - A holder id this client minted
+         * @returns {Promise<LockGrant>}
          */
-        acquireLock: (documentId: string, auditMessage?: string, newLockId?: string) => Promise<any>;
+        acquireLock: (documentId: string, auditMessage?: string, newLockId?: string) => Promise<LockGrant>;
         /**
          * Renew the lock `lockId` holds while it is live. HTTP 423 if another
          * holder has it, and also once it has expired or been dropped, even when
@@ -2297,8 +2950,9 @@ export class PlaidClient {
          * @param {string} documentId - The document ID
          * @param {string} lockId - The `lockId` acquireLock answered with
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<LockGrant>}
          */
-        renewLock: (documentId: string, lockId: string, auditMessage?: string) => Promise<any>;
+        renewLock: (documentId: string, lockId: string, auditMessage?: string) => Promise<LockGrant>;
         /**
          * Release the lock `lockId` holds. Idempotent: a lock that holder no
          * longer has is left alone. outOfBand, for the same reason as
@@ -2307,8 +2961,9 @@ export class PlaidClient {
          * @param {string} documentId - The document ID
          * @param {string} lockId - The `lockId` acquireLock answered with
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        releaseLock: (documentId: string, lockId: string, auditMessage?: string) => Promise<any>;
+        releaseLock: (documentId: string, lockId: string, auditMessage?: string) => Promise<void>;
         /**
          * Hold this document's server-enforced lock for the length of `fn`,
          * releasing it on the way out (including on error). Resolves to what
@@ -2345,6 +3000,12 @@ export class PlaidClient {
          * lost lock is recorded on the CLIENT, like strict mode, so it stops
          * every write the client makes (on any batch of it too) and not only the
          * ones this block makes.
+         *
+         * A core restart drops every lock, and until the next renewal finds it
+         * gone (up to half the lock window) this block's writes still pass, since
+         * writes carry no lock id. When a write must not land past that point,
+         * hold the document in strict mode too (`enterStrictMode`), so such a
+         * write is refused with a 409.
          * @template T
          * @param {string} documentId - The document ID
          * @param {(lock: import("./documentLock.js").DocumentLock) => T | Promise<T>} fn - The work to run while holding it
@@ -2391,13 +3052,18 @@ export class PlaidClient {
          * @param {File} file - The file to upload
          * @param {string} [auditMessage] - Custom audit-log message for this write
          * @param {{onProgress?: (progress: {loaded: number, total: number | null}) => void}} [options] - `{ onProgress }`: called with `{ loaded, total }` (bytes) as the file goes up. In a browser the upload then travels by XMLHttpRequest, and the request timeout only fires when the upload stalls, not on total time.
+         * @returns {Promise<{message: string, extension: string, contentType: string}>}
          */
         uploadMedia: (documentId: string, file: File, auditMessage?: string, { onProgress }?: {
             onProgress?: (progress: {
                 loaded: number;
                 total: number | null;
             }) => void;
-        }) => Promise<any>;
+        }) => Promise<{
+            message: string;
+            extension: string;
+            contentType: string;
+        }>;
         /**
          * Delete media file for a document
          * @param {string} documentId - The document ID
@@ -2406,10 +3072,11 @@ export class PlaidClient {
          *   recording meant, the `?v=` of the document's `mediaUrl`. The delete
          *   is refused with a 409 (`media-changed`, and the current `media-url`)
          *   when the stored recording is another one.
+         * @returns {Promise<void>}
          */
         deleteMedia: (documentId: string, auditMessage?: string, { mediaVersion }?: {
             mediaVersion?: string;
-        }) => Promise<any>;
+        }) => Promise<void>;
     };
     projects: {
         /**
@@ -2417,15 +3084,17 @@ export class PlaidClient {
          * @param {string} id - The resource ID
          * @param {string} userId - The user ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        addMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<any>;
+        addMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<void>;
         /**
          * Remove a user's maintainer privileges for this project.
          * @param {string} id - The resource ID
          * @param {string} userId - The user ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        removeMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<any>;
+        removeMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<void>;
         /**
          * Get audit log for a project. Transparently follows pagination cursors
          * and returns the full flat array. Each entry, and each of its `ops`,
@@ -2442,8 +3111,9 @@ export class PlaidClient {
          *   one of its operations matches, carrying only the ones that did.
          * @param {string[]|string} [kinds] - Only the entries of operations of
          *   these kinds (e.g. `['review', 'guess-adoption']`), each whole
+         * @returns {Promise<AuditEntry[]>}
          */
-        audit: (projectId: string, startTime?: string, endTime?: string, opTypes?: string[] | string, kinds?: string[] | string) => Promise<any[]>;
+        audit: (projectId: string, startTime?: string, endTime?: string, opTypes?: string[] | string, kinds?: string[] | string) => Promise<AuditEntry[]>;
         /**
          * One page of the same log, newest-first with `order: "desc"`. Use this
          * rather than audit() wherever the caller wants the recent end of a log
@@ -2461,7 +3131,7 @@ export class PlaidClient {
          *   operations in `ops` (1..1000). `opCount` on every entry says how
          *   many it has
          * @param {string} [opts.entryId] - Read only this entry, not a page
-         * @returns {Promise<{entries: Array, nextCursor: (string|null)}>}
+         * @returns {Promise<Page<AuditEntry>>}
          */
         auditPage: (projectId: string, { startTime, endTime, opTypes, kinds, order, limit, cursor, opsLimit, entryId }?: {
             startTime?: string;
@@ -2473,10 +3143,7 @@ export class PlaidClient {
             cursor?: string;
             opsLimit?: number;
             entryId?: string;
-        }) => Promise<{
-            entries: any[];
-            nextCursor: (string | null);
-        }>;
+        }) => Promise<Page<AuditEntry>>;
         /**
          * When the calling user last wrote to each document in a project, as a
          * `{documentId: timestamp}` map. Documents they have never written to
@@ -2495,21 +3162,24 @@ export class PlaidClient {
          * @param {string} id - The resource ID
          * @param {string} vocabId - The vocab layer ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        linkVocab: (id: string, vocabId: string, auditMessage?: string) => Promise<any>;
+        linkVocab: (id: string, vocabId: string, auditMessage?: string) => Promise<void>;
         /**
          * Unlink a vocabulary from a project.
          * @param {string} id - The resource ID
          * @param {string} vocabId - The vocab layer ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        unlinkVocab: (id: string, vocabId: string, auditMessage?: string) => Promise<any>;
+        unlinkVocab: (id: string, vocabId: string, auditMessage?: string) => Promise<void>;
         /**
          * Get a project by ID. To fetch the project's documents, use
          * listDocuments(id) — the include-documents flag has been removed.
          * @param {string} id - The resource ID
+         * @returns {Promise<Project>}
          */
-        get: (id: string) => Promise<any>;
+        get: (id: string) => Promise<Project>;
         /**
          * List all documents in a project. Transparently follows pagination
          * cursors and returns the full flat array.
@@ -2517,8 +3187,9 @@ export class PlaidClient {
          * Note: this endpoint does not support temporal (`as-of`) queries; the
          * server rejects `?as-of=` on the documents-list route with a 400.
          * @param {string} id - The project ID
+         * @returns {Promise<DocumentListEntry[]>}
          */
-        listDocuments: (id: string) => Promise<any[]>;
+        listDocuments: (id: string) => Promise<DocumentListEntry[]>;
         /**
          * Fetch a single page of a project's documents.
          *
@@ -2528,15 +3199,12 @@ export class PlaidClient {
          * @param {object} [opts]
          * @param {number} [opts.limit] - Page size (1..1000; server default 100)
          * @param {string} [opts.cursor] - Opaque cursor from a previous page
-         * @returns {Promise<{entries: Array, nextCursor: (string|null)}>}
+         * @returns {Promise<Page<DocumentListEntry>>}
          */
         listDocumentsPage: (id: string, { limit, cursor }?: {
             limit?: number;
             cursor?: string;
-        }) => Promise<{
-            entries: any[];
-            nextCursor: (string | null);
-        }>;
+        }) => Promise<Page<DocumentListEntry>>;
         /**
          * Async-iterate a project's documents page by page; yields each page's
          * entries array.
@@ -2546,11 +3214,11 @@ export class PlaidClient {
          * @param {string} id - The project ID
          * @param {object} [opts]
          * @param {number} [opts.pageSize] - Per-request page size
-         * @returns {AsyncGenerator<Array>}
+         * @returns {AsyncGenerator<DocumentListEntry[]>}
          */
         iterDocuments: (id: string, { pageSize }?: {
             pageSize?: number;
-        }) => AsyncGenerator<any[]>;
+        }) => AsyncGenerator<DocumentListEntry[]>;
         /**
          * Delete a project and everything in it. This is irrecoverable. The
          * project is gone when this returns, and what it holds is removed on
@@ -2559,55 +3227,56 @@ export class PlaidClient {
          * @param {string} [auditMessage] - Custom audit-log message
          * @param {object} [options]
          * @param {number} [options.timeout] - Per-request timeout in ms, the client's own by default (0/null disables)
+         * @returns {Promise<void>}
          */
         delete: (id: string, auditMessage?: string, { timeout }?: {
             timeout?: number;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * Update a project's name.
          * @param {string} id - The resource ID
          * @param {string} name - The name
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<Project>}
          */
-        update: (id: string, name: string, auditMessage?: string) => Promise<any>;
+        update: (id: string, name: string, auditMessage?: string) => Promise<Project>;
         /**
          * List all projects accessible to user. Transparently follows pagination
          * cursors and returns the full flat array.
+         * @returns {Promise<ProjectListEntry[]>}
          */
-        list: () => Promise<any[]>;
+        list: () => Promise<ProjectListEntry[]>;
         /**
          * Fetch a single page of projects.
          * @param {object} [opts]
          * @param {number} [opts.limit] - Page size (1..1000; server default 100)
          * @param {string} [opts.cursor] - Opaque cursor from a previous page
-         * @returns {Promise<{entries: Array, nextCursor: (string|null)}>}
+         * @returns {Promise<Page<ProjectListEntry>>}
          */
         listPage: ({ limit, cursor }?: {
             limit?: number;
             cursor?: string;
-        }) => Promise<{
-            entries: any[];
-            nextCursor: (string | null);
-        }>;
+        }) => Promise<Page<ProjectListEntry>>;
         /**
          * Async-iterate projects page by page; yields each page's entries array.
          * @param {object} [opts]
          * @param {number} [opts.pageSize] - Per-request page size
-         * @returns {AsyncGenerator<Array>}
+         * @returns {AsyncGenerator<ProjectListEntry[]>}
          */
         iterPages: ({ pageSize }?: {
             pageSize?: number;
-        }) => AsyncGenerator<any[]>;
+        }) => AsyncGenerator<ProjectListEntry[]>;
         /**
          * Create a new project. Note: this also registers the user as a maintainer.
          * @param {string} name - The name
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @returns {Promise<Created>}
          */
         create: (name: string, auditMessage?: string, { id }?: {
             id?: string;
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Set a configuration value in an editor namespace.
          * @param {string} id - The record's ID
@@ -2616,50 +3285,59 @@ export class PlaidClient {
          * @param {any} configValue - Configuration value to set
          * @param {string} [auditMessage] - Audit message for this write
          * @param {{expected?: any}} [options] - `expected`: the value read for this key (null or undefined when it
-         *   was absent). The write is then refused with a 409 when the stored value differs.
+         *   was absent). The write is then refused with a 409 when the stored value differs. A value the key
+         *   already holds is not written and leaves no audit row, so the value read, expecting it, states in a
+         *   batch that the key is unchanged.
+         * @returns {Promise<void>}
          */
         setConfig: (id: string, namespace: string, configKey: string, configValue: any, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * Remove a configuration value.
          * @param {string} id - The record's ID
          * @param {string} namespace - The config namespace
          * @param {string} configKey - The config key
          * @param {string} [auditMessage] - Audit message for this write
-         * @param {{expected?: any}} [options] - `expected`, as on setConfig.
+         * @param {{expected?: any}} [options] - `expected`, as on setConfig. A key that is absent is not
+         *   written, so expecting null states in a batch that it is still absent.
+         * @returns {Promise<void>}
          */
         deleteConfig: (id: string, namespace: string, configKey: string, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * Set a user's access level to read and write for this project.
          * @param {string} id - The resource ID
          * @param {string} userId - The user ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        addWriter: (id: string, userId: string, auditMessage?: string) => Promise<any>;
+        addWriter: (id: string, userId: string, auditMessage?: string) => Promise<void>;
         /**
          * Remove a user's writer privileges for this project.
          * @param {string} id - The resource ID
          * @param {string} userId - The user ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        removeWriter: (id: string, userId: string, auditMessage?: string) => Promise<any>;
+        removeWriter: (id: string, userId: string, auditMessage?: string) => Promise<void>;
         /**
          * Set a user's access level to read-only for this project.
          * @param {string} id - The resource ID
          * @param {string} userId - The user ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        addReader: (id: string, userId: string, auditMessage?: string) => Promise<any>;
+        addReader: (id: string, userId: string, auditMessage?: string) => Promise<void>;
         /**
          * Remove a user's reader privileges for this project.
          * @param {string} id - The resource ID
          * @param {string} userId - The user ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        removeReader: (id: string, userId: string, auditMessage?: string) => Promise<any>;
+        removeReader: (id: string, userId: string, auditMessage?: string) => Promise<void>;
     };
     textLayers: {
         /**
@@ -2669,35 +3347,40 @@ export class PlaidClient {
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @returns {Promise<Created>}
          */
         create: (projectId: string, name: string, auditMessage?: string, { id }?: {
             id?: string;
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Get a layer by ID.
          * @param {string} layerId - The layer ID
+         * @returns {Promise<LayerRecords[K]>}
          */
-        get: (layerId: string) => Promise<any>;
+        get: (layerId: string) => Promise<TextLayer>;
         /**
          * Delete a layer.
          * @param {string} layerId - The layer ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (layerId: string, auditMessage?: string) => Promise<any>;
+        delete: (layerId: string, auditMessage?: string) => Promise<void>;
         /**
          * Rename a layer.
          * @param {string} layerId - The layer ID
          * @param {string} name - The new name
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<LayerRecords[K]>}
          */
-        update: (layerId: string, name: string, auditMessage?: string) => Promise<any>;
+        update: (layerId: string, name: string, auditMessage?: string) => Promise<TextLayer>;
         /**
          * Move a layer one place in its display order.
          * @param {string} layerId - The layer ID
          * @param {string} direction - The direction ("up" or "down")
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<any>;
+        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<void>;
         /**
          * Set a configuration value in an editor namespace.
          * @param {string} id - The record's ID
@@ -2706,22 +3389,27 @@ export class PlaidClient {
          * @param {any} configValue - Configuration value to set
          * @param {string} [auditMessage] - Audit message for this write
          * @param {{expected?: any}} [options] - `expected`: the value read for this key (null or undefined when it
-         *   was absent). The write is then refused with a 409 when the stored value differs.
+         *   was absent). The write is then refused with a 409 when the stored value differs. A value the key
+         *   already holds is not written and leaves no audit row, so the value read, expecting it, states in a
+         *   batch that the key is unchanged.
+         * @returns {Promise<void>}
          */
         setConfig: (id: string, namespace: string, configKey: string, configValue: any, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * Remove a configuration value.
          * @param {string} id - The record's ID
          * @param {string} namespace - The config namespace
          * @param {string} configKey - The config key
          * @param {string} [auditMessage] - Audit message for this write
-         * @param {{expected?: any}} [options] - `expected`, as on setConfig.
+         * @param {{expected?: any}} [options] - `expected`, as on setConfig. A key that is absent is not
+         *   written, so expecting null states in a batch that it is still absent.
+         * @returns {Promise<void>}
          */
         deleteConfig: (id: string, namespace: string, configKey: string, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
     };
     vocabItems: {
         /**
@@ -2732,10 +3420,11 @@ export class PlaidClient {
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @returns {Promise<Created>}
          */
         create: (vocabLayerId: string, form: string, metadata?: any, auditMessage?: string, { id }?: {
             id?: string;
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Create multiple vocab items in a single operation. Entries may target
          * different vocab layers; the user must have write access to each.
@@ -2778,8 +3467,9 @@ export class PlaidClient {
         /**
          * Get a vocab item by ID
          * @param {string} id - The resource ID
+         * @returns {Promise<VocabItem>}
          */
-        get: (id: string) => Promise<any>;
+        get: (id: string) => Promise<VocabItem>;
         /**
          * Delete a vocab item, and every link to it. Every document holding one
          * of those links has its version bumped, and a strict-mode client picks
@@ -2789,10 +3479,11 @@ export class PlaidClient {
          * @param {{expectedLinkCount?: number}} [options] - `expectedLinkCount`: the
          *   number of links the caller showed. The delete is refused with a 409 when
          *   the entry has any other number of links by then.
+         * @returns {Promise<void>}
          */
         delete: (id: string, auditMessage?: string, { expectedLinkCount }?: {
             expectedLinkCount?: number;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * Merge entries into this one, in one operation. Every link to a loser
          * moves to the survivor (keeping its id and metadata), except a link on
@@ -2824,30 +3515,49 @@ export class PlaidClient {
          * @param {string} id - The resource ID
          * @param {string} form - The vocab item form
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<VocabItem>}
          */
-        update: (id: string, form: string, auditMessage?: string) => Promise<any>;
+        update: (id: string, form: string, auditMessage?: string) => Promise<VocabItem>;
         /**
          * Replace all metadata of an entity. Keys left out of the new map are removed.
          * @param {string} id - The entity's ID
          * @param {object} body - The new metadata map
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<any>;
+        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<VocabItem>;
         /**
          * Remove all metadata from an entity.
          * @param {string} id - The entity's ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        deleteMetadata: (id: string, auditMessage?: string) => Promise<any>;
+        deleteMetadata: (id: string, auditMessage?: string) => Promise<VocabItem>;
         /**
          * Edit an entity's metadata with a list of ops applied in order, in one operation. `{op: 'set', path, value}` writes value at path, creating missing objects along it; `{op: 'delete', path}` removes the key at path (a no-op when absent). A path is a non-empty array of keys, the first a top-level key. A path through a non-object is refused (400). See metadataOps and applyMetadataOps.
          * @param {string} id - The entity's ID
          * @param {MetadataOp[]} body - The metadata ops
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<any>;
+        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<VocabItem>;
     };
     relationLayers: {
+        /**
+         * The stored values of this layer that a value-set rule would refuse,
+         * before it is declared: exactly what a declaration of it would meet,
+         * with the rule's exemptions (an unconfirmed machine value, a value an
+         * import, a document copy or a restore set). Writes nothing, and a
+         * reader may ask.
+         * @param {string} layerId - The layer ID
+         * @param {ValueSetRule} rule - The list as a value-set declaration takes it
+         * @param {{limit?: number}} [options] - `limit`: how many values to list, the most frequent first
+         *   (default 20, at most 100)
+         * @returns {Promise<RefusedValues>}
+         */
+        refusedValues: (layerId: string, rule: ValueSetRule, options?: {
+            limit?: number;
+        }) => Promise<RefusedValues>;
         /**
          * Declare an app namespace's constraints on this layer, replacing that
          * namespace's list. Refused with 422 and the violations when the layer's
@@ -2872,18 +3582,22 @@ export class PlaidClient {
          * @param {string} namespace - The declaring app's namespace
          * @param {string} [auditMessage] - Audit message for this write
          * @param {{expected?: Array<object>|null}} [options] - `expected`, as on setConstraints.
+         * @returns {Promise<void>}
          */
         deleteConstraints: (layerId: string, namespace: string, auditMessage?: string, options?: {
             expected?: Array<object> | null;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * The violations the given constraints would meet in this layer's stored
          * data. Writes nothing.
          * @param {string} layerId - The layer ID
          * @param {LayerConstraint[]} constraints - The list to check
+         * @param {{limit?: number}} [options] - `limit`: how many violations to list (default 100)
          * @returns {Promise<{violations: ConstraintViolation[], violationCount: number}>}
          */
-        checkConstraints: (layerId: string, constraints: LayerConstraint[]) => Promise<{
+        checkConstraints: (layerId: string, constraints: LayerConstraint[], options?: {
+            limit?: number;
+        }) => Promise<{
             violations: ConstraintViolation[];
             violationCount: number;
         }>;
@@ -2919,22 +3633,27 @@ export class PlaidClient {
          * @param {any} configValue - Configuration value to set
          * @param {string} [auditMessage] - Audit message for this write
          * @param {{expected?: any}} [options] - `expected`: the value read for this key (null or undefined when it
-         *   was absent). The write is then refused with a 409 when the stored value differs.
+         *   was absent). The write is then refused with a 409 when the stored value differs. A value the key
+         *   already holds is not written and leaves no audit row, so the value read, expecting it, states in a
+         *   batch that the key is unchanged.
+         * @returns {Promise<void>}
          */
         setConfig: (id: string, namespace: string, configKey: string, configValue: any, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * Remove a configuration value.
          * @param {string} id - The record's ID
          * @param {string} namespace - The config namespace
          * @param {string} configKey - The config key
          * @param {string} [auditMessage] - Audit message for this write
-         * @param {{expected?: any}} [options] - `expected`, as on setConfig.
+         * @param {{expected?: any}} [options] - `expected`, as on setConfig. A key that is absent is not
+         *   written, so expecting null states in a batch that it is still absent.
+         * @returns {Promise<void>}
          */
         deleteConfig: (id: string, namespace: string, configKey: string, auditMessage?: string, options?: {
             expected?: any;
-        }) => Promise<any>;
+        }) => Promise<void>;
         /**
          * Create a new relation layer.
          * @param {string} spanLayerId - The span layer ID
@@ -2942,35 +3661,40 @@ export class PlaidClient {
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @returns {Promise<Created>}
          */
         create: (spanLayerId: string, name: string, auditMessage?: string, { id }?: {
             id?: string;
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Get a layer by ID.
          * @param {string} layerId - The layer ID
+         * @returns {Promise<LayerRecords[K]>}
          */
-        get: (layerId: string) => Promise<any>;
+        get: (layerId: string) => Promise<RelationLayer>;
         /**
          * Delete a layer.
          * @param {string} layerId - The layer ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (layerId: string, auditMessage?: string) => Promise<any>;
+        delete: (layerId: string, auditMessage?: string) => Promise<void>;
         /**
          * Rename a layer.
          * @param {string} layerId - The layer ID
          * @param {string} name - The new name
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<LayerRecords[K]>}
          */
-        update: (layerId: string, name: string, auditMessage?: string) => Promise<any>;
+        update: (layerId: string, name: string, auditMessage?: string) => Promise<RelationLayer>;
         /**
          * Move a layer one place in its display order.
          * @param {string} layerId - The layer ID
          * @param {string} direction - The direction ("up" or "down")
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<any>;
+        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<void>;
     };
     tokens: {
         /**
@@ -2978,21 +3702,24 @@ export class PlaidClient {
          * @param {string} id - The entity's ID
          * @param {object} body - The new metadata map
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<any>;
+        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<Token>;
         /**
          * Remove all metadata from an entity.
          * @param {string} id - The entity's ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        deleteMetadata: (id: string, auditMessage?: string) => Promise<any>;
+        deleteMetadata: (id: string, auditMessage?: string) => Promise<Token>;
         /**
          * Edit an entity's metadata with a list of ops applied in order, in one operation. `{op: 'set', path, value}` writes value at path, creating missing objects along it; `{op: 'delete', path}` removes the key at path (a no-op when absent). A path is a non-empty array of keys, the first a top-level key. A path through a non-object is refused (400). See metadataOps and applyMetadataOps.
          * @param {string} id - The entity's ID
          * @param {MetadataOp[]} body - The metadata ops
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<MetadataRecords[K]>}
          */
-        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<any>;
+        patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<Token>;
         /**
          * Create a new token in a token layer. Tokens define text substrings
          * using begin and end offsets. Tokens may be zero-width and may overlap.
@@ -3013,22 +3740,25 @@ export class PlaidClient {
          * @param {string} [auditMessage] - Audit message for this write
          * @param {object} [opts]
          * @param {string} [opts.id] - The new entity's id, minted by the caller (see uuidv7)
+         * @returns {Promise<Created>}
          */
         create: (tokenLayerId: string, text: string, begin: number, end: number, precedence?: number, metadata?: any, auditMessage?: string, { id }?: {
             id?: string;
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Get a token.
          * @param {string} tokenId - The token ID
+         * @returns {Promise<Token>}
          */
-        get: (tokenId: string) => Promise<any>;
+        get: (tokenId: string) => Promise<Token>;
         /**
          * Delete a token and remove it from any spans. If this causes a span to
          * have no remaining tokens, the span will also be deleted.
          * @param {string} tokenId - The token ID
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (tokenId: string, auditMessage?: string) => Promise<any>;
+        delete: (tokenId: string, auditMessage?: string) => Promise<void>;
         /**
          * Update a token.
          * @param {string} tokenId - The token ID
@@ -3039,8 +3769,9 @@ export class PlaidClient {
          *   CLEAR it (revert to no explicit ordering). bodyOf keeps null but
          *   drops undefined, so the three cases map correctly to the server.
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<Token>}
          */
-        update: (tokenId: string, begin?: number, end?: number, precedence?: number | null, auditMessage?: string) => Promise<any>;
+        update: (tokenId: string, begin?: number, end?: number, precedence?: number | null, auditMessage?: string) => Promise<Token>;
         /**
          * Create multiple tokens in a single operation.
          * @param {Array} body - The request body
@@ -3067,8 +3798,9 @@ export class PlaidClient {
             count: number;
         }>;
         /**
-         * Split a token at a Unicode code-point offset. The original token becomes the
-         * left half (keeps its ID, spans, vocab-links); the new right token's ID is returned.
+         * Split a token at a Unicode code-point offset. A new token is made for one
+         * half and its ID is returned. The original token keeps its ID, spans and
+         * vocab-links on the left half, or on the right half with `keep: "right"`.
          * @param {string} tokenId - The token ID
          * @param {number} position - Code-point offset to split at (strictly between begin and end)
          * @param {string} [auditMessage] - Audit message for this write
@@ -3079,11 +3811,12 @@ export class PlaidClient {
          *   half. A relation layer whose relations must stay inside one token
          *   of this layer declares a same-ancestor constraint, and the server deletes
          *   the relations the split leaves crossing in the same transaction.
+         * @returns {Promise<Created>}
          */
         split: (tokenId: string, position: number, auditMessage?: string, { id, keep }?: {
             id?: string;
             keep?: "left" | "right";
-        }) => Promise<any>;
+        }) => Promise<Created>;
         /**
          * Merge two tokens. The left token (smaller begin) survives with the combined
          * extent; the right is deleted and its spans/vocab-links are reparented to the left.
@@ -3092,8 +3825,9 @@ export class PlaidClient {
          * @param {string} tokenId - The anchor token ID
          * @param {string} otherTokenId - The other token to merge in
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<Token>}
          */
-        merge: (tokenId: string, otherTokenId: string, auditMessage?: string) => Promise<any>;
+        merge: (tokenId: string, otherTokenId: string, auditMessage?: string) => Promise<Token>;
         /**
          * Shift a token's boundary. On partitioning layers the adjacent token is
          * auto-adjusted to preserve the partition; on non-overlapping layers a shift that
@@ -3102,8 +3836,9 @@ export class PlaidClient {
          * @param {number} [begin] - New start offset, inclusive (Unicode code points)
          * @param {number} [end] - New end offset, exclusive (Unicode code points)
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<Token>}
          */
-        shift: (tokenId: string, begin?: number, end?: number, auditMessage?: string) => Promise<any>;
+        shift: (tokenId: string, begin?: number, end?: number, auditMessage?: string) => Promise<Token>;
     };
     messages: {
         /**
@@ -3129,9 +3864,12 @@ export class PlaidClient {
          * queues, so a message queued after the writes goes out after them.
          * @param {string} projectId - The UUID of the project to send to
          * @param {any} data - The message data to send
-         * @returns {Promise<any>} Response from the send operation
+         * @returns {Promise<{success: boolean, message: string}>}
          */
-        sendMessage: (projectId: string, data: any) => Promise<any>;
+        sendMessage: (projectId: string, data: any) => Promise<{
+            success: boolean;
+            message: string;
+        }>;
         /**
          * Discover the services seen on a project (synchronous GET). Currently
          * connected services carry `online: true`; previously-seen offline ones
@@ -3246,24 +3984,26 @@ export class PlaidClient {
      *
      * @param {Object} body - The query AST ({find, where, scope?, limit?, orderBy?,
      *   return?, bindings?}).
-     * @returns {Promise<Object>} For 'ids'/'entities': {columns, results, count, truncated}.
+     * @returns {Promise<QueryResult>} For 'ids'/'entities': {columns, results, count, truncated}.
      *   For 'count': {return: 'count', count, truncated}, where `truncated` says
      *   the count stopped at the server's cap. Entity cells are full entity
      *   objects (same shape as the GET endpoints).
      */
-    query: (body: any) => Promise<any>;
+    query: (body: any) => Promise<QueryResult>;
     operationGroups: {
         /**
          * Get a logical-operation group (its label + creator).
          * @param {string} id - The group id
+         * @returns {Promise<OperationGroup>}
          */
-        get: (id: string) => Promise<any>;
+        get: (id: string) => Promise<OperationGroup>;
         /**
          * Relabel a logical-operation group after the fact. Owner or admin only.
          * @param {string} id - The group id
          * @param {string|null} message - The new label
+         * @returns {Promise<OperationGroup>}
          */
-        update: (id: string, message: string | null) => Promise<any>;
+        update: (id: string, message: string | null) => Promise<OperationGroup>;
     };
     comments: {
         /**
@@ -3305,8 +4045,9 @@ export class PlaidClient {
          * Delete a comment. The author may delete their own; a project
          * maintainer (or admin) may delete any.
          * @param {string} id - The comment id
+         * @returns {Promise<void>}
          */
-        delete: (id: string) => Promise<any>;
+        delete: (id: string) => Promise<void>;
         /**
          * List comments in a project, oldest first. Transparently follows
          * pagination cursors and returns the full flat array.
@@ -3589,8 +4330,9 @@ export class PlaidClient {
          * Delete a guideline.
          * @param {string} id - The guideline id
          * @param {string} [auditMessage] - Audit message for this write
+         * @returns {Promise<void>}
          */
-        delete: (id: string, auditMessage?: string) => Promise<any>;
+        delete: (id: string, auditMessage?: string) => Promise<void>;
         /**
          * List a project's guidelines, by title. Transparently follows
          * pagination cursors and returns the full flat array.
@@ -3764,15 +4506,23 @@ export class PlaidClient {
      * parents created earlier in the same batch, and any op's failure rolls the
      * whole batch back. A batch is not nestable. Prefer `batched()`, which
      * submits or aborts for you.
+     *
+     * `timeout` (ms, or null for none) is how long each of this batch's
+     * requests may wait for its answer, in place of the client's
+     * `batchTimeout`, for this batch alone.
+     * @param {{timeout?: number | null}} [options]
      * @returns {PlaidBatch} the batch view
      */
-    batch(): PlaidBatch;
+    batch({ timeout }?: {
+        timeout?: number | null;
+    }): PlaidBatch;
     /**
      * POST one batch request (at most MAX_BATCH_OPS operations). Resolves to
      * one `{ status, headers, body }` per operation, with only the body
      * recased: the headers keep the server's spelling. `key` is the request's
      * Idempotency-Key: a batch whose answer is lost (no response, 502, 504) is
      * sent again under it, and answered from the first send if that landed.
+     * `timeout` is this request's, in place of `batchTimeout` when given.
      * @private
      */
     private _postBatch;
@@ -3789,11 +4539,15 @@ export class PlaidClient {
      *   });
      *
      * A write made on `client` inside `fn` is not part of the batch: it goes
-     * over the wire at once, as it would anywhere else. See `batch()`.
+     * over the wire at once, as it would anywhere else. See `batch()`, which
+     * also says what `timeout` does.
      * @param {(batch: PlaidBatch) => (void | Promise<void>)} fn
+     * @param {{timeout?: number | null}} [options]
      * @returns {Promise<any[]>}
      */
-    batched(fn: (batch: PlaidBatch) => (void | Promise<void>)): Promise<any[]>;
+    batched(fn: (batch: PlaidBatch) => (void | Promise<void>), { timeout }?: {
+        timeout?: number | null;
+    }): Promise<any[]>;
 }
 /**
  * The server's cap on operations per batch request (plaid.rest-api.v1.batch).
@@ -3805,7 +4559,7 @@ export { cpLength, cpSlice, cpSlicer, utf16ToCp, cpIndexOf, composeText } from "
 export { composeTextEdits, gapsToOps, applyTextOps } from "./textEdits.js";
 export { PLAID_NAMESPACE, ROLE_KEY, PRESERVE_ON_SPLIT_KEY, SPLIT_ON_SPACE_KEY, ROLES, readRole, findByRole } from "./roles.js";
 export { TASKS, servesTask, filterServicesByTask, getParamSchema, getServiceSummary, buildDefaultValues, coerceParamValues } from "./serviceSchema.js";
-export { ServiceCancelled, createCancelScope } from "./services.js";
+export { ServiceCancelled, createCancelScope, UNKNOWN_OUTCOME, UNREACHABLE } from "./services.js";
 export { REQUESTED_BY, makeRequester, requesterOf } from "./requester.js";
 export { DocumentLock, DocumentLockLost } from "./documentLock.js";
 export { PROV, PROV_STATES, PROVENANCE_KEYS, stampInferred, confirmedInferred, stampContributed, provState, provOrigin, isMachine, isProtected, needsReview, contributeOnEdit, serviceSource, REVIEW_KEY, readReview, projectRole, isReviewed, withReviewedUser, writerPolicy } from "./provenance.js";