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

package/src/client.d.ts

@@ -0,0 +1,1321 @@
+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>;
+export class PlaidClient {
+    /**
+     * Liveness, version and database size, with NO authentication and no client
+     * instance — for a launcher or status page checking whether a server is up
+     * before anyone logs in.
+     * @param {string} baseUrl - The API base URL
+     * @param {{timeout?: number | null}} [options]
+     * @returns {Promise<ServerHealth>}
+     */
+    static health(baseUrl: string, options?: {
+        timeout?: number | null;
+    }): Promise<ServerHealth>;
+    /**
+     * The limits this server enforces, with NO authentication and no client
+     * instance. See the instance method for the shape.
+     * @param {string} baseUrl - The API base URL
+     * @param {{timeout?: number | null}} [options]
+     * @returns {Promise<{limits: ServerLimits}>}
+     */
+    static info(baseUrl: string, options?: {
+        timeout?: number | null;
+    }): Promise<{
+        limits: ServerLimits;
+    }>;
+    /**
+     * Build the link to hand someone for an invite code. The server never sees
+     * an app URL, so the app that minted the invite is the one that names it.
+     * Both SPAs use HashRouter, so the code rides in the fragment — which also
+     * keeps it out of server access logs.
+     * @param {string} appUrl - Where the SPA lives, e.g. "https://plaid.example.org/igt/"
+     * @param {string} code - The code returned by invites.create()
+     * @returns {string}
+     */
+    static inviteUrl(appUrl: string, code: string): string;
+    /**
+     * Describe an invite code, with NO authentication — this is what a signup
+     * page calls before the redeemer has an account. Returns the kind of link
+     * ("signup" or "password-reset"), its status ("active", "used", "expired",
+     * "revoked", or "inactive" when its creator can no longer grant what it
+     * grants), and the project it grants access to, if any.
+     *
+     * Throws a 404-shaped error if the code is unknown. A known-but-dead code
+     * resolves normally with a non-"active" status, so the page can say why.
+     * @param {string} baseUrl - The API base URL
+     * @param {string} code - The invite code
+     * @param {object} [options]
+     * @returns {Promise<{kind: string, status: string, expiresAt: string, projectName?: string, projectRole?: string, email?: string, grantAdmin: boolean}>}
+     */
+    static lookupInvite(baseUrl: string, code: string, options?: object): Promise<{
+        kind: string;
+        status: string;
+        expiresAt: string;
+        projectName?: string;
+        projectRole?: string;
+        email?: string;
+        grantAdmin: boolean;
+    }>;
+    /**
+     * Redeem an invite code, with NO authentication.
+     *
+     * For a signup invite, pass `email` and `password` to create the account
+     * (and optionally `displayName`); the invite's grants are applied in the
+     * same transaction. For a password reset link, pass `password` only.
+     * Resolves to a logged-in client, exactly like login() — the redeemer just
+     * chose these credentials, so there is no reason to send them to a login
+     * form to retype them.
+     * @param {string} baseUrl - The API base URL
+     * @param {string} code - The invite code
+     * @param {object} credentials
+     * @param {string} [credentials.email] - The new account's email address,
+     *   which becomes its id and login (signup only)
+     * @param {string} [credentials.displayName] - How the new user is shown in
+     *   the UI; defaults to the local part of the email (signup only)
+     * @param {string} credentials.password - Desired password (min 8 characters)
+     * @param {object} [options]
+     * @returns {Promise<{client: PlaidClient, userId: string, kind: string}>}
+     */
+    static redeemInvite(baseUrl: string, code: string, { email, password, displayName }?: {
+        email?: string;
+        displayName?: string;
+        password: string;
+    }, options?: object): Promise<{
+        client: PlaidClient;
+        userId: string;
+        kind: string;
+    }>;
+    /**
+     * Authenticate and return a new client instance with token. This is the
+     * single auth entry point — there is no `client.login` resource.
+     * @param {string} baseUrl - The base URL for the API
+     * @param {string} userId - User ID for authentication
+     * @param {string} password - Password for authentication
+     * @param {object} [options] - Client options forwarded to the constructor (e.g. { timeout })
+     * @returns {Promise<PlaidClient>} - Authenticated client instance
+     */
+    static login(baseUrl: string, userId: string, password: string, options?: object): Promise<PlaidClient>;
+    /**
+     * Create a new PlaidClient instance
+     * @param {string} baseUrl - The base URL for the API
+     * @param {string} token - The authentication token
+     * @param {PlaidClientOptions} [options] - Client options
+     */
+    constructor(baseUrl: string, token: string, options?: PlaidClientOptions);
+    baseUrl: string;
+    token: string;
+    /** @type {number | null} */
+    timeout: number | null;
+    /** @type {number | null} */
+    batchTimeout: number | null;
+    /** @type {number[] | undefined} */
+    retryDelaysMs: number[] | undefined;
+    /**
+     * The latest version seen for each document written through this client,
+     * keyed by document id.
+     * @type {Record<string, number>}
+     */
+    documentVersions: Record<string, number>;
+    /**
+     * True once a response left its version list out
+     * (X-Document-Versions-Omitted, past fifty documents). Every version held
+     * was then forgotten, and the strict-mode document's is read again before
+     * the next write.
+     * @type {boolean | undefined}
+     */
+    documentVersionsOmitted: boolean | undefined;
+    /** @type {number | null} */
+    serverClockOffsetMs: number | null;
+    /**
+     * The document strict mode is entered for, or null.
+     * @type {string | null}
+     */
+    strictModeDocumentId: string | null;
+    /** @type {import("./documentLock.js").DocumentLockLost | null} */
+    documentLockLost: import("./documentLock.js").DocumentLockLost | null;
+    lockKeepers: Map<any, any>;
+    /**
+     * @type {{id: string, message: string | null, kind: OperationKind | null,
+     *   ref: string | null, depth: number, written: boolean, refined: any,
+     *   frames: object[]} | null}
+     */
+    operationGroup: {
+        id: string;
+        message: string | null;
+        kind: OperationKind | null;
+        ref: string | null;
+        depth: number;
+        written: boolean;
+        refined: any;
+        frames: object[];
+    } | null;
+    /** @type {((error: Error) => void) | null} */
+    onAuthError: ((error: Error) => void) | null;
+    /** @private */
+    private _authErrorFired;
+    /** @private */
+    private _retryListeners;
+    /** @private */
+    private _serverFacts;
+    /** @private @type {object | null} */
+    private _openedFrame;
+    /**
+     * A stream of this client ended without being closed here: the server may
+     * have restarted, with other limits.
+     * @private
+     */
+    private _noteStreamDropped;
+    /**
+     * A stream of this client is open. After a drop the limits are read again,
+     * once however many streams reopen.
+     * @private
+     */
+    private _noteStreamOpened;
+    /**
+     * Hear every time a request is sent again: after a 503 (the database was
+     * busy), or for a keyed write after its answer was lost (no response, 502,
+     * 504). The listener gets `{ attempt, retries, delay, error }` before the
+     * wait. A screen that writes through the client directly can say it is
+     * retrying while the server does not answer, though the browser is online.
+     * @param {(info: {attempt: number, retries: number, delay: number, error: Error}) => void} listener
+     * @returns {() => void} the unsubscribe
+     */
+    onRetry(listener: (info: {
+        attempt: number;
+        retries: number;
+        delay: number;
+        error: Error;
+    }) => void): () => void;
+    /**
+     * Tell every `onRetry` listener. A listener that throws is passed over.
+     * @private
+     */
+    private _noteRetry;
+    /**
+     * The server's time now, as its last response's Date header put it (to the
+     * second), else this machine's. Judge a time the server stamped, such as an
+     * audit entry's `ts`, against this rather than `Date.now()`: a browser
+     * clock can be minutes off.
+     * @returns {Date}
+     */
+    serverNow(): Date;
+    /**
+     * The API bundles (`client.documents`, `client.tokens`, ...). Installed on
+     * the client, and again on every batch it opens (see `batch()`): a batch is
+     * a view of the client with its own `_request`, so the same bundles built
+     * on it queue instead of sending.
+     * @private
+     */
+    private _installResources;
+    documents: {
+        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>>;
+        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<import("./types.js").PlaidDocument>;
+        deleteMetadata: (id: string, auditMessage?: string) => Promise<import("./types.js").PlaidDocument>;
+        patchMetadata: (id: string, body: import("./families.js").MetadataOp[], auditMessage?: string) => Promise<import("./types.js").PlaidDocument>;
+        get: (documentId: string, includeBody?: boolean, asOf?: string, layers?: string[] | string) => Promise<import("./apiDocuments.js").PlaidDocument>;
+        getMedia: (documentId: string, { timeout, onProgress }?: {
+            timeout?: number | null;
+            onProgress?: (progress: {
+                loaded: number;
+                total: number | null;
+            }) => void;
+        }) => Promise<Blob>;
+        create: (projectId: string, name: string, metadata?: any, auditMessage?: string, { id, freeName }?: {
+            id?: string;
+            freeName?: boolean;
+        }) => Promise<{
+            id: string;
+            name: string;
+        }>;
+        update: (documentId: string, name: string, auditMessage?: string) => Promise<import("./apiDocuments.js").PlaidDocument>;
+        delete: (documentId: string, auditMessage?: string) => Promise<void>;
+        checkLock: (documentId: string) => Promise<{
+            userId: string;
+            expiresAt: number;
+        } | void>;
+        acquireLock: (documentId: string, auditMessage?: string, newLockId?: string) => Promise<import("./apiDocuments.js").LockGrant>;
+        renewLock: (documentId: string, lockId: string, auditMessage?: string) => Promise<import("./apiDocuments.js").LockGrant>;
+        releaseLock: (documentId: string, lockId: string, auditMessage?: string) => Promise<void>;
+        locked: <T>(documentId: string, fn: (lock: import("./documentLock.js").DocumentLock) => T | Promise<T>, options?: {
+            keepAlive?: boolean;
+        }) => Promise<T>;
+        mediaLink: (documentId: string) => Promise<{
+            url: string;
+            expiresAt: string;
+        }>;
+        uploadMedia: (documentId: string, file: File, auditMessage?: string, { onProgress }?: {
+            onProgress?: (progress: {
+                loaded: number;
+                total: number | null;
+            }) => void;
+        }) => Promise<{
+            message: string;
+            extension: string;
+            contentType: string;
+        }>;
+        deleteMedia: (documentId: string, auditMessage?: string, { mediaVersion }?: {
+            mediaVersion?: string;
+        }) => Promise<void>;
+        restore: (documentId: string, asOf: string, { dryRun }?: {
+            dryRun?: boolean;
+        }, auditMessage?: string) => Promise<import("./apiDocuments.js").DocumentRestoreSummary>;
+        copy: (documentId: string, name: string, { includeMedia, id, freeName }?: {
+            includeMedia?: boolean;
+            id?: string;
+            freeName?: boolean;
+        }, auditMessage?: string) => Promise<{
+            id: string;
+            name: string;
+            mediaError?: string;
+        }>;
+    };
+    texts: {
+        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<import("./types.js").PlaidText>;
+        deleteMetadata: (id: string, auditMessage?: string) => Promise<import("./types.js").PlaidText>;
+        patchMetadata: (id: string, body: import("./families.js").MetadataOp[], auditMessage?: string) => Promise<import("./types.js").PlaidText>;
+        get: (textId: string) => Promise<import("./apiDocuments.js").PlaidText>;
+        create: (textLayerId: string, documentId: string, body: string, metadata?: any, auditMessage?: string, { id, tokenEdges, tokenizeLayer }?: {
+            id?: string;
+            tokenEdges?: number[];
+            tokenizeLayer?: string;
+        }) => Promise<import("./apiDocuments.js").Created>;
+        update: (textId: string, body: any, auditMessage?: string, { base, versioned, tokenizeLayer }?: {
+            base?: string;
+            versioned?: boolean;
+            tokenizeLayer?: string;
+        }) => Promise<import("./apiDocuments.js").PlaidText & {
+            reshape: import("./apiDocuments.js").TextReshape;
+        }>;
+        delete: (textId: string, auditMessage?: string) => Promise<void>;
+        edit: (textId: string, edits: Array<object>, auditMessage?: string, { base, versioned, tokenizeLayer }?: {
+            base?: string;
+            versioned?: boolean;
+            tokenizeLayer?: string;
+        }) => Promise<import("./apiDocuments.js").PlaidText & {
+            reshape: import("./apiDocuments.js").TextReshape;
+        }>;
+    };
+    tokens: {
+        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: (tokenId: string) => Promise<import("./apiAnnotations.js").Token>;
+        create: (tokenLayerId: string, text: string, begin: number, end: number, precedence?: number, metadata?: any, auditMessage?: string, { id }?: {
+            id?: string;
+        }) => Promise<import("./apiAnnotations.js").Created>;
+        update: (tokenId: string, begin?: number, end?: number, precedence?: number | null, auditMessage?: string) => Promise<import("./apiAnnotations.js").Token>;
+        delete: (tokenId: string, auditMessage?: string) => Promise<void>;
+        bulkCreate: (body: any[], auditMessage?: string) => Promise<{
+            ids: string[];
+        }>;
+        bulkDelete: (body: any[], auditMessage?: string) => Promise<void>;
+        bulkUpdate: (body: any[], auditMessage?: string) => Promise<{
+            count: number;
+        }>;
+        split: (tokenId: string, position: number, auditMessage?: string, { id, keep }?: {
+            id?: string;
+            keep?: "left" | "right";
+        }) => Promise<import("./apiAnnotations.js").Created>;
+        merge: (tokenId: string, otherTokenId: string, auditMessage?: string) => Promise<import("./apiAnnotations.js").Token>;
+        shift: (tokenId: string, begin?: number, end?: number, auditMessage?: string) => Promise<import("./apiAnnotations.js").Token>;
+    };
+    spans: {
+        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: (spanId: string) => Promise<import("./apiAnnotations.js").Span>;
+        create: (spanLayerId: string, tokens: any[], value: any, metadata?: any, auditMessage?: string, { id }?: {
+            id?: string;
+        }) => Promise<import("./apiAnnotations.js").Created>;
+        update: (spanId: string, value: any, auditMessage?: string) => Promise<import("./apiAnnotations.js").Span>;
+        delete: (spanId: string, auditMessage?: string) => Promise<void>;
+        bulkCreate: (body: any[], auditMessage?: string) => Promise<{
+            ids: string[];
+        }>;
+        bulkDelete: (body: any[], auditMessage?: string) => Promise<void>;
+        bulkUpdate: (body: any[], auditMessage?: string) => Promise<{
+            count: number;
+        }>;
+        setTokens: (spanId: string, tokens: any[], auditMessage?: string) => Promise<import("./apiAnnotations.js").Span>;
+    };
+    relations: {
+        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: (relationId: string) => Promise<import("./apiAnnotations.js").Relation>;
+        create: (relationLayerId: string, source: string, target: string, value: any, metadata?: any, auditMessage?: string, { id }?: {
+            id?: string;
+        }) => Promise<import("./apiAnnotations.js").Created>;
+        update: (relationId: string, value: any, auditMessage?: string) => Promise<import("./apiAnnotations.js").Relation>;
+        delete: (relationId: string, auditMessage?: string) => Promise<void>;
+        bulkCreate: (body: any[], auditMessage?: string) => Promise<{
+            ids: string[];
+        }>;
+        bulkDelete: (body: any[], auditMessage?: string) => Promise<void>;
+        bulkUpdate: (body: any[], auditMessage?: string) => Promise<{
+            count: number;
+        }>;
+        setTarget: (relationId: string, spanId: string, auditMessage?: string) => Promise<import("./apiAnnotations.js").Relation>;
+        setSource: (relationId: string, spanId: string, auditMessage?: string) => Promise<import("./apiAnnotations.js").Relation>;
+    };
+    vocabLinks: {
+        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: (id: string) => Promise<import("./apiAnnotations.js").VocabLink>;
+        create: (vocabItem: string, tokens: any[], metadata?: any, auditMessage?: string, { id }?: {
+            id?: string;
+        }) => Promise<import("./apiAnnotations.js").Created>;
+        delete: (id: string, auditMessage?: string) => Promise<void>;
+        bulkCreate: (body: Array<{
+            vocabItem: string;
+            tokens: string[];
+            metadata?: any;
+        }>, auditMessage?: string) => Promise<{
+            ids: string[];
+        }>;
+        bulkDelete: (body: string[], auditMessage?: string) => Promise<void>;
+    };
+    textLayers: {
+        get: (layerId: string) => Promise<import("./types.js").TextLayer>;
+        delete: (layerId: string, auditMessage?: string) => Promise<void>;
+        update: (layerId: string, name: string, auditMessage?: string) => Promise<import("./types.js").TextLayer>;
+        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<void>;
+        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>;
+        create: (projectId: string, name: string, auditMessage?: string, { id }?: {
+            id?: string;
+        }) => Promise<import("./apiLayers.js").Created>;
+    };
+    tokenLayers: {
+        setConstraints: (layerId: string, namespace: string, constraints: import("./families.js").LayerConstraint[], auditMessage?: string, options?: {
+            expected?: Array<object> | null;
+        }) => Promise<{
+            constraints: Record<string, import("./families.js").LayerConstraint[]>;
+        }>;
+        deleteConstraints: (layerId: string, namespace: string, auditMessage?: string, options?: {
+            expected?: Array<object> | null;
+        }) => Promise<void>;
+        checkConstraints: (layerId: string, constraints: import("./families.js").LayerConstraint[], options?: {
+            limit?: number;
+        }) => Promise<{
+            violations: import("./families.js").ConstraintViolation[];
+            violationCount: number;
+        }>;
+        repairConstraints: (layerId: string, constraints: import("./families.js").LayerConstraint[], auditMessage?: string, options?: {
+            document?: string;
+        }) => Promise<{
+            repaired: import("./families.js").ConstraintRepair[];
+            locked: Array<{
+                document: string;
+                lockedBy: string;
+            }>;
+            violations: import("./families.js").ConstraintViolation[];
+            violationCount: number;
+        }>;
+        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: (layerId: string) => Promise<import("./types.js").TokenLayer>;
+        delete: (layerId: string, auditMessage?: string) => Promise<void>;
+        update: (layerId: string, name: string, auditMessage?: string) => Promise<import("./types.js").TokenLayer>;
+        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<void>;
+        create: (textLayerId: string, name: string, overlapMode?: string, parentTokenLayerId?: string, auditMessage?: string, { id }?: {
+            id?: string;
+        }) => Promise<import("./apiLayers.js").Created>;
+        countMatching: (layerIds: string[], value: {
+            regex: string;
+            flags?: string;
+        }) => Promise<{
+            results: Array<[string, string, number]>;
+        }>;
+    };
+    spanLayers: {
+        get: (layerId: string) => Promise<import("./types.js").SpanLayer>;
+        delete: (layerId: string, auditMessage?: string) => Promise<void>;
+        update: (layerId: string, name: string, auditMessage?: string) => Promise<import("./types.js").SpanLayer>;
+        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<void>;
+        refusedValues: (layerId: string, rule: import("./families.js").ValueSetRule, options?: {
+            limit?: number;
+        }) => Promise<import("./families.js").RefusedValues>;
+        setConstraints: (layerId: string, namespace: string, constraints: import("./families.js").LayerConstraint[], auditMessage?: string, options?: {
+            expected?: Array<object> | null;
+        }) => Promise<{
+            constraints: Record<string, import("./families.js").LayerConstraint[]>;
+        }>;
+        deleteConstraints: (layerId: string, namespace: string, auditMessage?: string, options?: {
+            expected?: Array<object> | null;
+        }) => Promise<void>;
+        checkConstraints: (layerId: string, constraints: import("./families.js").LayerConstraint[], options?: {
+            limit?: number;
+        }) => Promise<{
+            violations: import("./families.js").ConstraintViolation[];
+            violationCount: number;
+        }>;
+        repairConstraints: (layerId: string, constraints: import("./families.js").LayerConstraint[], auditMessage?: string, options?: {
+            document?: string;
+        }) => Promise<{
+            repaired: import("./families.js").ConstraintRepair[];
+            locked: Array<{
+                document: string;
+                lockedBy: string;
+            }>;
+            violations: import("./families.js").ConstraintViolation[];
+            violationCount: number;
+        }>;
+        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>;
+        create: (tokenLayerId: string, name: string, auditMessage?: string, { id }?: {
+            id?: string;
+        }) => Promise<import("./apiLayers.js").Created>;
+    };
+    relationLayers: {
+        refusedValues: (layerId: string, rule: import("./families.js").ValueSetRule, options?: {
+            limit?: number;
+        }) => Promise<import("./families.js").RefusedValues>;
+        setConstraints: (layerId: string, namespace: string, constraints: import("./families.js").LayerConstraint[], auditMessage?: string, options?: {
+            expected?: Array<object> | null;
+        }) => Promise<{
+            constraints: Record<string, import("./families.js").LayerConstraint[]>;
+        }>;
+        deleteConstraints: (layerId: string, namespace: string, auditMessage?: string, options?: {
+            expected?: Array<object> | null;
+        }) => Promise<void>;
+        checkConstraints: (layerId: string, constraints: import("./families.js").LayerConstraint[], options?: {
+            limit?: number;
+        }) => Promise<{
+            violations: import("./families.js").ConstraintViolation[];
+            violationCount: number;
+        }>;
+        repairConstraints: (layerId: string, constraints: import("./families.js").LayerConstraint[], auditMessage?: string, options?: {
+            document?: string;
+        }) => Promise<{
+            repaired: import("./families.js").ConstraintRepair[];
+            locked: Array<{
+                document: string;
+                lockedBy: string;
+            }>;
+            violations: import("./families.js").ConstraintViolation[];
+            violationCount: number;
+        }>;
+        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: (layerId: string) => Promise<import("./types.js").RelationLayer>;
+        delete: (layerId: string, auditMessage?: string) => Promise<void>;
+        update: (layerId: string, name: string, auditMessage?: string) => Promise<import("./types.js").RelationLayer>;
+        shift: (layerId: string, direction: string, auditMessage?: string) => Promise<void>;
+        create: (spanLayerId: string, name: string, auditMessage?: string, { id }?: {
+            id?: string;
+        }) => Promise<import("./apiLayers.js").Created>;
+    };
+    vocabLayers: {
+        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: (id: string, includeItems?: boolean, asOf?: string) => Promise<import("./apiVocab.js").VocabLayer>;
+        getItemAt: (id: string, itemId: string, asOf: string) => Promise<import("./apiVocab.js").VocabItem>;
+        list: () => Promise<import("./apiVocab.js").VocabLayer[]>;
+        listPage: ({ limit, cursor }?: {
+            limit?: number;
+            cursor?: string;
+        }) => Promise<import("./apiVocab.js").Page<import("./apiVocab.js").VocabLayer>>;
+        iterPages: ({ pageSize }?: {
+            pageSize?: number;
+        }) => AsyncGenerator<import("./apiVocab.js").VocabLayer[]>;
+        create: (name: string, auditMessage?: string, { id }?: {
+            id?: string;
+        }) => Promise<import("./apiVocab.js").Created>;
+        update: (id: string, name: string, auditMessage?: string) => Promise<import("./apiVocab.js").VocabLayer>;
+        delete: (id: string, auditMessage?: string) => Promise<void>;
+        audit: (id: string, startTime?: string, endTime?: string, opTypes?: string[] | string, itemId?: string, kinds?: string[] | string) => Promise<import("./apiVocab.js").AuditEntry[]>;
+        auditPage: (id: string, { startTime, endTime, opTypes, kinds, order, limit, cursor, opsLimit, entryId, itemId }?: {
+            startTime?: string;
+            endTime?: string;
+            opTypes?: string[] | string;
+            kinds?: import("./apiVocab.js").OperationKind[] | string;
+            order?: "asc" | "desc";
+            limit?: number;
+            cursor?: string;
+            opsLimit?: number;
+            entryId?: string;
+            itemId?: string;
+        }) => Promise<import("./apiVocab.js").Page<import("./apiVocab.js").AuditEntry>>;
+        restoreItem: (id: string, itemId: string, asOf: string, { dryRun }?: {
+            dryRun?: boolean;
+        }, auditMessage?: string) => Promise<import("./apiVocab.js").VocabItemRestoreSummary>;
+        addMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<void>;
+        removeMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<void>;
+    };
+    vocabItems: {
+        setMetadata: (id: string, body: object, auditMessage?: string) => Promise<import("./types.js").VocabItem>;
+        deleteMetadata: (id: string, auditMessage?: string) => Promise<import("./types.js").VocabItem>;
+        patchMetadata: (id: string, body: import("./families.js").MetadataOp[], auditMessage?: string) => Promise<import("./types.js").VocabItem>;
+        get: (id: string) => Promise<import("./apiVocab.js").VocabItem>;
+        create: (vocabLayerId: string, form: string, metadata?: any, auditMessage?: string, { id }?: {
+            id?: string;
+        }) => Promise<import("./apiVocab.js").Created>;
+        update: (id: string, form: string, auditMessage?: string) => Promise<import("./apiVocab.js").VocabItem>;
+        delete: (id: string, auditMessage?: string, { expectedLinkCount }?: {
+            expectedLinkCount?: number;
+        }) => Promise<void>;
+        bulkCreate: (body: Array<{
+            vocabLayerId: string;
+            form: string;
+            metadata?: any;
+        }>, auditMessage?: string) => Promise<{
+            ids: string[];
+        }>;
+        bulkUpdate: (body: Array<{
+            id: string;
+            form?: string;
+            metadata?: Array<object>;
+        }>, auditMessage?: string) => Promise<{
+            count: number;
+        }>;
+        bulkDelete: (body: string[], auditMessage?: string) => Promise<void>;
+        merge: (survivorId: string, loserIds: string[], auditMessage?: string) => Promise<{
+            moved: number;
+            duplicates: number;
+            removed: string[];
+        }>;
+    };
+    users: {
+        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: (id: string) => Promise<import("./apiPeople.js").User>;
+        getAvatar: (id: string) => Promise<ArrayBuffer>;
+        list: ({ q }?: {
+            q?: string;
+        }) => Promise<import("./apiPeople.js").User[]>;
+        listPage: ({ q, limit, cursor }?: {
+            q?: string;
+            limit?: number;
+            cursor?: string;
+        }) => Promise<import("./apiPeople.js").Page<import("./apiPeople.js").User>>;
+        iterPages: ({ q, pageSize }?: {
+            q?: string;
+            pageSize?: number;
+        }) => AsyncGenerator<import("./apiPeople.js").User[]>;
+        create: (email: string, password: string, isAdmin: boolean, displayName?: string, auditMessage?: string) => Promise<import("./apiPeople.js").Created>;
+        update: (id: string, password?: string, displayName?: string, isAdmin?: boolean, auditMessage?: string) => Promise<import("./apiPeople.js").User>;
+        delete: (id: string, auditMessage?: string) => Promise<void>;
+        activate: (id: string, auditMessage?: string) => Promise<import("./apiPeople.js").User>;
+        avatarToken: ({ renew }?: {
+            renew?: boolean;
+        }) => Promise<{
+            token: string;
+            expiresAt: string;
+        }>;
+        avatarUrl: (id: string, avatarHash?: string | null, { renew }?: {
+            renew?: boolean;
+        }) => Promise<string | null>;
+        setAvatar: (id: string, file: File, auditMessage?: string) => Promise<import("./apiPeople.js").User>;
+        deleteAvatar: (id: string, auditMessage?: string) => Promise<void>;
+    };
+    apiTokens: {
+        list: (userId: string) => Promise<import("./apiPeople.js").ApiToken[]>;
+        listPage: (userId: string, { limit, cursor }?: {
+            limit?: number;
+            cursor?: string;
+        }) => Promise<import("./apiPeople.js").Page<import("./apiPeople.js").ApiToken>>;
+        iterPages: (userId: string, { pageSize }?: {
+            pageSize?: number;
+        }) => AsyncGenerator<import("./apiPeople.js").ApiToken[]>;
+        create: (userId: string, name: string, auditMessage?: string) => Promise<{
+            id: string;
+            name: string;
+            token: string;
+        }>;
+        revoke: (userId: string, tokenId: string, auditMessage?: string) => Promise<void>;
+    };
+    invites: {
+        list: ({ projectId, all }?: {
+            projectId?: string;
+            all?: boolean;
+        }) => Promise<import("./apiPeople.js").Invite[]>;
+        listPage: ({ projectId, all, limit, cursor }?: {
+            projectId?: string;
+            all?: boolean;
+            limit?: number;
+            cursor?: string;
+        }) => Promise<import("./apiPeople.js").Page<import("./apiPeople.js").Invite>>;
+        iterPages: ({ projectId, all, pageSize }?: {
+            projectId?: string;
+            all?: boolean;
+            pageSize?: number;
+        }) => AsyncGenerator<import("./apiPeople.js").Invite[]>;
+        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<import("./apiPeople.js").Invite & {
+            code: string;
+        }>;
+        revoke: (id: string, auditMessage?: string) => Promise<void>;
+    };
+    auth: {
+        logoutEverywhere: () => Promise<void>;
+    };
+    userData: {
+        get: (userId: string, key: string) => Promise<import("./apiPeople.js").UserDataEntry & {
+            value: any;
+        }>;
+        list: (userId: string, { prefix, pattern, includeValues, pageSize }?: {
+            prefix?: string;
+            pattern?: string;
+            includeValues?: boolean;
+            pageSize?: number;
+        }) => Promise<import("./apiPeople.js").UserDataEntry[]>;
+        listPage: (userId: string, { prefix, pattern, includeValues, limit, cursor }?: {
+            prefix?: string;
+            pattern?: string;
+            includeValues?: boolean;
+            limit?: number;
+            cursor?: string;
+        }) => Promise<import("./apiPeople.js").Page<import("./apiPeople.js").UserDataEntry>>;
+        iterPages: (userId: string, { prefix, pattern, includeValues, pageSize }?: {
+            prefix?: string;
+            pattern?: string;
+            includeValues?: boolean;
+            pageSize?: number;
+        }) => AsyncGenerator<import("./apiPeople.js").UserDataEntry[]>;
+        delete: (userId: string, key: string) => Promise<void>;
+        put: (userId: string, key: string, value: any, { version }?: {
+            version?: number;
+        }) => Promise<{
+            key: string;
+            updatedAt: string;
+            version: number;
+        }>;
+    };
+    projects: {
+        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: (id: string) => Promise<import("./apiProject.js").Project>;
+        list: () => Promise<import("./apiProject.js").ProjectListEntry[]>;
+        listPage: ({ limit, cursor }?: {
+            limit?: number;
+            cursor?: string;
+        }) => Promise<import("./apiProject.js").Page<import("./apiProject.js").ProjectListEntry>>;
+        iterPages: ({ pageSize }?: {
+            pageSize?: number;
+        }) => AsyncGenerator<import("./apiProject.js").ProjectListEntry[]>;
+        listDocuments: (id: string) => Promise<import("./apiProject.js").DocumentListEntry[]>;
+        listDocumentsPage: (id: string, { limit, cursor }?: {
+            limit?: number;
+            cursor?: string;
+        }) => Promise<import("./apiProject.js").Page<import("./apiProject.js").DocumentListEntry>>;
+        iterDocuments: (id: string, { pageSize }?: {
+            pageSize?: number;
+        }) => AsyncGenerator<import("./apiProject.js").DocumentListEntry[]>;
+        create: (name: string, auditMessage?: string, { id }?: {
+            id?: string;
+        }) => Promise<import("./apiProject.js").Created>;
+        update: (id: string, name: string, auditMessage?: string) => Promise<import("./apiProject.js").Project>;
+        delete: (id: string, auditMessage?: string, { timeout }?: {
+            timeout?: number;
+        }) => Promise<void>;
+        addWriter: (id: string, userId: string, auditMessage?: string) => Promise<void>;
+        removeWriter: (id: string, userId: string, auditMessage?: string) => Promise<void>;
+        addReader: (id: string, userId: string, auditMessage?: string) => Promise<void>;
+        removeReader: (id: string, userId: string, auditMessage?: string) => Promise<void>;
+        addMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<void>;
+        removeMaintainer: (id: string, userId: string, auditMessage?: string) => Promise<void>;
+        myLastEdits: (projectId: string) => Promise<{
+            [x: string]: string;
+        }>;
+        linkVocab: (id: string, vocabId: string, auditMessage?: string) => Promise<void>;
+        unlinkVocab: (id: string, vocabId: string, auditMessage?: string) => Promise<void>;
+    };
+    guidelines: {
+        get: (id: string) => Promise<import("./apiProject.js").Guideline>;
+        list: (projectId: string, { includeBodies }?: {
+            includeBodies?: boolean;
+        }) => Promise<import("./apiProject.js").Guideline[]>;
+        listPage: (projectId: string, { limit, cursor, includeBodies }?: {
+            limit?: number;
+            cursor?: string;
+            includeBodies?: boolean;
+        }) => Promise<import("./apiProject.js").Page<import("./apiProject.js").Guideline>>;
+        iterPages: (projectId: string, { pageSize, includeBodies }?: {
+            pageSize?: number;
+            includeBodies?: boolean;
+        }) => AsyncGenerator<import("./apiProject.js").Guideline[]>;
+        create: (projectId: string, title: string, { body, pinned, id }?: {
+            body?: string;
+            pinned?: boolean;
+            id?: string;
+        }, auditMessage?: string) => Promise<{
+            id: string;
+        }>;
+        update: (id: string, { title, body, pinned, expectedUpdatedAt }?: {
+            title?: string;
+            body?: string;
+            pinned?: boolean;
+            expectedUpdatedAt?: string;
+        }, auditMessage?: string) => Promise<import("./apiProject.js").Guideline>;
+        delete: (id: string, auditMessage?: string) => Promise<void>;
+    };
+    comments: {
+        get: (id: string) => Promise<import("./apiProject.js").Comment>;
+        list: (projectId: string, { documentId, entityType, entityId }?: {
+            documentId?: string;
+            entityType?: string;
+            entityId?: string;
+        }) => Promise<import("./apiProject.js").Comment[]>;
+        listPage: (projectId: string, { limit, cursor, documentId, entityType, entityId }?: {
+            limit?: number;
+            cursor?: string;
+            documentId?: string;
+            entityType?: string;
+            entityId?: string;
+        }) => Promise<import("./apiProject.js").Page<import("./apiProject.js").Comment>>;
+        iterPages: (projectId: string, { pageSize, documentId, entityType, entityId }?: {
+            pageSize?: number;
+            documentId?: string;
+            entityType?: string;
+            entityId?: string;
+        }) => AsyncGenerator<import("./apiProject.js").Comment[]>;
+        listInVocab: (vocabId: string, { entityId }?: {
+            entityId?: string;
+        }) => Promise<import("./apiProject.js").Comment[]>;
+        listInVocabPage: (vocabId: string, { limit, cursor, entityId }?: {
+            limit?: number;
+            cursor?: string;
+            entityId?: string;
+        }) => Promise<import("./apiProject.js").Page<import("./apiProject.js").Comment>>;
+        iterInVocabPages: (vocabId: string, { entityId, pageSize }?: {
+            entityId?: string;
+            pageSize?: number;
+        }) => AsyncGenerator<import("./apiProject.js").Comment[]>;
+        create: (entityType: import("./apiProject.js").CommentableType, entityId: string, body: string, { anchorLabel, id }?: {
+            anchorLabel?: string;
+            id?: string;
+        }) => Promise<import("./apiProject.js").Comment>;
+        update: (id: string, body: string) => Promise<import("./apiProject.js").Comment>;
+        delete: (id: string) => Promise<void>;
+        counts: (projectId: string, { documentId, entityType, entityId }?: {
+            documentId?: string;
+            entityType?: import("./apiProject.js").CommentableType;
+            entityId?: string;
+        }) => Promise<{
+            [x: string]: number;
+        }>;
+        countsInVocab: (vocabId: string, { entityId }?: {
+            entityId?: string;
+        }) => Promise<{
+            [x: string]: number;
+        }>;
+    };
+    events: {
+        list: (projectId: string, { types, startTime, endTime }?: {
+            types?: string | string[];
+            startTime?: string;
+            endTime?: string;
+        }) => Promise<import("./apiProject.js").ClientEvent[]>;
+        listPage: (projectId: string, { limit, cursor, types, startTime, endTime }?: {
+            limit?: number;
+            cursor?: string;
+            types?: string | string[];
+            startTime?: string;
+            endTime?: string;
+        }) => Promise<import("./apiProject.js").Page<import("./apiProject.js").ClientEvent>>;
+        iterPages: (projectId: string, { pageSize, types, startTime, endTime }?: {
+            pageSize?: number;
+            types?: string | string[];
+            startTime?: string;
+            endTime?: string;
+        }) => AsyncGenerator<import("./apiProject.js").ClientEvent[]>;
+        create: (projectId: string, events: Array<{
+            type: string;
+            documentId?: string;
+            targetId?: string;
+            data?: object;
+            clientTs?: string;
+        }>) => Promise<{
+            count: number;
+        }>;
+        record: (type: import("./apiProject.js").ClientEventType, fields: {
+            projectId: string;
+            documentId?: string;
+            targetId?: string;
+            data?: object;
+        }) => boolean;
+        flush: () => void;
+        setEnabled: (projectId: string, on: boolean) => void;
+    };
+    operationGroups: {
+        get: (id: string) => Promise<import("./apiProject.js").OperationGroup>;
+        update: (id: string, message: string | null) => Promise<import("./apiProject.js").OperationGroup>;
+    };
+    server: {
+        info: () => Promise<{
+            limits: import("./apiServer.js").ServerLimits;
+        }>;
+        refresh: () => Promise<{
+            limits: import("./apiServer.js").ServerLimits;
+        }>;
+        limits: () => Promise<import("./apiServer.js").ServerLimits>;
+        health: () => Promise<import("./apiServer.js").ServerHealth>;
+    };
+    admin: {
+        server: () => Promise<import("./apiServer.js").ServerReport>;
+        backup: () => Promise<import("./apiServer.js").BackupStatus>;
+        locks: () => Promise<{
+            entries: Array<{
+                documentId: string;
+                userId: string;
+                expiresAt: number;
+            }>;
+        }>;
+        releaseLock: (documentId: string) => Promise<{
+            result: string;
+        }>;
+        rateLimits: () => Promise<import("./apiServer.js").RateLimitSnapshot>;
+        clearRateLimits: ({ ip, userId }?: {
+            ip?: string;
+            userId?: string;
+        }) => Promise<{
+            result: string;
+        }>;
+        logs: ({ limit, q, level, status, user, method }?: {
+            limit?: number;
+            q?: string;
+            level?: string;
+            status?: string;
+            user?: string;
+            method?: string;
+        }) => Promise<import("./apiServer.js").LiveLog>;
+        logFile: ({ lines }?: {
+            lines?: number;
+        }) => Promise<{
+            file: (string | null);
+            lines: string[];
+            error?: string;
+        }>;
+        userData: ({ prefix, pattern, includeValues }?: {
+            prefix?: string;
+            pattern?: string;
+            includeValues?: boolean;
+        }) => Promise<import("./apiServer.js").AdminUserDataEntry[]>;
+        userDataPage: ({ prefix, pattern, includeValues, limit, cursor }?: {
+            prefix?: string;
+            pattern?: string;
+            includeValues?: boolean;
+            limit?: number;
+            cursor?: string;
+        }) => Promise<import("./apiServer.js").Page<import("./apiServer.js").AdminUserDataEntry>>;
+    };
+    audit: {
+        list: ({ startTime, endTime, opTypes, kinds }?: {
+            startTime?: string;
+            endTime?: string;
+            opTypes?: string[] | string;
+            kinds?: string[] | string;
+        }) => Promise<import("./apiServer.js").AuditEntry[]>;
+        listPage: ({ startTime, endTime, opTypes, kinds, order, limit, cursor, opsLimit, entryId }?: {
+            startTime?: string;
+            endTime?: string;
+            opTypes?: string[] | string;
+            kinds?: import("./apiServer.js").OperationKind[] | string;
+            order?: "asc" | "desc";
+            limit?: number;
+            cursor?: string;
+            opsLimit?: number;
+            entryId?: string;
+        }) => Promise<import("./apiServer.js").Page<import("./apiServer.js").AuditEntry>>;
+        iterPages: ({ startTime, endTime, opTypes, kinds, pageSize }?: {
+            startTime?: string;
+            endTime?: string;
+            opTypes?: string[] | string;
+            kinds?: import("./apiServer.js").OperationKind[] | string;
+            pageSize?: number;
+        }) => AsyncGenerator<import("./apiServer.js").AuditEntry[]>;
+        tally: ({ projectId, startTime, endTime, daily }?: {
+            projectId?: string;
+            startTime?: string;
+            endTime?: string;
+            daily?: boolean;
+        }) => Promise<import("./apiServer.js").ActivityTallyRow[]>;
+    };
+    messages: {
+        listen: (projectId: string, onEvent: (eventType: string, data: any) => void | boolean, path?: string) => import("./apiMessages.js").SSEConnection;
+        sendMessage: (projectId: string, data: any) => Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        discoverServices: (projectId: string) => Promise<import("./apiMessages.js").DiscoveredService[]>;
+        discardService: (projectId: string, serviceId: string) => Promise<void>;
+        releaseService: (projectId: string, serviceId: string) => Promise<void>;
+        serve: (projectId: string, serviceInfo: import("./apiMessages.js").ServiceInfo, onServiceRequest: (data: any, responseHelper: import("./apiMessages.js").ResponseHelper) => void, extras?: any, onStatus?: (event: import("./apiMessages.js").ServiceStatusEvent, projectId: string, detail?: string) => void) => import("./apiMessages.js").ServiceRegistration;
+        requestService: (projectId: string, serviceId: string, data: any, timeout?: number, onProgress?: Function, signal?: AbortSignal, opts?: {
+            requestId?: string;
+            onAccepted?: (requestId: string) => void;
+            projectIds?: string[];
+            noOperation?: boolean;
+        }) => Promise<any>;
+        attachServiceRequest: (projectId: string, requestId: string, timeout?: number, onProgress?: Function, signal?: AbortSignal) => Promise<any>;
+        cancelServiceRequest: (projectId: string, requestId: string) => Promise<void>;
+    };
+    /**
+     * Run a query over every project you can read.
+     *
+     * `body` is the query AST. Its keys follow the usual client convention
+     * (camelCase, e.g. `scope.projectIds`) and are converted to the wire
+     * format automatically; clause heads and variables are plain strings you
+     * write literally (e.g. `'span'`, `'?s1'`, `'vocab-link'`). Example:
+     *
+     *   await client.query({
+     *     find: ['?s1', '?s2'],
+     *     where: [
+     *       ['span', '?s1', { layer: posLayerId, value: 'NOUN' }],
+     *       ['span', '?s2', { layer: posLayerId, value: 'VERB' }],
+     *       ['covers', '?s1', '?t1'], ['covers', '?s2', '?t2'],
+     *       ['precedes', '?t1', '?t2'],
+     *     ],
+     *     return: 'entities',   // 'ids' (default) | 'entities' | 'count'
+     *     limit: 100,
+     *   });
+     *
+     * A `layer` is referenced by its id (its UUID) only — not by name or
+     * path. To match a layer by name, bind it with a `*-layer` clause (e.g.
+     * `['span-layer', '?sl', { name: 'pos' }]`) and use the variable.
+     *
+     * A vocab link's provenance is on the link itself: bind it as a `link`
+     * entity to filter or group by it, e.g. the machine-made links nobody
+     * confirmed, with the tokens they sit on:
+     *
+     *   ['link', '?l', { metadata: { prov: 'inferred' } }],
+     *   ['not', ['link', '?l', { metadata: { provConfirmed: true } }]],
+     *   ['link-token', '?l', '?t'], ['link-item', '?l', '?v']
+     *
+     * Optional keys: `scope` (restrict to projects by id, `{projectIds}`), `orderBy`
+     * (sort rows), and `bindings` (substitute `?name` placeholders with literals).
+     * `return` may also be an aggregate spec `{group, aggregates}`. See the query
+     * language reference.
+     *
+     * @param {Object} body - The query AST ({find, where, scope?, limit?, orderBy?,
+     *   return?, bindings?}).
+     * @returns {Promise<QueryResult>} For 'ids'/'entities': {columns, results, count, truncated}.
+     *   For 'count': {return: 'count', count, truncated}, where `truncated` says
+     *   the count stopped at the server's cap. Entity cells are full entity
+     *   objects (same shape as the GET endpoints).
+     */
+    query: (body: any) => Promise<QueryResult>;
+    /** @private */
+    private _request;
+    /**
+     * Enter strict mode for a specific document, requiring document version
+     * headers so that conflicting concurrent writes are rejected.
+     * @param {string} documentId - The ID of the document to track versions for
+     */
+    enterStrictMode(documentId: string): void;
+    /** Exit strict mode and stop tracking document versions for writes. */
+    exitStrictMode(): void;
+    /**
+     * Begin a LOGICAL OPERATION: a user-meaningful action ("Merge morphemes",
+     * "Re-transcribe") implemented as many low-level writes, possibly across
+     * several batches and even a service round-trip. Until `endOperation()`,
+     * every write is stamped with a client-minted `?group-id=` (and the message)
+     * so the audit log shows the whole run as ONE expandable entry labeled
+     * `message`, with each write's own description underneath.
+     *
+     * Grouping is orthogonal to batches: a batch is a transaction boundary, an
+     * operation is an intent boundary. An operation is NOT atomic — if write 3
+     * of 5 fails, writes 1–2 stay committed (and logged under the group). Use a
+     * batch inside the operation for any step that must be all-or-nothing.
+     *
+     * Nesting flattens: a `beginOperation` while one is open is a no-op that
+     * joins the outer operation (the outer label wins), and the matching
+     * `endOperation` is likewise a no-op. The label is recorded on the FIRST
+     * write, so an operation that is never ended (crash, closed tab) is still
+     * labeled in the log.
+     *
+     * "Every write" is the writes of project data. Reads never join, and neither
+     * do the out-of-band signals shaped like a write (a document lock taken or
+     * renewed, a stopped service request, a service reporting itself, an admin
+     * control), and neither does a broadcast message (`messages.sendMessage`):
+     * none of them is audited, so there would be nothing under the label.
+     *
+     * `kind` says what kind of operation this is, for a program reading the
+     * log: one of `assistant-plan`, `service-run`, `import`, `bulk-edit`,
+     * `guess-adoption`, `repair` or `review` (the server refuses any other).
+     * Any other kind throws here, before anything is written.
+     * `ref` is a short string naming what the operation came from, in the
+     * shape its kind documents (the core manual, "Kinds of operation"). Both
+     * are recorded from the first write like the label, and a nested operation
+     * keeps the outer one's.
+     *
+     * `keys` (from `keySeed()`) makes a run of the operation send the same
+     * requests as an earlier run with the same keys: the nth keyed request that
+     * joins it takes the Idempotency-Key `<seed>.<n>` and the document-version
+     * its first run claimed, so a request that landed is answered from its
+     * first send and writes nothing again. The count starts at 0 at each
+     * outermost begin. A nested operation joins the outer one's keys, unless it
+     * brings its own: then it numbers from 0 under its own seed until its
+     * matching end, and the outer numbering resumes after it.
+     *
+     * @param {string} message - Human label for the operation.
+     * @param {{groupId?: string, kind?: OperationKind, ref?: string, keys?: KeySeed, minted?: Iterable<string>}} [opts] - Optional `{ groupId, kind, ref, keys, minted }`. `groupId` adopts an existing group id instead of minting one (a service joining the requester's operation; `requestService` propagates an open operation to the service automatically). Python's is `group_id`. `kind`, `ref` and `keys` are described above. `minted` is the ids the operation mints for what it creates: a create refused 409 id-taken for one of them was made by an earlier send of the operation, and answers as made.
+     * @returns {string} The operation's group id.
+     */
+    beginOperation(message: string, { groupId, kind, ref, keys, minted }?: {
+        groupId?: string;
+        kind?: OperationKind;
+        ref?: string;
+        keys?: KeySeed;
+        minted?: Iterable<string>;
+    }): string;
+    /**
+     * A seed for the Idempotency-Keys of a logical operation that may be run
+     * again from the top (see beginOperation's `keys`). Keep it with the work
+     * it belongs to and pass it to every run.
+     * @returns {KeySeed}
+     */
+    keySeed(): KeySeed;
+    /**
+     * End the current logical operation. With no argument this is purely local
+     * (no request). Pass a refined `message` to relabel the group now that the
+     * outcome is known (e.g. `endOperation('Merged 3 morphemes')`) — that sends
+     * one PATCH, skipped if the operation never wrote anything. A refine from a
+     * nested (flattened) `endOperation` is ignored; the outer label wins.
+     * @param {string} [message] - Optional refined label.
+     * @returns {Promise<void>}
+     */
+    endOperation(message?: string): Promise<void>;
+    /**
+     * Run `fn` as one logical operation (see beginOperation), ending it when
+     * `fn` settles — including on throw. `fn` receives a `setMessage(msg)`
+     * callback to refine the label once the outcome is known.
+     *
+     *   await client.withOperation('Merge morphemes', async (setMessage) => {
+     *     await client.batched(async (b) => { ... });
+     *     setMessage(`Merged ${n} morphemes`);
+     *   });
+     *
+     * The kind and reference (see beginOperation) come after `fn`:
+     *
+     *   await client.withOperation('Import ELAN corpus', run, { kind: 'import', ref: 'format:elan' });
+     *
+     * @template T
+     * @param {string} message - Human label for the operation.
+     * @param {(setMessage: (msg: string) => void) => T | Promise<T>} fn - The work to run; receives `setMessage(msg)` to refine the label once the outcome is known.
+     * @param {{kind?: OperationKind, ref?: string, groupId?: string, keys?: KeySeed, minted?: Iterable<string>}} [opts] - Optional `{ kind, ref, groupId, keys, minted }`, as for beginOperation. `kind` is one of `assistant-plan`, `service-run`, `import`, `bulk-edit`, `guess-adoption`, `repair` or `review`, and any other throws before `fn` runs.
+     * @returns {Promise<T>} Whatever `fn` resolves to.
+     */
+    withOperation<T>(message: string, fn: (setMessage: (msg: string) => void) => T | Promise<T>, { kind, ref, groupId, keys, minted }?: {
+        kind?: OperationKind;
+        ref?: string;
+        groupId?: string;
+        keys?: KeySeed;
+        minted?: Iterable<string>;
+    }): Promise<T>;
+    /**
+     * Open a batch: a view of this client with the same bundles, on which every
+     * write of project data queues instead of going out. `submit()` sends the
+     * queued operations as ONE atomic request (larger than the server's cap,
+     * as consecutive requests with the results concatenated in queue order,
+     * each atomic on its own, so a failure in a later one leaves the earlier
+     * ones committed, and the error it throws carries `committed`, the count
+     * saved, and `committedResults`, their results) and
+     * resolves to one result per operation; `abort()` drops them. A call made
+     * on the client itself is never touched by an open batch, and a read or an
+     * out-of-band signal made on the batch goes over the wire now (see the note
+     * at the top of `http.js`).
+     *
+     *   const b = client.batch();
+     *   b.tokens.bulkCreate(sentenceOps);
+     *   b.tokens.bulkCreate(wordOps);
+     *   const [sentRes, wordRes] = await b.submit();
+     *
+     * Server-side a batch runs sequentially in one transaction: a child op sees
+     * parents created earlier in the same batch, and any op's failure rolls the
+     * whole batch back. A batch is not nestable. Prefer `batched()`, which
+     * submits or aborts for you.
+     *
+     * `timeout` (ms, or null for none) is how long each of this batch's
+     * requests may wait for its answer, in place of the client's
+     * `batchTimeout`, for this batch alone.
+     * @param {{timeout?: number | null}} [options]
+     * @returns {PlaidBatch} the batch view
+     */
+    batch({ timeout }?: {
+        timeout?: number | null;
+    }): PlaidBatch;
+    /**
+     * POST one batch request (at most MAX_BATCH_OPS operations). Resolves to
+     * one `{ status, headers, body }` per operation, with only the body
+     * recased: the headers keep the server's spelling. `key` is the request's
+     * Idempotency-Key: a batch whose answer is lost (no response, 502, 504) is
+     * sent again under it, and answered from the first send if that landed.
+     * `timeout` is this request's, in place of `batchTimeout` when given.
+     * See postBatch in http.js.
+     * @param {string} url
+     * @param {object[]} body
+     * @param {{key?: string, timeout?: number | null}} [options]
+     * @private
+     */
+    private _postBatch;
+    /**
+     * Run `fn` with a batch, then submit all queued ops as `submit()` does (ONE
+     * atomic request up to MAX_BATCH_OPS operations, consecutive requests past
+     * it), or abort the batch if `fn` throws. `fn` receives the batch and makes its
+     * writes on it; it must NOT call `submit()` itself. Resolves to the batch
+     * results array (`[]` if `fn` queued nothing).
+     *
+     *   const [sentRes, wordRes] = await client.batched(async (b) => {
+     *     b.tokens.bulkCreate(sentenceOps);
+     *     b.tokens.bulkCreate(wordOps);
+     *   });
+     *
+     * A write made on `client` inside `fn` is not part of the batch: it goes
+     * over the wire at once, as it would anywhere else. See `batch()`, which
+     * also says what `timeout` does.
+     * @param {(batch: PlaidBatch) => (void | Promise<void>)} fn
+     * @param {{timeout?: number | null}} [options]
+     * @returns {Promise<any[]>}
+     */
+    batched(fn: (batch: PlaidBatch) => (void | Promise<void>), { timeout }?: {
+        timeout?: number | null;
+    }): Promise<any[]>;
+}