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

package/src/apiPeople.d.ts

@@ -0,0 +1,626 @@
+/**
+ * @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 usersApi(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>>;
+    /**
+     * Get a user by ID
+     * @param {string} id - The resource ID
+     * @returns {Promise<User>}
+     */
+    get: (id: string) => Promise<User>;
+    /**
+     * 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<ArrayBuffer>;
+    /**
+     * List (or search) users. Transparently follows pagination cursors and
+     * 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<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<Page<User>>}
+     */
+    listPage: ({ q, limit, cursor }?: {
+        q?: string;
+        limit?: number;
+        cursor?: string;
+    }) => 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<User[]>}
+     */
+    iterPages: ({ q, pageSize }?: {
+        q?: string;
+        pageSize?: number;
+    }) => AsyncGenerator<User[]>;
+    /**
+     * Create a new user. Admin only, and not with a named API token (403):
+     * it needs a sign-in token.
+     * @param {string} email - The account's email address. It becomes the
+     *   user's id and is what they log in with; it can never be changed.
+     * @param {string} password - The password
+     * @param {boolean} isAdmin - Whether the user is an admin
+     * @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<Created>;
+    /**
+     * 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
+     * name or password. A password change cannot be made with a named API
+     * token (403): it needs a sign-in token.
+     *
+     * A user's id is their email address and is fixed for the life of the
+     * account — it is what they log in with, so nothing can change it.
+     * @param {string} id - The resource ID (the user's email address)
+     * @param {string} [password] - New password
+     * @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<User>;
+    /**
+     * Deactivate a user. Users are never hard-deleted: deactivation
+     * rejects their logins and tokens, strips their project memberships
+     * and vocab maintainerships, and revokes their API tokens. The user
+     * stays visible in listings with a deactivated-at timestamp.
+     * 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<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<User>;
+    /**
+     * A token that shows any user's profile picture without an
+     * Authorization header, for an `<img>`, which cannot send one. Resolves
+     * to `{ token, expiresAt }` (`expiresAt` an ISO-8601 instant, a day on by
+     * default). The server refuses it on every route but the picture, and
+     * it stops working when the user signs out or changes password.
+     *
+     * One token serves the whole client: it is kept and handed out again
+     * until under ten minutes of it remain (half its life, for one minted
+     * near the end of a login), calls made while one is being minted share
+     * that request, and it is dropped when the client's token changes.
+     * avatarUrl() uses it.
+     * @param {{renew?: boolean}} [options] - `renew`: mint a new one
+     *   whatever is kept, unless one was minted in the last few seconds
+     *   (or is being minted), which is shared
+     * @returns {Promise<{token: string, expiresAt: string}>}
+     */
+    avatarToken: ({ renew }?: {
+        renew?: boolean;
+    }) => Promise<{
+        token: string;
+        expiresAt: string;
+    }>;
+    /**
+     * Build a URL for a user's profile picture, for an `<img>` src. The
+     * URL carries the client's avatar token (see avatarToken()), never the
+     * login token.
+     *
+     * Pass the user record's `avatarHash` as the second argument whenever you
+     * have it: the URL then addresses that exact picture, so the browser can
+     * cache it indefinitely and still pick up a replacement the moment the
+     * user changes it. Resolves to null when `avatarHash` is null (the user
+     * has no picture), so callers can fall back to initials without a
+     * wasted request.
+     * @param {string} id - The user ID
+     * @param {string|null} [avatarHash] - The user record's `avatarHash`
+     * @param {{renew?: boolean}} [options] - `renew`: mint a new avatar
+     *   token first, for a picture its URL failed to load (the token
+     *   stops working when the login it was minted under ends)
+     * @returns {Promise<string|null>}
+     */
+    avatarUrl: (id: string, avatarHash?: string | null, { renew }?: {
+        renew?: boolean;
+    }) => Promise<string | null>;
+    /**
+     * 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
+     * length, and re-encodes, so no client-side resizing is needed. Accepts
+     * PNG, JPEG, WebP, and GIF. Resolves to the updated user record.
+     * @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<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<void>;
+};
+/** @param {import("./client.js").PlaidClient} client */
+export function apiTokensApi(client: import("./client.js").PlaidClient): {
+    /**
+     * List a user's named API tokens. Never includes the signed token
+     * 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<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<Page<ApiToken>>}
+     */
+    listPage: (userId: string, { limit, cursor }?: {
+        limit?: number;
+        cursor?: string;
+    }) => 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<ApiToken[]>}
+     */
+    iterPages: (userId: string, { pageSize }?: {
+        pageSize?: number;
+    }) => 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
+     * do not expire and survive password changes / logout; revoke to kill.
+     * A client signed in with a named API token cannot do this (403): it
+     * needs a sign-in token.
+     * @param {string} userId - The user ID who will own the token
+     * @param {string} name - A human label, e.g. "Stanza parser"
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<{id: string, name: string, token: string}>}
+     */
+    create: (userId: string, name: string, auditMessage?: string) => Promise<{
+        id: string;
+        name: string;
+        token: string;
+    }>;
+    /**
+     * Revoke a named API token (soft-revoke; idempotent).
+     * A client signed in with a named API token cannot do this (403): it
+     * needs a sign-in token.
+     * @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<void>;
+};
+/** @param {import("./client.js").PlaidClient} client */
+export function invitesApi(client: import("./client.js").PlaidClient): {
+    /**
+     * List invites you minted, oldest first. With `projectId`, lists that
+     * project's invites instead (including co-maintainers'), which requires
+     * maintainer or admin on it. Never includes invite codes — the code is
+     * returned once, by create(), and is not recoverable afterward.
+     * Transparently follows pagination cursors and returns the full flat array.
+     * @param {object} [opts]
+     * @param {string} [opts.projectId] - List this project's invites instead of your own
+     * @param {boolean} [opts.all] - List every invite on the server (admin only)
+     * @returns {Promise<Invite[]>}
+     */
+    list: ({ projectId, all }?: {
+        projectId?: string;
+        all?: boolean;
+    }) => Promise<Invite[]>;
+    /**
+     * Fetch a single page of invites.
+     * @param {object} [opts]
+     * @param {string} [opts.projectId] - List this project's invites instead of your own
+     * @param {boolean} [opts.all] - List every invite on the server (admin only)
+     * @param {number} [opts.limit] - Page size (1..1000; server default 100)
+     * @param {string} [opts.cursor] - Opaque cursor from a previous page
+     * @returns {Promise<Page<Invite>>}
+     */
+    listPage: ({ projectId, all, limit, cursor }?: {
+        projectId?: string;
+        all?: boolean;
+        limit?: number;
+        cursor?: string;
+    }) => Promise<Page<Invite>>;
+    /**
+     * Async-iterate invites page by page; yields each page's entries array.
+     * @param {object} [opts]
+     * @param {string} [opts.projectId] - List this project's invites instead of your own
+     * @param {boolean} [opts.all] - List every invite on the server (admin only)
+     * @param {number} [opts.pageSize] - Per-request page size
+     * @returns {AsyncGenerator<Invite[]>}
+     */
+    iterPages: ({ projectId, all, pageSize }?: {
+        projectId?: string;
+        all?: boolean;
+        pageSize?: number;
+    }) => AsyncGenerator<Invite[]>;
+    /**
+     * Mint an invite. The returned `code` is shown ONLY here — it is never
+     * stored and cannot be recovered, so build and hand off the link now.
+     * Use PlaidClient.inviteUrl() to turn it into one.
+     *
+     * Admins may mint anything. A project maintainer may mint role grants on
+     * projects they maintain, and nothing else: no admin grant, no grantless
+     * invite, no password resets — so for a non-admin, projectId/projectRole
+     * are required in practice (403 without them).
+     *
+     * Needs a signed-in session: a client signed in with a named API token
+     * cannot mint any invite (403).
+     *
+     * EVERY option is optional; `create()` with no arguments mints a
+     * single-use signup link granting nothing but an account. Two pairing
+     * rules the server enforces with a 400: projectId and projectRole must be
+     * given TOGETHER, and targetUserId may not be combined with projectId,
+     * grantAdmin, or a maxUses above 1.
+     * @param {object} [opts]
+     * @param {string} [opts.projectId] - Project the redeemer joins (requires projectRole)
+     * @param {string} [opts.projectRole] - "reader" | "writer" | "maintainer" (requires projectId)
+     * @param {boolean} [opts.grantAdmin] - Make the new account a global admin (admin only)
+     * @param {string} [opts.targetUserId] - Password reset for that user instead of a signup; admin only, single-use, grants nothing
+     * @param {number} [opts.maxUses] - How many accounts this link may create (default 1)
+     * @param {number} [opts.ttlDays] - Days until it expires (default 14, max 365)
+     * @param {string} [opts.note] - Human label shown in your invite list
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<Invite & {code: string}>}
+     */
+    create: ({ projectId, projectRole, grantAdmin, targetUserId, maxUses, ttlDays, note, }?: {
+        projectId?: string;
+        projectRole?: string;
+        grantAdmin?: boolean;
+        targetUserId?: string;
+        maxUses?: number;
+        ttlDays?: number;
+        note?: string;
+    }, auditMessage?: string) => Promise<Invite & {
+        code: string;
+    }>;
+    /**
+     * Revoke an invite, killing the link immediately. Idempotent. Allowed for
+     * 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<void>;
+};
+/** @param {import("./client.js").PlaidClient} client */
+export function authApi(client: import("./client.js").PlaidClient): {
+    /**
+     * End every sign-in of this user on every device: each browser tab,
+     * script and service holding one of the user's sign-in tokens is
+     * refused from now on, this client included. Named API tokens are not
+     * affected (revoke one with `apiTokens.revoke`). To sign out of one tab
+     * only, discard its token instead. A signal rather than project data:
+     * made on a batch it still goes out at once, and it never joins an
+     * operation.
+     * @returns {Promise<void>}
+     */
+    logoutEverywhere: () => Promise<void>;
+};
+/** @param {import("./client.js").PlaidClient} client */
+export function userDataApi(client: import("./client.js").PlaidClient): {
+    /**
+     * Read one private data entry ({key, updatedAt, version, value}); 404 if absent.
+     * @param {string} userId
+     * @param {string} key
+     * @returns {Promise<UserDataEntry & {value: any}>}
+     */
+    get: (userId: string, key: string) => Promise<UserDataEntry & {
+        value: any;
+    }>;
+    /**
+     * List a user's private data entries ({key, updatedAt}, plus value when
+     * includeValues), ordered by key. Owner or admin only. Transparently
+     * follows pagination cursors and returns the full flat array.
+     *
+     * Narrow with `prefix` (the literal head of a key) and/or `pattern`, a
+     * GLOB over the whole key (`*` any run, `?` one character) — the way to
+     * ask for a key convention identified by a segment in the middle, e.g.
+     * `igt:assistant:*:meta:*` for every conversation's sidebar entry across
+     * every project without dragging down the transcripts beside them.
+     *
+     * `pageSize` is exposed here, and defaults lower than elsewhere, because
+     * one value runs to megabytes (`userDataValueBytes` in
+     * `server.limits()`): a page of them with `includeValues` is the
+     * largest response this API can be asked for. Raise it when the listing
+     * is keys, or the values are known to be small.
+     * @param {string} userId
+     * @param {object} [opts]
+     * @param {string} [opts.prefix] - Only keys starting with this prefix
+     * @param {string} [opts.pattern] - Only keys matching this GLOB
+     * @param {boolean} [opts.includeValues] - Also return each entry's value
+     * @param {number} [opts.pageSize=100] - Entries per request (1..1000)
+     * @returns {Promise<UserDataEntry[]>}
+     */
+    list: (userId: string, { prefix, pattern, includeValues, pageSize }?: {
+        prefix?: string;
+        pattern?: string;
+        includeValues?: boolean;
+        pageSize?: number;
+    }) => Promise<UserDataEntry[]>;
+    /**
+     * One page of a user's private data entries, ordered by key.
+     * @param {string} userId
+     * @param {object} [opts]
+     * @param {string} [opts.prefix] - Only keys starting with this prefix
+     * @param {string} [opts.pattern] - Only keys matching this GLOB
+     * @param {boolean} [opts.includeValues] - Also return each entry's value
+     * @param {number} [opts.limit] - Page size (1..1000; server default 100)
+     * @param {string} [opts.cursor] - Opaque cursor from a previous page
+     * @returns {Promise<Page<UserDataEntry>>}
+     */
+    listPage: (userId: string, { prefix, pattern, includeValues, limit, cursor }?: {
+        prefix?: string;
+        pattern?: string;
+        includeValues?: boolean;
+        limit?: number;
+        cursor?: string;
+    }) => Promise<Page<UserDataEntry>>;
+    /**
+     * Async generator over a user's private data entries, one page at a time.
+     * @param {string} userId
+     * @param {object} [opts]
+     * @param {string} [opts.prefix] - Only keys starting with this prefix
+     * @param {string} [opts.pattern] - Only keys matching this GLOB
+     * @param {boolean} [opts.includeValues] - Also return each entry's value
+     * @param {number} [opts.pageSize=100] - Entries per request (1..1000)
+     * @returns {AsyncGenerator<UserDataEntry[]>}
+     */
+    iterPages: (userId: string, { prefix, pattern, includeValues, pageSize }?: {
+        prefix?: string;
+        pattern?: string;
+        includeValues?: boolean;
+        pageSize?: number;
+    }) => AsyncGenerator<UserDataEntry[]>;
+    /**
+     * Delete one private data entry; 404 if absent.
+     * @param {string} userId
+     * @param {string} key
+     * @returns {Promise<void>}
+     */
+    delete: (userId: string, key: string) => Promise<void>;
+    /**
+     * Create or replace one private data entry. `value` is any JSON, up to
+     * the server's `userDataValueBytes` (`server.limits()`, 5 MB by
+     * default), and is refused with 413 over it, after which
+     * `server.limits()` answers the figure the server has now. Not audited,
+     * not batchable.
+     *
+     * The server stores it verbatim, but this client recases object keys on
+     * the way out and back like any other body (`myKey` <-> `my-key`), so a
+     * value whose keys are camelCase round-trips unchanged while one keyed
+     * by arbitrary strings does not. Put such a map under a `metadata` key,
+     * which both clients pass through untouched.
+     *
+     * Every write raises the entry's `version` by one, and reads answer it.
+     * With `version`, the write lands only when the entry is still at that
+     * version (0: only when there is no entry), and is otherwise refused with
+     * 409, `error: "version-mismatch"`, and the stored `version` and
+     * `updatedAt` on the error's `responseData`: read it again and make the
+     * change on what is there.
+     * @param {string} userId
+     * @param {string} key
+     * @param {*} value
+     * @param {object} [opts]
+     * @param {number} [opts.version] - The version this write was made from
+     * @returns {Promise<{key: string, updatedAt: string, version: number}>}
+     */
+    put: (userId: string, key: string, value: any, { version }?: {
+        version?: number;
+    }) => Promise<{
+        key: string;
+        updatedAt: string;
+        version: number;
+    }>;
+};
+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>;