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

package/README.md

@@ -0,0 +1,39 @@
+# @larc-iu/plaid-client
+
+The JavaScript client for the [Plaid](https://larc-iu.github.io/plaid/) annotation API.
+It has no dependencies and runs in browsers and in Node.
+
+## From npm
+
+```sh
+npm install @larc-iu/plaid-client@alpha
+```
+
+```js
+import { PlaidClient } from "@larc-iu/plaid-client";
+
+const client = await PlaidClient.login("http://localhost:8080", "user@example.com", "password");
+console.log(await client.projects.list());
+```
+
+## From a Plaid server
+
+Every Plaid server serves the client that matches its own version at `/client/plaid-client.js`, with its type declarations at `/client/plaid-client.d.ts`.
+A page served by Plaid, for example from the folder set as `static_resources_path` in its `config.toml`, can import it without bundling a copy:
+
+```html
+<script type="module">
+  import { PlaidClient } from "/client/plaid-client.js";
+  const client = await PlaidClient.login(location.origin, "user@example.com", "password");
+  console.log(await client.projects.list());
+</script>
+```
+
+## Documentation
+
+- [Manual](https://larc-iu.github.io/plaid/manual.html), which covers the API and its concepts.
+- [API reference](https://larc-iu.github.io/plaid/api-js.html) for this client.
+
+## Types
+
+The type declarations are generated from the JSDoc in `src/` by `npm run types` (TypeScript's `tsc`), which `npm pack` runs. The JSDoc is their only source.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larc-iu/plaid-client",
-  "version": "0.2.0-alpha.3",
+  "version": "0.2.0-alpha.30",
   "description": "JavaScript client for the Plaid annotation API",
   "type": "module",
   "repository": {
@@ -14,13 +14,20 @@
   },
   "main": "src/index.js",
   "exports": {
-    ".": "./src/index.js"
+    ".": "./src/index.js",
+    "./testing": "./src/testing.js"
   },
   "scripts": {
-    "test": "node --test"
+    "test": "node --test",
+    "types": "npm run clean-types && tsc -p .",
+    "clean-types": "node -e \"const fs = require('fs'); for (const f of fs.readdirSync('src')) if (f.endsWith('.d.ts')) fs.rmSync('src/' + f)\"",
+    "prepack": "npm run types",
+    "postpack": "npm run clean-types"
   },
   "files": [
-    "src/",
-    "index.d.ts"
-  ]
+    "src/"
+  ],
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
 }

package/src/apiAnnotations.d.ts

@@ -0,0 +1,508 @@
+/**
+ * @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 tokensApi(client: import("./client.js").PlaidClient): {
+    setMetadata: (id: string, body: object, auditMessage?: string) => Promise<import("./types.js").Token>;
+    deleteMetadata: (id: string, auditMessage?: string) => Promise<import("./types.js").Token>;
+    patchMetadata: (id: string, body: import("./families.js").MetadataOp[], auditMessage?: string) => Promise<import("./types.js").Token>;
+    /**
+     * Get a token.
+     * @param {string} tokenId - The token ID
+     * @returns {Promise<Token>}
+     */
+    get: (tokenId: 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.
+     * For tokens sharing the same begin, precedence controls the linear
+     * ordering.
+     *
+     * Offsets are 0-based indices in Unicode CODE POINTS (not UTF-16 code
+     * units): a supplementary-plane character (emoji, SMP script) is one
+     * position. JS strings are UTF-16, so do NOT use `str.length` /
+     * `str.substring` to compute offsets — count code points instead
+     * (e.g. `[...str].length`, or iterate with `codePointAt`).
+     * @param {string} tokenLayerId - The token layer ID
+     * @param {string} text - The text ID
+     * @param {number} begin - Start offset, inclusive (Unicode code points)
+     * @param {number} end - End offset, exclusive (Unicode code points)
+     * @param {number} [precedence] - Ordering precedence
+     * @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: (tokenLayerId: string, text: string, begin: number, end: number, precedence?: number, metadata?: any, auditMessage?: string, { id }?: {
+        id?: string;
+    }) => Promise<Created>;
+    /**
+     * Update a token.
+     * @param {string} tokenId - The token ID
+     * @param {number} [begin] - New start offset, inclusive (Unicode code points)
+     * @param {number} [end] - New end offset, exclusive (Unicode code points)
+     * @param {?number} [precedence] - Ordering precedence. Omit (undefined)
+     *   to leave unchanged; pass a number to set; pass null explicitly to
+     *   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<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<void>;
+    /**
+     * Create multiple tokens in a single operation.
+     * @param {Array} body - The tokens to create, each as its single create takes it
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<{ids: string[]}>} The created entity IDs, in input order.
+     */
+    bulkCreate: (body: any[], auditMessage?: string) => Promise<{
+        ids: string[];
+    }>;
+    /**
+     * Delete multiple tokens in a single operation. Provide an array of IDs.
+     * @param {Array} body - The IDs of the tokens to delete
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<void>}
+     */
+    bulkDelete: (body: any[], auditMessage?: string) => Promise<void>;
+    /**
+     * Update many tokens in a single operation: patch metadata.
+     * @param {Array} body - Objects of the shape `{id, metadata}`. `metadata` is a list of metadata ops, as for patchMetadata. The tokens may lie in several documents of one project; every document touched has its version bumped and every new version comes back in `X-Document-Versions` (past fifty documents, only their number, in `X-Document-Versions-Omitted`). A `document-version` precondition is accepted only when every entry lies in one document. An unknown id refuses the whole update.
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<{count: number}>} How many tokens were updated.
+     */
+    bulkUpdate: (body: any[], auditMessage?: string) => Promise<{
+        count: number;
+    }>;
+    /**
+     * 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
+     * @param {{id?: string, keep?: "left"|"right"}} [options] - `id`: the new
+     *   token's id, a UUIDv7 this client minted. `keep`: the half the original token
+     *   (its id, spans, vocab-links, comments and metadata) stays on, `"left"` by
+     *   default. With `"right"` the new token, whose id is answered, is the left
+     *   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<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.
+     * On partitioning layers the tokens must be adjacent; on non-overlapping layers the
+     * merged extent must not engulf a third token.
+     * @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<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
+     * would create an overlap is rejected.
+     * @param {string} tokenId - The token ID
+     * @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<Token>;
+};
+/** @param {import("./client.js").PlaidClient} client */
+export function spansApi(client: import("./client.js").PlaidClient): {
+    setMetadata: (id: string, body: object, auditMessage?: string) => Promise<import("./types.js").Span>;
+    deleteMetadata: (id: string, auditMessage?: string) => Promise<import("./types.js").Span>;
+    patchMetadata: (id: string, body: import("./families.js").MetadataOp[], auditMessage?: string) => Promise<import("./types.js").Span>;
+    /**
+     * Get a span by ID.
+     * @param {string} spanId - The span ID
+     * @returns {Promise<Span>}
+     */
+    get: (spanId: 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.
+     * @param {string} spanLayerId - The span layer ID
+     * @param {Array} tokens - The tokens
+     * @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: (spanLayerId: string, tokens: any[], value: any, metadata?: any, auditMessage?: string, { id }?: {
+        id?: string;
+    }) => Promise<Created>;
+    /**
+     * 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<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<void>;
+    /**
+     * Create multiple spans in a single operation.
+     * @param {Array} body - The spans to create, each as its single create takes it
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<{ids: string[]}>} The created entity IDs, in input order.
+     */
+    bulkCreate: (body: any[], auditMessage?: string) => Promise<{
+        ids: string[];
+    }>;
+    /**
+     * Delete multiple spans in a single operation. Provide an array of IDs.
+     * @param {Array} body - The IDs of the spans to delete
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<void>}
+     */
+    bulkDelete: (body: any[], auditMessage?: string) => Promise<void>;
+    /**
+     * Update many spans in a single operation: set values and/or patch metadata.
+     * @param {Array} body - Objects of the shape `{id, value?, metadata?}`. `value` is set only when the key is present (null sends JSON null); `metadata` is a list of metadata ops, as for patchMetadata. The spans may lie in several documents of one project; every document touched has its version bumped and every new version comes back in `X-Document-Versions` (past fifty documents, only their number, in `X-Document-Versions-Omitted`). A `document-version` precondition is accepted only when every entry lies in one document. An unknown id refuses the whole update.
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<{count: number}>} How many spans were updated.
+     */
+    bulkUpdate: (body: any[], auditMessage?: string) => Promise<{
+        count: number;
+    }>;
+    /**
+     * 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<Span>;
+};
+/** @param {import("./client.js").PlaidClient} client */
+export function relationsApi(client: import("./client.js").PlaidClient): {
+    setMetadata: (id: string, body: object, auditMessage?: string) => Promise<import("./types.js").Relation>;
+    deleteMetadata: (id: string, auditMessage?: string) => Promise<import("./types.js").Relation>;
+    patchMetadata: (id: string, body: import("./families.js").MetadataOp[], auditMessage?: string) => Promise<import("./types.js").Relation>;
+    /**
+     * Get a relation by ID.
+     * @param {string} relationId - The relation ID
+     * @returns {Promise<Relation>}
+     */
+    get: (relationId: 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} 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: (relationLayerId: string, source: string, target: string, value: any, metadata?: any, auditMessage?: string, { id }?: {
+        id?: string;
+    }) => Promise<Created>;
+    /**
+     * 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<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<void>;
+    /**
+     * Create multiple relations in a single operation.
+     * @param {Array} body - The relations to create, each as its single create takes it
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<{ids: string[]}>} The created entity IDs, in input order.
+     */
+    bulkCreate: (body: any[], auditMessage?: string) => Promise<{
+        ids: string[];
+    }>;
+    /**
+     * Delete multiple relations in a single operation. Provide an array of IDs.
+     * @param {Array} body - The IDs of the relations to delete
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<void>}
+     */
+    bulkDelete: (body: any[], auditMessage?: string) => Promise<void>;
+    /**
+     * Update many relations in a single operation: set values and/or patch metadata.
+     * @param {Array} body - Objects of the shape `{id, value?, metadata?}`. `value` is set only when the key is present (null sends JSON null); `metadata` is a list of metadata ops, as for patchMetadata. The relations may lie in several documents of one project; every document touched has its version bumped and every new version comes back in `X-Document-Versions` (past fifty documents, only their number, in `X-Document-Versions-Omitted`). A `document-version` precondition is accepted only when every entry lies in one document. An unknown id refuses the whole update.
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<{count: number}>} How many relations were updated.
+     */
+    bulkUpdate: (body: any[], auditMessage?: string) => Promise<{
+        count: number;
+    }>;
+    /**
+     * Update the target 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>}
+     */
+    setTarget: (relationId: string, spanId: string, 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<Relation>;
+};
+/** @param {import("./client.js").PlaidClient} client */
+export function vocabLinksApi(client: import("./client.js").PlaidClient): {
+    setMetadata: (id: string, body: object, auditMessage?: string) => Promise<import("./types.js").VocabLink>;
+    deleteMetadata: (id: string, auditMessage?: string) => Promise<import("./types.js").VocabLink>;
+    patchMetadata: (id: string, body: import("./families.js").MetadataOp[], auditMessage?: string) => Promise<import("./types.js").VocabLink>;
+    /**
+     * Get a vocab link by ID
+     * @param {string} id - The resource ID
+     * @returns {Promise<VocabLink>}
+     */
+    get: (id: string) => Promise<VocabLink>;
+    /**
+     * Create a new vocab link between tokens and a vocab item.
+     * @param {string} vocabItem - The vocab item to link
+     * @param {Array} tokens - The tokens to link
+     * @param {any} [metadata] - Metadata for the link. 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: (vocabItem: string, tokens: any[], metadata?: any, auditMessage?: string, { id }?: {
+        id?: string;
+    }) => Promise<Created>;
+    /**
+     * 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<void>;
+    /**
+     * Create multiple vocab links in a single operation. Entries may
+     * reference different vocab items, but all tokens across the call must
+     * belong to one document.
+     * @param {Array<{vocabItem: string, tokens: string[], metadata?: any}>} body - The vocab links to create
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<{ids: string[]}>} The created entity IDs, in input order.
+     */
+    bulkCreate: (body: Array<{
+        vocabItem: string;
+        tokens: string[];
+        metadata?: any;
+    }>, auditMessage?: string) => Promise<{
+        ids: string[];
+    }>;
+    /**
+     * Delete multiple vocab links in a single operation. Provide an array of IDs.
+     * @param {string[]} body - The vocab link IDs to delete
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<void>}
+     */
+    bulkDelete: (body: string[], auditMessage?: string) => Promise<void>;
+};
+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>;