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

package/src/apiProject.d.ts

@@ -0,0 +1,761 @@
+/**
+ * @typedef {import("./types.js").TextEditOp} TextEditOp
+ * @typedef {import("./types.js").TextGap} TextGap
+ * @typedef {import("./types.js").MetadataOp} MetadataOp
+ * @typedef {import("./types.js").LayerConstraint} LayerConstraint
+ * @typedef {import("./types.js").ConstraintWriteOptions} ConstraintWriteOptions
+ * @typedef {import("./types.js").ConstraintViolation} ConstraintViolation
+ * @typedef {import("./types.js").Requester} Requester
+ * @typedef {import("./types.js").BatchRef} BatchRef
+ * @typedef {import("./types.js").ServiceParam} ServiceParam
+ * @typedef {import("./types.js").ServiceInfo} ServiceInfo
+ * @typedef {import("./types.js").DiscoveredService} DiscoveredService
+ * @typedef {import("./types.js").ResponseHelper} ResponseHelper
+ * @typedef {import("./types.js").ServiceRegistration} ServiceRegistration
+ * @typedef {import("./types.js").ServiceStatusEvent} ServiceStatusEvent
+ * @typedef {import("./types.js").OperationGroupsBundle} OperationGroupsBundle
+ * @typedef {import("./types.js").PlaidClientOptions} PlaidClientOptions
+ * @typedef {import("./types.js").OperationKind} OperationKind
+ * @typedef {import("./types.js").KeySeed} KeySeed
+ * @typedef {import("./types.js").PlaidBatch} PlaidBatch
+ * @typedef {import("./types.js").AuditPageOptions} AuditPageOptions
+ * @typedef {import("./types.js").VocabItemRestoreSummary} VocabItemRestoreSummary
+ * @typedef {import("./types.js").UserDataEntry} UserDataEntry
+ * @typedef {import("./types.js").AdminUserDataEntry} AdminUserDataEntry
+ * @typedef {import("./types.js").ActivityTallyRow} ActivityTallyRow
+ * @typedef {import("./types.js").ConstraintRepair} ConstraintRepair
+ * @typedef {import("./types.js").ValueSetRule} ValueSetRule
+ * @typedef {import("./types.js").RefusedValues} RefusedValues
+ * @typedef {import("./types.js").CommentableType} CommentableType
+ * @typedef {import("./types.js").Comment} Comment
+ * @typedef {import("./types.js").Guideline} Guideline
+ * @typedef {import("./types.js").ClientEventType} ClientEventType
+ * @typedef {import("./types.js").ClientEvent} ClientEvent
+ * @typedef {import("./types.js").Invite} Invite
+ * @typedef {import("./types.js").ServerLimits} ServerLimits
+ * @typedef {import("./types.js").ServerHealth} ServerHealth
+ * @typedef {import("./types.js").RateLimitBucket} RateLimitBucket
+ * @typedef {import("./types.js").RateLimitSnapshot} RateLimitSnapshot
+ * @typedef {import("./types.js").BackupStatus} BackupStatus
+ * @typedef {import("./types.js").ServerReport} ServerReport
+ * @typedef {import("./types.js").LiveLog} LiveLog
+ * @typedef {import("./types.js").SSEConnection} SSEConnection
+ * @typedef {import("./types.js").SSEStats} SSEStats
+ * @typedef {import("./types.js").AtomicValue} AtomicValue
+ * @typedef {import("./types.js").Created} Created
+ * @typedef {import("./types.js").Project} Project
+ * @typedef {import("./types.js").ProjectTextLayer} ProjectTextLayer
+ * @typedef {import("./types.js").ProjectTokenLayer} ProjectTokenLayer
+ * @typedef {import("./types.js").ProjectSpanLayer} ProjectSpanLayer
+ * @typedef {import("./types.js").ProjectRelationLayer} ProjectRelationLayer
+ * @typedef {import("./types.js").ProjectVocab} ProjectVocab
+ * @typedef {import("./types.js").PlaidDocument} PlaidDocument
+ * @typedef {import("./types.js").DocumentTextLayer} DocumentTextLayer
+ * @typedef {import("./types.js").DocumentTokenLayer} DocumentTokenLayer
+ * @typedef {import("./types.js").DocumentSpanLayer} DocumentSpanLayer
+ * @typedef {import("./types.js").PlaidText} PlaidText
+ * @typedef {import("./types.js").TextReshape} TextReshape
+ * @typedef {import("./types.js").Token} Token
+ * @typedef {import("./types.js").Span} Span
+ * @typedef {import("./types.js").Relation} Relation
+ * @typedef {import("./types.js").VocabItem} VocabItem
+ * @typedef {import("./types.js").VocabLink} VocabLink
+ * @typedef {import("./types.js").VocabLayer} VocabLayer
+ * @typedef {import("./types.js").TextLayer} TextLayer
+ * @typedef {import("./types.js").TokenLayer} TokenLayer
+ * @typedef {import("./types.js").SpanLayer} SpanLayer
+ * @typedef {import("./types.js").RelationLayer} RelationLayer
+ * @typedef {import("./types.js").MetadataRecords} MetadataRecords
+ * @typedef {import("./types.js").LayerRecords} LayerRecords
+ * @typedef {import("./types.js").User} User
+ * @typedef {import("./types.js").ProjectListEntry} ProjectListEntry
+ * @typedef {import("./types.js").DocumentListEntry} DocumentListEntry
+ * @typedef {import("./types.js").ApiToken} ApiToken
+ * @typedef {import("./types.js").AuditUser} AuditUser
+ * @typedef {import("./types.js").AuditTarget} AuditTarget
+ * @typedef {import("./types.js").AuditOp} AuditOp
+ * @typedef {import("./types.js").AuditEntry} AuditEntry
+ * @typedef {import("./types.js").LockGrant} LockGrant
+ * @typedef {import("./types.js").DocumentRestoreSummary} DocumentRestoreSummary
+ * @typedef {import("./types.js").RestoreCounts} RestoreCounts
+ * @typedef {import("./types.js").OperationGroup} OperationGroup
+ * @typedef {import("./types.js").QueryResult} QueryResult
+ */
+/**
+ * @template [T=any]
+ * @typedef {import("./types.js").Page<T>} Page
+ */
+/** @param {import("./client.js").PlaidClient} client */
+export function projectsApi(client: import("./client.js").PlaidClient): {
+    audit: (id: string, startTime?: string, endTime?: string, opTypes?: string[] | string, kinds?: string[] | string) => Promise<import("./families.js").AuditEntry[]>;
+    auditPage: (id: string, { startTime, endTime, opTypes, kinds, order, limit, cursor, opsLimit, entryId }?: {
+        startTime?: string;
+        endTime?: string;
+        opTypes?: string[] | string;
+        kinds?: import("./families.js").OperationKind[] | string;
+        order?: "asc" | "desc";
+        limit?: number;
+        cursor?: string;
+        opsLimit?: number;
+        entryId?: string;
+    }) => Promise<import("./families.js").Page<import("./families.js").AuditEntry>>;
+    setConfig: (id: string, namespace: string, configKey: string, configValue: any, auditMessage?: string, options?: {
+        expected?: any;
+    }) => Promise<void>;
+    deleteConfig: (id: string, namespace: string, configKey: string, auditMessage?: string, options?: {
+        expected?: any;
+    }) => 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<Project>;
+    /**
+     * List all projects accessible to user. Transparently follows pagination
+     * cursors and returns the full flat array.
+     * @returns {Promise<ProjectListEntry[]>}
+     */
+    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<Page<ProjectListEntry>>}
+     */
+    listPage: ({ limit, cursor }?: {
+        limit?: number;
+        cursor?: string;
+    }) => 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<ProjectListEntry[]>}
+     */
+    iterPages: ({ pageSize }?: {
+        pageSize?: number;
+    }) => AsyncGenerator<ProjectListEntry[]>;
+    /**
+     * List all documents in a project. Transparently follows pagination
+     * cursors and returns the full flat array.
+     *
+     * 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<DocumentListEntry[]>;
+    /**
+     * Fetch a single page of a project's documents.
+     *
+     * 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
+     * @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<Page<DocumentListEntry>>}
+     */
+    listDocumentsPage: (id: string, { limit, cursor }?: {
+        limit?: number;
+        cursor?: string;
+    }) => Promise<Page<DocumentListEntry>>;
+    /**
+     * Async-iterate a project's documents page by page; yields each page's
+     * entries array.
+     *
+     * 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
+     * @param {object} [opts]
+     * @param {number} [opts.pageSize] - Per-request page size
+     * @returns {AsyncGenerator<DocumentListEntry[]>}
+     */
+    iterDocuments: (id: string, { pageSize }?: {
+        pageSize?: number;
+    }) => AsyncGenerator<DocumentListEntry[]>;
+    /**
+     * 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<Created>;
+    /**
+     * 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<Project>;
+    /**
+     * Delete a project and everything in it. This is irrecoverable. The
+     * project is gone when this returns, and what it holds is removed on
+     * the server afterwards.
+     * @param {string} id - The resource ID
+     * @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<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<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<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<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<void>;
+    /**
+     * Assign a user as a maintainer 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>}
+     */
+    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<void>;
+    /**
+     * When the calling user last wrote to each document in a project, as a
+     * `{documentId: timestamp}` map. Documents they have never written to
+     * are absent. One request covers a whole document list.
+     *
+     * The response is NOT key-transformed: its keys are document ids, and
+     * camelCasing would mangle the hyphens in a UUID.
+     * @param {string} projectId - The project ID
+     * @returns {Promise<Object<string, string>>}
+     */
+    myLastEdits: (projectId: string) => Promise<{
+        [x: string]: string;
+    }>;
+    /**
+     * Link a vocabulary to 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>}
+     */
+    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<void>;
+};
+/** @param {import("./client.js").PlaidClient} client */
+export function guidelinesApi(client: import("./client.js").PlaidClient): {
+    /**
+     * Read one guideline, Markdown body included.
+     * @param {string} id - The guideline id
+     * @returns {Promise<Guideline>}
+     */
+    get: (id: string) => Promise<Guideline>;
+    /**
+     * List a project's guidelines, by title. Transparently follows
+     * pagination cursors and returns the full flat array.
+     *
+     * Without `includeBodies` each entry carries `bodyChars`, the length of
+     * its body, so a caller can budget before fetching any. Pinned
+     * guidelines are NOT sorted first: `pinned` is on every entry and
+     * grouping is the caller's.
+     * @param {string} projectId - The project to read
+     * @param {object} [opts]
+     * @param {boolean} [opts.includeBodies] - Return each body instead of its length
+     * @returns {Promise<Guideline[]>}
+     */
+    list: (projectId: string, { includeBodies }?: {
+        includeBodies?: boolean;
+    }) => Promise<Guideline[]>;
+    /**
+     * Fetch a single page of a project's guidelines.
+     * @param {string} projectId - The project to read
+     * @param {object} [opts]
+     * @param {number} [opts.limit] - Page size (1..1000; server default 100)
+     * @param {string} [opts.cursor] - Opaque cursor from a previous page
+     * @param {boolean} [opts.includeBodies] - Return each body instead of its length
+     * @returns {Promise<Page<Guideline>>}
+     */
+    listPage: (projectId: string, { limit, cursor, includeBodies }?: {
+        limit?: number;
+        cursor?: string;
+        includeBodies?: boolean;
+    }) => Promise<Page<Guideline>>;
+    /**
+     * Async-iterate a project's guidelines page by page; yields each page's entries array.
+     * @param {string} projectId - The project to read
+     * @param {object} [opts]
+     * @param {number} [opts.pageSize] - Per-request page size
+     * @param {boolean} [opts.includeBodies] - Return each body instead of its length
+     * @returns {AsyncGenerator<Guideline[]>}
+     */
+    iterPages: (projectId: string, { pageSize, includeBodies }?: {
+        pageSize?: number;
+        includeBodies?: boolean;
+    }) => AsyncGenerator<Guideline[]>;
+    /**
+     * Create a guideline in a project. `title` is the handle an assistant
+     * asks for one by, and the only thing a person has to keep current. It is
+     * NOT required to be unique, so a title already in use is written like
+     * any other: warn about it, do not refuse it. A `pinned` guideline is one
+     * the assistant is given in full on every turn.
+     * @param {string} projectId - The project the guideline belongs to
+     * @param {string} title - The handle an assistant asks for one by (1..100 characters)
+     * @param {object} [opts]
+     * @param {string} [opts.body] - The Markdown text (up to 20000 characters; may be empty)
+     * @param {boolean} [opts.pinned] - Send this one to the assistant in full on every turn
+     * @param {string} [opts.id] - The new guideline's id, minted by the caller (see uuidv7)
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<{id: string}>}
+     */
+    create: (projectId: string, title: string, { body, pinned, id }?: {
+        body?: string;
+        pinned?: boolean;
+        id?: string;
+    }, auditMessage?: string) => Promise<{
+        id: string;
+    }>;
+    /**
+     * Update a guideline. Every field is optional and an omitted one is
+     * left alone, so an edit to the body need not restate the title.
+     *
+     * Pass `expectedUpdatedAt` (the `updatedAt` you last read) when a person
+     * has been editing prose: the write then fails with 409 rather than
+     * overwriting somebody who saved in between. Leave it off for a pin
+     * toggle or a script, which have nothing of anyone's to lose.
+     * @param {string} id - The guideline id
+     * @param {object} [changes]
+     * @param {string} [changes.title] - The new handle
+     * @param {string} [changes.body] - The new Markdown text
+     * @param {boolean} [changes.pinned] - Whether the assistant always gets it in full
+     * @param {string} [changes.expectedUpdatedAt] - Write only if this is still the stored updatedAt
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<Guideline>}
+     */
+    update: (id: string, { title, body, pinned, expectedUpdatedAt }?: {
+        title?: string;
+        body?: string;
+        pinned?: boolean;
+        expectedUpdatedAt?: string;
+    }, auditMessage?: string) => Promise<Guideline>;
+    /**
+     * 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<void>;
+};
+/** @param {import("./client.js").PlaidClient} client */
+export function commentsApi(client: import("./client.js").PlaidClient): {
+    /**
+     * Read one comment.
+     * @param {string} id - The comment id
+     * @returns {Promise<Comment>}
+     */
+    get: (id: string) => Promise<Comment>;
+    /**
+     * List comments in a project, oldest first. Transparently follows
+     * pagination cursors and returns the full flat array.
+     * @param {string} projectId - The project to read
+     * @param {object} [filters] - Narrow the scope
+     * @param {string} [filters.documentId] - Every comment anywhere in one document
+     * @param {string} [filters.entityType] - With entityId, one entity's thread
+     * @param {string} [filters.entityId] - With entityType, one entity's thread
+     * @returns {Promise<Comment[]>}
+     */
+    list: (projectId: string, { documentId, entityType, entityId }?: {
+        documentId?: string;
+        entityType?: string;
+        entityId?: string;
+    }) => Promise<Comment[]>;
+    /**
+     * Fetch a single page of a project's comments.
+     * @param {string} projectId - The project to read
+     * @param {object} [opts]
+     * @param {number} [opts.limit] - Page size (1..1000; server default 100)
+     * @param {string} [opts.cursor] - Opaque cursor from a previous page
+     * @param {string} [opts.documentId] - Every comment anywhere in one document
+     * @param {string} [opts.entityType] - With entityId, one entity's thread
+     * @param {string} [opts.entityId] - With entityType, one entity's thread
+     * @returns {Promise<Page<Comment>>}
+     */
+    listPage: (projectId: string, { limit, cursor, documentId, entityType, entityId }?: {
+        limit?: number;
+        cursor?: string;
+        documentId?: string;
+        entityType?: string;
+        entityId?: string;
+    }) => Promise<Page<Comment>>;
+    /**
+     * Async-iterate a project's comments page by page; yields each page's entries array.
+     * @param {string} projectId - The project to read
+     * @param {object} [opts]
+     * @param {number} [opts.pageSize] - Per-request page size
+     * @param {string} [opts.documentId] - Every comment anywhere in one document
+     * @param {string} [opts.entityType] - With entityId, one entity's thread
+     * @param {string} [opts.entityId] - With entityType, one entity's thread
+     * @returns {AsyncGenerator<Comment[]>}
+     */
+    iterPages: (projectId: string, { pageSize, documentId, entityType, entityId }?: {
+        pageSize?: number;
+        documentId?: string;
+        entityType?: string;
+        entityId?: string;
+    }) => AsyncGenerator<Comment[]>;
+    /**
+     * List the comments on a vocabulary's entries, oldest first. Requires
+     * read access to the vocabulary. Transparently follows pagination
+     * cursors and returns the full flat array.
+     * @param {string} vocabId - The vocab layer to read
+     * @param {object} [filters]
+     * @param {string} [filters.entityId] - One entry's thread
+     * @returns {Promise<Comment[]>}
+     */
+    listInVocab: (vocabId: string, { entityId }?: {
+        entityId?: string;
+    }) => Promise<Comment[]>;
+    /**
+     * Fetch a single page of a vocabulary's comments.
+     * @param {string} vocabId - The vocab layer to read
+     * @param {object} [opts]
+     * @param {number} [opts.limit] - Page size (1..1000; server default 100)
+     * @param {string} [opts.cursor] - Opaque cursor from a previous page
+     * @param {string} [opts.entityId] - One entry's thread
+     * @returns {Promise<Page<Comment>>}
+     */
+    listInVocabPage: (vocabId: string, { limit, cursor, entityId }?: {
+        limit?: number;
+        cursor?: string;
+        entityId?: string;
+    }) => Promise<Page<Comment>>;
+    /**
+     * Async-iterate a vocabulary's comments page by page, oldest first;
+     * yields each page's entries array.
+     * @param {string} vocabId - The vocab layer to read
+     * @param {object} [opts]
+     * @param {string} [opts.entityId] - One entry's thread
+     * @param {number} [opts.pageSize] - Per-request page size
+     * @returns {AsyncGenerator<Comment[]>}
+     */
+    iterInVocabPages: (vocabId: string, { entityId, pageSize }?: {
+        entityId?: string;
+        pageSize?: number;
+    }) => AsyncGenerator<Comment[]>;
+    /**
+     * Post a comment on an entity. Requires write access to the entity's
+     * project, or to the vocabulary for a vocab-item; the author is the
+     * authenticated caller. Comments are not audited and do not bump the
+     * document version.
+     *
+     * A comment outlives its anchor: deleting the entity does not delete
+     * the comment. `anchorLabel` is the caption shown once that happens
+     * ("Gloss of ktab, sentence 4"), so pass what the comment is about.
+     * @param {CommentableType} entityType - What kind of thing is being commented on
+     * @param {string} entityId - The commented entity's id
+     * @param {string} body - The comment text (1..10000 characters)
+     * @param {object} [opts]
+     * @param {string} [opts.anchorLabel] - What the comment is about, in words (at most 200 characters)
+     * @param {string} [opts.id] - The new comment's id, minted by the caller (see uuidv7)
+     * @returns {Promise<Comment>}
+     */
+    create: (entityType: CommentableType, entityId: string, body: string, { anchorLabel, id }?: {
+        anchorLabel?: string;
+        id?: string;
+    }) => Promise<Comment>;
+    /**
+     * Edit a comment's body. Only the comment's AUTHOR may do this - not
+     * maintainers, not admins. Sets `edited` on the comment.
+     * @param {string} id - The comment id
+     * @param {string} body - The replacement text
+     * @returns {Promise<Comment>}
+     */
+    update: (id: string, body: string) => Promise<Comment>;
+    /**
+     * 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<void>;
+    /**
+     * Comment counts per entity, as an `{entityId: n}` map, over the same
+     * scope and filters as `list`. One cheap request paints a comment
+     * indicator on every annotated item in a document without paging
+     * through the bodies.
+     *
+     * The response is NOT key-transformed: its keys are entity ids, and
+     * camelCasing would mangle the hyphens in a UUID.
+     * @param {string} projectId - The project to read
+     * @param {{documentId?: string, entityType?: CommentableType, entityId?: string}} [filters] - Same filters as list()
+     * @returns {Promise<Object<string, number>>}
+     */
+    counts: (projectId: string, { documentId, entityType, entityId }?: {
+        documentId?: string;
+        entityType?: CommentableType;
+        entityId?: string;
+    }) => Promise<{
+        [x: string]: number;
+    }>;
+    /**
+     * Comment counts per entry of a vocabulary, as an `{entityId: n}` map.
+     * The response is NOT key-transformed: its keys are entry ids.
+     * @param {string} vocabId - The vocab layer to read
+     * @param {object} [filters]
+     * @param {string} [filters.entityId] - One entry only
+     * @returns {Promise<Object<string, number>>}
+     */
+    countsInVocab: (vocabId: string, { entityId }?: {
+        entityId?: string;
+    }) => Promise<{
+        [x: string]: number;
+    }>;
+};
+/** @param {import("./client.js").PlaidClient} client */
+export function eventsApi(client: import("./client.js").PlaidClient): {
+    /**
+     * A project's events in arrival order. Maintainer or admin only.
+     * Transparently follows pagination cursors and returns the full flat
+     * array.
+     * @param {string} projectId - The project to read
+     * @param {object} [filters]
+     * @param {string|string[]} [filters.types] - Only these types
+     * @param {string} [filters.startTime] - Only events the server stamped at or after this instant
+     * @param {string} [filters.endTime] - Only events the server stamped at or before this instant
+     * @returns {Promise<ClientEvent[]>}
+     */
+    list: (projectId: string, { types, startTime, endTime }?: {
+        types?: string | string[];
+        startTime?: string;
+        endTime?: string;
+    }) => Promise<ClientEvent[]>;
+    /**
+     * One page of a project's events. Maintainer or admin only.
+     * @param {string} projectId - The project to read
+     * @param {object} [opts]
+     * @param {number} [opts.limit] - Page size (1..1000; server default 100)
+     * @param {string} [opts.cursor] - Opaque cursor from a previous page
+     * @param {string|string[]} [opts.types] - Only these types
+     * @param {string} [opts.startTime] - Only events at or after this instant
+     * @param {string} [opts.endTime] - Only events at or before this instant
+     * @returns {Promise<Page<ClientEvent>>}
+     */
+    listPage: (projectId: string, { limit, cursor, types, startTime, endTime }?: {
+        limit?: number;
+        cursor?: string;
+        types?: string | string[];
+        startTime?: string;
+        endTime?: string;
+    }) => Promise<Page<ClientEvent>>;
+    /**
+     * Async-iterate a project's events page by page; yields each page's entries array.
+     * @param {string} projectId - The project to read
+     * @param {object} [opts]
+     * @param {number} [opts.pageSize] - Per-request page size
+     * @param {string|string[]} [opts.types] - Only these types
+     * @param {string} [opts.startTime] - Only events at or after this instant
+     * @param {string} [opts.endTime] - Only events at or before this instant
+     * @returns {AsyncGenerator<ClientEvent[]>}
+     */
+    iterPages: (projectId: string, { pageSize, types, startTime, endTime }?: {
+        pageSize?: number;
+        types?: string | string[];
+        startTime?: string;
+        endTime?: string;
+    }) => AsyncGenerator<ClientEvent[]>;
+    /**
+     * Record events directly, with no buffering. Requires write access, and
+     * the server refuses with a 403 while the project's switch is off. All
+     * or nothing: one bad event refuses the request with a 400 naming it.
+     * @param {string} projectId - The project the events happened in
+     * @param {Array<{type: string, documentId?: string, targetId?: string, data?: object, clientTs?: string}>} events - At most 500 events
+     * @returns {Promise<{count: number}>}
+     */
+    create: (projectId: string, events: Array<{
+        type: string;
+        documentId?: string;
+        targetId?: string;
+        data?: object;
+        clientTs?: string;
+    }>) => Promise<{
+        count: number;
+    }>;
+    /**
+     * Record one research-telemetry event (plaid-core sql/client_event.clj).
+     * Fire and forget: the event is buffered and sent with
+     * others every ten seconds, at fifty events, and when the page is
+     * hidden. A batch that fails is dropped, nothing is retried, and
+     * nothing is ever thrown. Sends nothing for a project whose switch
+     * (`config.plaid.research.telemetry`) is off, which it reads from the
+     * project itself. `suggestion.shown` is recorded once per target,
+     * field and value in a page session.
+     * @param {ClientEventType} type - The event type
+     * @param {object} fields
+     * @param {string} fields.projectId - The project it happened in
+     * @param {string} [fields.documentId] - The document it happened in
+     * @param {string} [fields.targetId] - What it is about: a token, a plan
+     * @param {object} [fields.data] - Its details, keyed by single lowercase words (`value`, `source`, `field`, `written`, `conversation`)
+     * @returns {boolean} Whether the event was buffered
+     */
+    record: (type: ClientEventType, fields: {
+        projectId: string;
+        documentId?: string;
+        targetId?: string;
+        data?: object;
+    }) => boolean;
+    /**
+     * Send what the recorder holds now, rather than at its next interval.
+     * @returns {void}
+     */
+    flush: () => void;
+    /**
+     * Tell the recorder a project's switch at once, e.g. right after a
+     * maintainer changed it. Turning it off drops what is buffered.
+     * @param {string} projectId - The project
+     * @param {boolean} on - Whether telemetry is on
+     * @returns {void}
+     */
+    setEnabled: (projectId: string, on: boolean) => void;
+};
+/** @param {import("./client.js").PlaidClient} client */
+export function operationGroupsApi(client: import("./client.js").PlaidClient): {
+    /**
+     * Get a logical-operation group (its label + creator).
+     * @param {string} id - The group id
+     * @returns {Promise<OperationGroup>}
+     */
+    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<OperationGroup>;
+};
+export type TextEditOp = import("./types.js").TextEditOp;
+export type TextGap = import("./types.js").TextGap;
+export type MetadataOp = import("./types.js").MetadataOp;
+export type LayerConstraint = import("./types.js").LayerConstraint;
+export type ConstraintWriteOptions = import("./types.js").ConstraintWriteOptions;
+export type ConstraintViolation = import("./types.js").ConstraintViolation;
+export type Requester = import("./types.js").Requester;
+export type BatchRef = import("./types.js").BatchRef;
+export type ServiceParam = import("./types.js").ServiceParam;
+export type ServiceInfo = import("./types.js").ServiceInfo;
+export type DiscoveredService = import("./types.js").DiscoveredService;
+export type ResponseHelper = import("./types.js").ResponseHelper;
+export type ServiceRegistration = import("./types.js").ServiceRegistration;
+export type ServiceStatusEvent = import("./types.js").ServiceStatusEvent;
+export type OperationGroupsBundle = import("./types.js").OperationGroupsBundle;
+export type PlaidClientOptions = import("./types.js").PlaidClientOptions;
+export type OperationKind = import("./types.js").OperationKind;
+export type KeySeed = import("./types.js").KeySeed;
+export type PlaidBatch = import("./types.js").PlaidBatch;
+export type AuditPageOptions = import("./types.js").AuditPageOptions;
+export type VocabItemRestoreSummary = import("./types.js").VocabItemRestoreSummary;
+export type UserDataEntry = import("./types.js").UserDataEntry;
+export type AdminUserDataEntry = import("./types.js").AdminUserDataEntry;
+export type ActivityTallyRow = import("./types.js").ActivityTallyRow;
+export type ConstraintRepair = import("./types.js").ConstraintRepair;
+export type ValueSetRule = import("./types.js").ValueSetRule;
+export type RefusedValues = import("./types.js").RefusedValues;
+export type CommentableType = import("./types.js").CommentableType;
+export type Comment = import("./types.js").Comment;
+export type Guideline = import("./types.js").Guideline;
+export type ClientEventType = import("./types.js").ClientEventType;
+export type ClientEvent = import("./types.js").ClientEvent;
+export type Invite = import("./types.js").Invite;
+export type ServerLimits = import("./types.js").ServerLimits;
+export type ServerHealth = import("./types.js").ServerHealth;
+export type RateLimitBucket = import("./types.js").RateLimitBucket;
+export type RateLimitSnapshot = import("./types.js").RateLimitSnapshot;
+export type BackupStatus = import("./types.js").BackupStatus;
+export type ServerReport = import("./types.js").ServerReport;
+export type LiveLog = import("./types.js").LiveLog;
+export type SSEConnection = import("./types.js").SSEConnection;
+export type SSEStats = import("./types.js").SSEStats;
+export type AtomicValue = import("./types.js").AtomicValue;
+export type Created = import("./types.js").Created;
+export type Project = import("./types.js").Project;
+export type ProjectTextLayer = import("./types.js").ProjectTextLayer;
+export type ProjectTokenLayer = import("./types.js").ProjectTokenLayer;
+export type ProjectSpanLayer = import("./types.js").ProjectSpanLayer;
+export type ProjectRelationLayer = import("./types.js").ProjectRelationLayer;
+export type ProjectVocab = import("./types.js").ProjectVocab;
+export type PlaidDocument = import("./types.js").PlaidDocument;
+export type DocumentTextLayer = import("./types.js").DocumentTextLayer;
+export type DocumentTokenLayer = import("./types.js").DocumentTokenLayer;
+export type DocumentSpanLayer = import("./types.js").DocumentSpanLayer;
+export type PlaidText = import("./types.js").PlaidText;
+export type TextReshape = import("./types.js").TextReshape;
+export type Token = import("./types.js").Token;
+export type Span = import("./types.js").Span;
+export type Relation = import("./types.js").Relation;
+export type VocabItem = import("./types.js").VocabItem;
+export type VocabLink = import("./types.js").VocabLink;
+export type VocabLayer = import("./types.js").VocabLayer;
+export type TextLayer = import("./types.js").TextLayer;
+export type TokenLayer = import("./types.js").TokenLayer;
+export type SpanLayer = import("./types.js").SpanLayer;
+export type RelationLayer = import("./types.js").RelationLayer;
+export type MetadataRecords = import("./types.js").MetadataRecords;
+export type LayerRecords = import("./types.js").LayerRecords;
+export type User = import("./types.js").User;
+export type ProjectListEntry = import("./types.js").ProjectListEntry;
+export type DocumentListEntry = import("./types.js").DocumentListEntry;
+export type ApiToken = import("./types.js").ApiToken;
+export type AuditUser = import("./types.js").AuditUser;
+export type AuditTarget = import("./types.js").AuditTarget;
+export type AuditOp = import("./types.js").AuditOp;
+export type AuditEntry = import("./types.js").AuditEntry;
+export type LockGrant = import("./types.js").LockGrant;
+export type DocumentRestoreSummary = import("./types.js").DocumentRestoreSummary;
+export type RestoreCounts = import("./types.js").RestoreCounts;
+export type OperationGroup = import("./types.js").OperationGroup;
+export type QueryResult = import("./types.js").QueryResult;
+export type Page<T = any> = import("./types.js").Page<T>;