@knkcs/contenthub-ui 0.0.0-stage → 0.1.0

package/dist/testing.d.ts

@@ -0,0 +1,1555 @@
+import { HostIdentity } from '@knkcs/anker/host';
+
+/**
+ * One of a workspace's own reasons a Content may be blocked, such as "being
+ * revised by the author" (CONTEXT.md, Block Reason). Configuration, not
+ * versioned.
+ */
+declare interface BlockReason {
+    id: string;
+    name: string;
+    /** ISO 8601. */
+    createTime: string;
+    /** ISO 8601. */
+    updateTime: string;
+}
+
+/** A content Blueprint, as the `BlueprintSource` port names it. */
+declare interface BlueprintInfo {
+    id: string;
+    /** What editors call it. */
+    name: string;
+}
+
+/** One page of `BlueprintSource.searchBlueprints`. */
+declare interface BlueprintPage {
+    blueprints: BlueprintInfo[];
+    /** Empty on the last page. */
+    nextPageToken: string;
+}
+
+/** A Release of a content Blueprint: what a new Content pins. */
+declare interface BlueprintReleaseInfo {
+    id: string;
+    blueprintId: string;
+    /** The name given when it was cut, such as "2026-10". */
+    name: string;
+    /** ISO 8601: when it was cut. */
+    releaseTime: string;
+}
+
+/**
+ * The port a host fills with blueprinthub (ADR 0020): the workspace's
+ * content Blueprints and their Releases, for New Content and the Library's
+ * Blueprint filter. contenthub-ui depends on no blueprinthub package. A host
+ * without blueprinthub leaves the port empty: the Library then names
+ * Blueprints by id, offers no Blueprint filter and cannot create Content.
+ */
+declare interface BlueprintSource {
+    /**
+     * Unarchived content Blueprints whose name holds `query` (every one for
+     * ""), by name. `signal` aborts a search the user has moved on from.
+     */
+    searchBlueprints(input: {
+        query: string;
+        pageToken?: string;
+        signal?: AbortSignal;
+    }): Promise<BlueprintPage>;
+    /** The Blueprints of these ids, archived ones too; an unknown id is left out. */
+    getBlueprints(ids: string[]): Promise<BlueprintInfo[]>;
+    /** Every Release of a Blueprint, newest first; empty while none has been cut. */
+    listReleases(blueprintId: string): Promise<BlueprintReleaseInfo[]>;
+}
+
+/** What a Branch is for: one an editor works on, or a Carry-forward link. */
+declare type BranchKind = "editorial" | "carry_forward";
+
+/** What a Chain on Dated Content, effective on a date, would be and meet (PreviewChain). */
+declare interface ChainPreview {
+    /** The Release it would fork from; "" in a gap. */
+    forkReleaseId: string;
+    /** The later Releases it would carry forward through. */
+    carryForwardReleaseIds: string[];
+    /** Whether a final link would merge Main's head. */
+    mergesMain: boolean;
+    /** The Releases the period cuts into. */
+    cutIntoReleaseIds: string[];
+    /** The Releases the period covers entirely: planning it as it is would be refused. */
+    coveredReleaseIds: string[];
+}
+
+/** A Change Set as editors see it (CONTEXT.md, Change Set). */
+declare interface ChangeSet {
+    id: string;
+    name: string;
+    /** Absent when it records none, as a one-off correction does. */
+    source?: ChangeSetSource;
+    state: ChangeSetState;
+    /** Who opened it: an odon user id. */
+    createdBy: string;
+    /** ISO 8601. */
+    createTime: string;
+    /** ISO 8601; absent while it is open. */
+    closeTime?: string;
+    /** In the order they were started. Empty in a list. */
+    chains: ChangeSetChain[];
+    /** The Change Sets it depends on, whatever their state. Empty in a list. */
+    dependsOnChangeSetIds: string[];
+    /**
+     * The slug of its status in statushub's `contenthub/change_set`
+     * catalogue; "" for an unknown status, which it has until someone first
+     * sets one. Frozen once it is closed.
+     */
+    status: string;
+    /** Who is working on it now: odon user ids, in the order they were set. */
+    assigneeIds: string[];
+    /**
+     * Its Planned Releases, proposed ones included, in the order they were
+     * planned. Empty in a list.
+     */
+    plannedReleases: PlannedRelease[];
+}
+
+/** One Branch of a Chain, with the head a save on it names. */
+declare interface ChangeSetBranch {
+    id: string;
+    /** Its place in its Chain, from 0. */
+    position: number;
+    kind: BranchKind;
+    headRevisionId: string;
+    /**
+     * On a Chain on Dated Content, the date its change takes effect
+     * (YYYY-MM-DD): an editorial Branch's own, or the first day of the
+     * Release a Carry-forward link carries. Absent or "" otherwise.
+     */
+    effectiveOn?: string;
+    /**
+     * The Release it carries: the first Branch's fork Release, or the later
+     * Release a Carry-forward link carries. Absent or "" where it carries
+     * Main's head or nothing.
+     */
+    carriedReleaseId?: string;
+    /** Whether a Pending Merge is stored on it, which `getPendingMerge` reads. */
+    hasPendingMerge?: boolean;
+}
+
+/** The ordered Branches of one Content inside a Change Set. */
+declare interface ChangeSetChain {
+    id: string;
+    contentId: string;
+    /** Born in this Change Set: it has no Main Branch until it is published. */
+    born: boolean;
+    /** By position. */
+    branches: ChangeSetBranch[];
+}
+
+/** One page of `listChangeSets`. */
+declare interface ChangeSetList {
+    changeSets: ChangeSet[];
+    /** Empty on the last page. */
+    nextPageToken: string;
+}
+
+/**
+ * The publication that triggered a Change Set (CONTEXT.md, Source), such as
+ * 2026-09-20, "BGBl. 2026 I Nr. 270".
+ */
+declare interface ChangeSetSource {
+    /** The day it was published, as YYYY-MM-DD. */
+    date: string;
+    /** How it is cited: one line, at most 500 characters. */
+    reference: string;
+}
+
+/** Where a Change Set is in its life: open, then published or discarded for good. */
+declare type ChangeSetState = "open" | "published" | "discarded";
+
+/**
+ * A status of statushub's `contenthub/change_set` catalogue, as a label to
+ * show: what the `StatusSource` port answers.
+ */
+declare interface ChangeSetStatusInfo {
+    slug: string;
+    /** Its display name, in the workspace's words. */
+    name: string;
+    /** Its colour as statushub holds it (a CSS colour); absent for none. */
+    color?: string;
+}
+
+/** What `updateChangeSet` changes of a Change Set. */
+declare type ChangeSetUpdateField = "name" | "source";
+
+/** What a Check Result says. */
+declare type CheckOutcome = "passed" | "failed" | "waived";
+
+/** One recorded outcome of a Required Check, against the heads it saw. */
+declare interface CheckResult {
+    id: string;
+    requiredCheckId: string;
+    heads: Record<string, string>;
+    outcome: CheckOutcome;
+    /** Why, for a waiver; optional otherwise. */
+    note: string;
+    /** Who recorded it: a person, or a flow's Run-as user. */
+    recordedBy: string;
+    /** ISO 8601. */
+    recordTime: string;
+}
+
+/** Whether a Required Check gates each Branch, or the Change Set once (ADR 0014). */
+declare type CheckScope = "branch" | "change_set";
+
+/**
+ * Where one Required Check stands on one thing it applies to: a Branch or a
+ * Branch-less Planned Release for Branch scope, the whole Change Set for
+ * Change Set scope.
+ */
+declare interface CheckStanding {
+    check: RequiredCheck;
+    /** For Branch scope, its Content; "" for Change Set scope. */
+    contentId: string;
+    /** For Branch scope, the Branch, or the Branch-less Planned Release; "" otherwise. */
+    branchId: string;
+    releaseId: string;
+    /** What a result recorded now names. */
+    heads: Record<string, string>;
+    /** Newest first: the first is the latest, the one that counts. */
+    results: CheckResult[];
+    /** The latest result names other heads: a save since made it count for nothing. */
+    stale: boolean;
+    /** The latest result is passed or waived, and not stale. */
+    cleared: boolean;
+}
+
+/**
+ * A node of the workspace's tree for filing Content (CONTEXT.md,
+ * Collection). Filing is not a save and is not versioned.
+ */
+declare interface Collection {
+    id: string;
+    name: string;
+    /** The Collection it sits in; "" at the root. */
+    parentId: string;
+    /** A Restricted Collection, visible only to those granted on it (ADR 0017). */
+    restricted: boolean;
+}
+
+/**
+ * A level of access to a Restricted Collection (ADR 0017): `viewer` sees the
+ * Content filed in it, `editor` also saves and files it, and `owner`, given to
+ * whoever restricted it and never granted, also manages the grants.
+ */
+declare type CollectionAccessLevel = "viewer" | "editor" | "owner";
+
+/** One person's access to a Restricted Collection. */
+declare interface CollectionGrant {
+    userId: string;
+    level: CollectionAccessLevel;
+}
+
+/** What a Revision is compared against. */
+declare type CompareBase = {
+    kind: "revision";
+    revisionId: string;
+} | {
+    kind: "fork";
+    branchId: string;
+} | {
+    kind: "main_head";
+};
+
+/** One Content as a read found it: at a Main head, a Branch head or a Release. */
+declare interface Content {
+    id: string;
+    /** The Blueprint, and the Blueprint Release its Revision pins. */
+    blueprintId: string;
+    blueprintReleaseId: string;
+    /** The Revision read. */
+    revisionId: string;
+    /** Its data, keyed by field accessor. */
+    data: Record<string, unknown>;
+    /**
+     * The Change Set and Branch it was read on; "" when read on Main or at a
+     * Release. A search on Main finds Branch heads too, so a Main list can
+     * hold rows read in a Change Set.
+     */
+    changeSetId: string;
+    branchId: string;
+    /** ISO 8601: when the Revision was written. */
+    revisionCreateTime: string;
+    /** The Release it was read at, in the In Force view; "" elsewhere. */
+    releaseId: string;
+}
+
+/**
+ * A Content's unversioned attributes (ADR 0015): the same wherever it is
+ * read, and never part of a Revision or a Release.
+ */
+declare interface ContentAttributes {
+    /** The Collections it is filed in, by id. */
+    collectionIds: string[];
+    /** Who maintains it: odon user ids, in the order they were set. */
+    assigneeIds: string[];
+    /** Absent while it is not blocked. */
+    block?: ContentBlock;
+    /** When it was archived, ISO 8601; absent while it is not Archived. */
+    archiveTime?: string;
+}
+
+/**
+ * A Content's Block (CONTEXT.md, Block): editing is closed to all but
+ * `allowedUserIds` until it is lifted. A Block controls editing, not seeing.
+ */
+declare interface ContentBlock {
+    blockReasonId: string;
+    /** Who may still edit it: odon user ids; empty is nobody. */
+    allowedUserIds: string[];
+    /** The odon user who set it. */
+    blockedBy: string;
+    /** ISO 8601. */
+    blockTime: string;
+}
+
+/** One Content as `getContent` reads it, with its Blueprint Release and attributes. */
+declare interface ContentDetail {
+    content: Content;
+    /** Absent when this build can't read the Resolved Release. */
+    blueprintRelease?: ResolvedBlueprintRelease;
+    attributes: ContentAttributes;
+}
+
+/**
+ * Everything contenthub-ui's screens ask contenthub, and nothing else: the
+ * port a host fills (ADR 0020). `createConnectContenthubClient` is the
+ * production implementation; `@knkcs/contenthub-ui/testing` has a stub over
+ * an in-memory workspace.
+ *
+ * Errors the screens act on arrive as the typed errors below, never as a
+ * ConnectError the screen would have to pick details out of. Anything else
+ * (no permission, the service down) arrives as it came.
+ *
+ * The workspace is never an argument: contenthub reads it from the caller's
+ * token (contenthub ADR 0017), so a host cannot ask about another workspace by
+ * mistake.
+ */
+declare interface ContenthubClient {
+    /** The workspace's Block Reasons, by name. */
+    listBlockReasons(): Promise<BlockReason[]>;
+    /**
+     * Adds a Block Reason. Rejects with `BlockReasonNameTakenError` when the
+     * workspace already has one of that name, and `InvalidInputError` for a
+     * name the service refuses (blank, too long, more than one line).
+     */
+    createBlockReason(input: {
+        name: string;
+    }): Promise<BlockReason>;
+    /** Renames a Block Reason; its id stays. Rejects as `createBlockReason` does. */
+    renameBlockReason(input: {
+        id: string;
+        name: string;
+    }): Promise<BlockReason>;
+    /** Removes a Block Reason. */
+    deleteBlockReason(input: {
+        id: string;
+    }): Promise<void>;
+    /**
+     * Change Sets, newest first, without their Chains, dependencies or
+     * Planned Releases. Each filter given must hold.
+     */
+    listChangeSets(input?: {
+        state?: ChangeSetState;
+        /** Only those this odon user is assigned to. */
+        assigneeId?: string;
+        /** Only those with a Chain on this Content. */
+        contentId?: string;
+        /** At most 200; 50 when absent. */
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<ChangeSetList>;
+    /**
+     * Opens a Change Set. Rejects with `InvalidInputError` for a name or
+     * Source the service refuses.
+     */
+    createChangeSet(input: {
+        name: string;
+        source?: ChangeSetSource;
+    }): Promise<ChangeSet>;
+    /** A Change Set with its Chains, their Branches' heads and its dependencies. */
+    getChangeSet(id: string): Promise<ChangeSet>;
+    /**
+     * Renames an open Change Set and corrects its Source, as `updateMask`
+     * says: a field it doesn't name is left as it is, and a masked `source`
+     * that is absent clears the Source. Rejects with `InvalidInputError` for
+     * a name or Source the service refuses, and `ChangeSetClosedError` once
+     * it is published or discarded: the Source freezes at Publish.
+     */
+    updateChangeSet(input: {
+        id: string;
+        updateMask: ChangeSetUpdateField[];
+        name?: string;
+        source?: ChangeSetSource;
+        /** Makes a retry safe (CONTEXT.md, Idempotency Key). */
+        idempotencyKey?: string;
+    }): Promise<ChangeSet>;
+    /**
+     * Moves the status label from `expectedStatus` (the status the caller
+     * saw, "" for none) to `status`. Rejects with
+     * `StatusTransitionRefusedError` when statushub refuses the move,
+     * `StaleStatusError` when the status moved meanwhile,
+     * `ChangeSetClosedError` when the Change Set is published or discarded,
+     * and `ServiceUnavailableError` while statushub can't be reached.
+     */
+    setChangeSetStatus(input: {
+        id: string;
+        expectedStatus: string;
+        status: string;
+    }): Promise<ChangeSet>;
+    /** Replaces who is working on it: the whole new set of odon user ids. */
+    setChangeSetAssignees(input: {
+        id: string;
+        assigneeIds: string[];
+    }): Promise<ChangeSet>;
+    /**
+     * Makes the Change Set depend on another open one. Rejects with
+     * `InvalidInputError` for one that would close a cycle or is closed, and
+     * `ChangeSetClosedError` when this Change Set itself is closed.
+     */
+    addDependency(input: {
+        id: string;
+        dependsOnId: string;
+    }): Promise<ChangeSet>;
+    /** Undoes `addDependency` while the Change Set is open. */
+    removeDependency(input: {
+        id: string;
+        dependsOnId: string;
+    }): Promise<ChangeSet>;
+    /**
+     * Publish's dry run with `reviewedHeads` (Branch id to head Revision id):
+     * every blocker a Publish with them would be refused with now, and the
+     * Releases it would cut. Writes nothing. Rejects with `WithheldWorkError`
+     * when Publish would, for a caller who can't see all of the Change Set.
+     */
+    validatePublish(input: {
+        id: string;
+        reviewedHeads: Record<string, string>;
+    }): Promise<PublishReview>;
+    /**
+     * Publishes the Change Set with exactly `reviewedHeads`: every Branch at
+     * the head the caller reviewed. Rejects with `PublishRefusedError`
+     * carrying every blocker when it is refused, `ChangeSetClosedError`
+     * when it is closed (published with other heads, or discarded), and
+     * `WithheldWorkError` when it holds work the caller can't see.
+     */
+    publish(input: {
+        id: string;
+        reviewedHeads: Record<string, string>;
+    }): Promise<PublishOutcome>;
+    /**
+     * Merges what Main (and each dependency) gained since into every Chain
+     * of the Change Set. A Branch whose merge has Conflicts, or fails its
+     * Blueprint Release, is left with a Pending Merge, which the Branch
+     * editor resolves. Rejects with `ChangeSetClosedError` when it is closed,
+     * and, without `chainId`, `WithheldWorkError` when it holds work the
+     * caller can't see.
+     */
+    updateFromMain(input: {
+        id: string;
+        /** One of its Chains to update alone; every Chain when absent. */
+        chainId?: string;
+        /** Makes a retry safe (CONTEXT.md, Idempotency Key). */
+        idempotencyKey?: string;
+    }): Promise<UpdateFromMainOutcome>;
+    /**
+     * Closes the Change Set for good without publishing it. Rejects with
+     * `ChangeSetClosedError` when it is closed already, and
+     * `WithheldWorkError` when it holds work the caller can't see.
+     */
+    discardChangeSet(id: string): Promise<ChangeSet>;
+    /**
+     * Where every Required Check that applies to the Change Set stands: the
+     * heads a result recorded now names, its results newest first, and
+     * whether the latest is stale or clears it.
+     */
+    listCheckResults(changeSetId: string): Promise<CheckStanding[]>;
+    /**
+     * Records a Check Result against `heads`, the heads the recorder saw.
+     * Rejects with `StaleHeadError` when one of them moved,
+     * `CheckResultDeniedError` when the caller may not record it (an
+     * independent check's passed or waived from an author of what it
+     * covers), `InvalidInputError` for what
+     * the service refuses (a waiver without a note), and
+     * `ChangeSetClosedError` when the Change Set is closed.
+     */
+    recordCheckResult(input: {
+        changeSetId: string;
+        requiredCheckId: string;
+        heads: Record<string, string>;
+        outcome: CheckOutcome;
+        note: string;
+    }): Promise<CheckResult>;
+    /** The workspace's Required Checks, by name. */
+    listRequiredChecks(): Promise<RequiredCheck[]>;
+    /**
+     * Declares a Required Check; it gates every open Change Set at once.
+     * Rejects with `NameTakenError` when another check has the name, and
+     * `InvalidInputError` for anything else the service refuses.
+     */
+    createRequiredCheck(input: RequiredCheckInput): Promise<RequiredCheck>;
+    /** Replaces every field of a Required Check; its id stays. Rejects as create does. */
+    updateRequiredCheck(input: RequiredCheckInput & {
+        id: string;
+    }): Promise<RequiredCheck>;
+    /**
+     * Removes a Required Check: it stops gating. Its results are kept and
+     * count for nothing; its recorders' grants go with it. Rejects with
+     * `ServiceUnavailableError` while Guardian doesn't take that, and nothing
+     * is removed.
+     */
+    deleteRequiredCheck(input: {
+        id: string;
+    }): Promise<void>;
+    /**
+     * Who records a Required Check: every member until an admin narrows it
+     * (ADR 0017's 2026-10-03 amendment). Admin only: rejects with
+     * `AccessDeniedError` otherwise, and with `GuardianModeRequiredError` in
+     * `authz.mode: workspace`, where every member records every check and
+     * nothing narrows it.
+     */
+    listRequiredCheckRecorders(requiredCheckId: string): Promise<RequiredCheckRecorders>;
+    /**
+     * Makes a member, or every member, a recorder of a Required Check. The
+     * caller may grant themselves: an admin records a check only when
+     * granted (break-glass, announced like any grant). Rejects as
+     * `listRequiredCheckRecorders` does, with `InvalidInputError` for a
+     * grantee who is not a member, and `ServiceUnavailableError` while
+     * Guardian doesn't take the grant.
+     */
+    grantRequiredCheckRecorder(input: {
+        requiredCheckId: string;
+        recorder: RecorderGrant;
+    }): Promise<void>;
+    /**
+     * Takes recorder from a person, or from every member, which narrows the
+     * check to the people granted by name. Rejects as grant does.
+     */
+    revokeRequiredCheckRecorder(input: {
+        requiredCheckId: string;
+        recorder: RecorderGrant;
+    }): Promise<void>;
+    /** Every Collection of the workspace, by name, then id: a tree by `parentId`. */
+    listCollections(): Promise<Collection[]>;
+    /**
+     * Creates a Collection at the root or under `parentId`. Rejects with
+     * `NameTakenError` for a sibling of the same name, `InvalidInputError` for
+     * a name the service refuses, and `RestrictionUnavailableError` for a
+     * restricted one in workspace mode.
+     */
+    createCollection(input: {
+        name: string;
+        parentId?: string;
+        restricted?: boolean;
+    }): Promise<Collection>;
+    /** Renames a Collection, keeping its place and filing. Rejects as create does. */
+    renameCollection(input: {
+        id: string;
+        name: string;
+    }): Promise<Collection>;
+    /**
+     * Moves a Collection, with everything under it, under `parentId` ("" for
+     * the root). Rejects with `InvalidInputError` for a move under itself, and
+     * `NameTakenError` for a sibling of the same name there, whose
+     * `takenName` is "": the request carries no name.
+     */
+    moveCollection(input: {
+        id: string;
+        parentId: string;
+    }): Promise<Collection>;
+    /**
+     * Removes a Collection and unfiles its Content, answering the Content it
+     * unfiled. Rejects with `InvalidInputError` while Collections sit under it.
+     */
+    removeCollection(input: {
+        id: string;
+    }): Promise<string[]>;
+    /**
+     * Restricts a Collection (the caller becomes its owner), or opens it
+     * again, which discloses its Content to every viewer and so needs
+     * `acknowledgeDisclosure`; opening it clears its grants. Rejects with
+     * `RestrictionUnavailableError` in workspace mode, and
+     * `InvalidInputError` for an unacknowledged disclosure.
+     */
+    setCollectionRestricted(input: {
+        id: string;
+        restricted: boolean;
+        acknowledgeDisclosure?: boolean;
+    }): Promise<Collection>;
+    /**
+     * Who is granted on a Restricted Collection, its owner included. Rejects
+     * with `AccessDeniedError` unless the caller is its owner or an admin, and
+     * `RestrictionUnavailableError` in workspace mode.
+     */
+    listCollectionGrants(collectionId: string): Promise<CollectionGrant[]>;
+    /**
+     * Grants a member viewer or editor on a Restricted Collection, replacing
+     * what they held. The caller may grant themselves (break-glass, announced
+     * like any grant). Rejects as `listCollectionGrants` does, and with
+     * `InvalidInputError` for a grantee who is not a member or an open
+     * Collection.
+     */
+    grantCollectionAccess(input: {
+        collectionId: string;
+        userId: string;
+        level: "viewer" | "editor";
+    }): Promise<void>;
+    /** Takes a person's grant on a Restricted Collection. Rejects as grant does. */
+    revokeCollectionAccess(input: {
+        collectionId: string;
+        userId: string;
+    }): Promise<void>;
+    /**
+     * Content in one view, ordered by id (then Branch, for a search), each
+     * filter given holding. Rejects with `InvalidInputError` for a search in
+     * the In Force view, which Editor Search never covers (ADR 0019), and for
+     * a search the service refuses.
+     */
+    listContents(input?: {
+        /** Main when absent. */
+        view?: ContentView;
+        /**
+         * Only Content filed directly in this Collection, not in Collections
+         * under it.
+         */
+        collectionId?: string;
+        /** Editor Search: a name, number or phrase, letter for letter but ignoring case. */
+        search?: string;
+        /**
+         * Only Content of one of these Blueprints, filtered by the service so
+         * that every page but the last is full; empty or absent for every
+         * Blueprint. At most 100.
+         */
+        blueprintIds?: string[];
+        /** Only Content this user maintains: one of its assignees. */
+        assigneeId?: string;
+        /** At most 200; 50 when absent. */
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<ContentList>;
+    /**
+     * Creates a Content in an open Change Set, pinning a Blueprint Release,
+     * with empty data: its one Chain has one Branch, opened in the Branch
+     * editor. Rejects with `ChangeSetClosedError` for a closed Change Set,
+     * `ContentRefusedError` for a Release contenthub can't load or empty data
+     * the Release refuses (a required field), and `InvalidInputError` for
+     * anything else the service refuses.
+     */
+    createContent(input: {
+        changeSetId: string;
+        /** May be "" with `copyFrom`, to pin what the source pins. */
+        blueprintReleaseId: string;
+        /** Duplicate: the new Content's first Revision takes this source's data. */
+        copyFrom?: CopyFrom;
+    }): Promise<Content>;
+    /**
+     * Saves a new Revision on a Branch of an open Change Set, on top of
+     * `expectedHeadId`, the head the editor loaded (ADR 0003). With
+     * `fieldMask` the save is partial: each top-level field it names takes
+     * its value in `data`, or is removed when `data` doesn't hold it, and
+     * every other field is carried over from the head. Answers the Content
+     * as read in the Change Set afterwards.
+     *
+     * Rejects with `StaleHeadError` when the head moved (nothing is written,
+     * and nothing is merged: ADR 0020), `ContentRefusedError` with one reason
+     * per Violation the data breaks, `ContentBlockedError` or
+     * `ContentArchivedError` for Content closed to the caller,
+     * `ChangeSetClosedError` for a closed Change Set, and `InvalidInputError`
+     * for anything else the service refuses.
+     */
+    saveRevision(input: {
+        /** The Branch's Change Set, which a closed refusal names. */
+        changeSetId: string;
+        branchId: string;
+        expectedHeadId: string;
+        data: Record<string, unknown>;
+        /** Top-level field accessors; absent saves `data` as the whole Revision. */
+        fieldMask?: string[];
+        /**
+         * Makes a retry safe (CONTEXT.md, Idempotency Key): sent again with
+         * the same request, it answers the first save and writes nothing.
+         */
+        idempotencyKey?: string;
+    }): Promise<Content>;
+    /**
+     * One Content with its Blueprint Release and attributes: on Main, or
+     * inside `changeSetId`. Content born in an open Change Set exists only
+     * there, so read anywhere else it is a NotFound ConnectError.
+     */
+    getContent(input: {
+        id: string;
+        changeSetId?: string;
+    }): Promise<ContentDetail>;
+    /** Its Timeline, with the Planned Releases of open Change Sets beside it. */
+    getTimeline(contentId: string): Promise<ContentTimeline>;
+    /**
+     * Revisions, newest first: every one of a published Content, or those of
+     * one Branch (the only way to list those of Content born in an open
+     * Change Set).
+     */
+    listRevisions(input: {
+        target: {
+            contentId: string;
+        } | {
+            branchId: string;
+        };
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<RevisionList>;
+    /** How `revisionId` differs from a base, field by field. */
+    compare(input: {
+        revisionId: string;
+        base: CompareBase;
+    }): Promise<RevisionComparison>;
+    /** The outgoing edges of one Revision, its own only. */
+    listReferences(input: {
+        contentId: string;
+        revisionId: string;
+    }): Promise<Edge[]>;
+    /**
+     * One page of the edges pointing at a Content from Releases In Force
+     * today and, asked, open Branch heads: Releases first, then Change Sets.
+     */
+    listReferrers(input: {
+        contentId: string;
+        includeOpenChangeSets?: boolean;
+        /** 100 when absent; above 1000 reads as 1000. */
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<ReferrerList>;
+    /** The pinned edges of a Branch head or a Revision that are outdated today. */
+    listOutdatedPins(input: {
+        branchId: string;
+    } | {
+        revisionId: string;
+    }): Promise<OutdatedPin[]>;
+    /** Files a Content in exactly these Collections: no save, no Revision (ADR 0015). Answers its Collections. */
+    setContentCollections(input: {
+        contentId: string;
+        collectionIds: string[];
+    }): Promise<string[]>;
+    /** Replaces who maintains a Content: no save, no Revision. */
+    setContentAssignees(input: {
+        contentId: string;
+        assigneeIds: string[];
+    }): Promise<ContentAttributes>;
+    /** Blocks a Content, replacing any Block it has. */
+    blockContent(input: {
+        contentId: string;
+        blockReasonId: string;
+        allowedUserIds: string[];
+    }): Promise<ContentAttributes>;
+    unblockContent(contentId: string): Promise<ContentAttributes>;
+    /**
+     * Archives a published Content with no Release In Force today or later.
+     * Rejects with `InvalidInputError` for any other, with the service's reason.
+     */
+    archiveContent(contentId: string): Promise<ContentAttributes>;
+    unarchiveContent(contentId: string): Promise<ContentAttributes>;
+    /**
+     * Starts a Chain on a published Content, in `changeSetId` or in a new
+     * Change Set named `changeSetName` (after the Content when empty).
+     * Answers the Change Set and the Content as read on the Branch to edit.
+     * Rejects with `ContentBlockedError`, `ContentArchivedError`,
+     * `ChangeSetClosedError`, and `InvalidInputError` for anything else the
+     * service refuses (a missing or needless effective date).
+     */
+    startEditing(input: {
+        contentId: string;
+        changeSetId?: string;
+        /** YYYY-MM-DD: required for Dated Content, refused for undated. */
+        effectiveOn?: string;
+        changeSetName?: string;
+    }): Promise<{
+        changeSet: ChangeSet;
+        content: Content;
+    }>;
+    /** What a Chain on Dated Content, effective on a date, would fork from and meet. */
+    previewChain(input: {
+        changeSetId: string;
+        contentId: string;
+        effectiveOn: string;
+        /** The period to meet the Content's Releases with; from `effectiveOn`, open, when absent. */
+        validityPeriod?: ValidityPeriod;
+    }): Promise<ChainPreview>;
+    /**
+     * Plans the Release Publish will cut of an editorial Branch's head, with
+     * its Validity Period (required for Dated Content, refused for undated)
+     * and Release Spec values. Rejects with `ContentRefusedError` for Release
+     * Spec values the Blueprint Release refuses, `CoversReleaseError` when
+     * the period would cover a Release entirely, and as any edit does.
+     */
+    planRelease(input: {
+        changeSetId: string;
+        branchId: string;
+        validityPeriod?: ValidityPeriod;
+        releaseSpec?: Record<string, unknown>;
+        supersedesReleaseIds?: string[];
+        idempotencyKey?: string;
+    }): Promise<PlannedRelease>;
+    /**
+     * Changes a Planned Release: each part given replaces what it had, each
+     * absent keeps it. The Change Set's proposals are derived again. Rejects
+     * as `planRelease` does, and with `InvalidInputError` for a proposal.
+     */
+    updatePlannedRelease(input: {
+        changeSetId: string;
+        plannedReleaseId: string;
+        validityPeriod?: ValidityPeriod;
+        releaseSpec?: Record<string, unknown>;
+        supersedesReleaseIds?: string[];
+        idempotencyKey?: string;
+    }): Promise<PlannedRelease>;
+    /**
+     * Adds an editorial Branch to a Chain on Dated Content, for a later
+     * date. Answers the Change Set and the new Branch's id. Rejects with
+     * `InvalidInputError` for a date not after the Chain's last editorial
+     * Branch's, or a Chain without dates.
+     */
+    appendBranch(input: {
+        changeSetId: string;
+        chainId: string;
+        effectiveOn: string;
+        idempotencyKey?: string;
+    }): Promise<{
+        changeSet: ChangeSet;
+        branchId: string;
+    }>;
+    /**
+     * Removes a Chain from an open Change Set with its Planned Releases; its
+     * Revisions stay in history. Rejects with `InvalidInputError` for the
+     * Chain of Content born in the Change Set.
+     */
+    dropChain(input: {
+        changeSetId: string;
+        chainId: string;
+        idempotencyKey?: string;
+    }): Promise<ChangeSet>;
+    /** The Pending Merge on a Branch, with what its resolution decides; null for none. */
+    getPendingMerge(branchId: string): Promise<PendingMerge | null>;
+    /**
+     * Resolves the Pending Merge on a Branch field by field, as a merge
+     * Revision that becomes its head. Rejects with `StaleHeadError` when the
+     * head moved, `ContentRefusedError` when the result fails the Blueprint
+     * Release, and `InvalidInputError` for a field undecided or a Branch
+     * without a Pending Merge.
+     */
+    resolveMerge(input: {
+        changeSetId: string;
+        branchId: string;
+        expectedHeadId: string;
+        resolutions: FieldResolution[];
+        idempotencyKey?: string;
+    }): Promise<Content>;
+    /** Drops the Pending Merge on a Branch, which stays behind its base. */
+    abortMerge(input: {
+        changeSetId: string;
+        branchId: string;
+        idempotencyKey?: string;
+    }): Promise<void>;
+    /**
+     * Preview: the Content as In Force on `validOn` (today when absent) if
+     * the open Change Set were published now (ReleaseService's
+     * preview_change_set); null when nothing is In Force then.
+     */
+    previewInForce(input: {
+        contentId: string;
+        changeSetId: string;
+        validOn?: string;
+    }): Promise<PreviewedContent | null>;
+    /** Plans a Repeal of Dated Content ending on `lastDay`. */
+    planRepeal(input: {
+        changeSetId: string;
+        contentId: string;
+        lastDay: string;
+    }): Promise<PlannedEnd>;
+    /** Plans a Withdrawal of undated Content. */
+    planWithdrawal(input: {
+        changeSetId: string;
+        contentId: string;
+    }): Promise<PlannedEnd>;
+}
+
+/** One page of `listContents`. */
+declare interface ContentList {
+    contents: Content[];
+    /** Empty on the last page. */
+    nextPageToken: string;
+}
+
+/** A Content's Timeline, with what open Change Sets plan to add to it. */
+declare interface ContentTimeline {
+    entries: TimelineEntry[];
+    /** By Change Set, in the order they were planned. */
+    plannedReleases: {
+        changeSetId: string;
+        plannedRelease: PlannedRelease;
+    }[];
+}
+
+/**
+ * Where the Content Library reads each Content: on Main (what has been
+ * published, at its Main head), at its Release In Force today, or inside one
+ * Change Set (at the head of its Chain's last Branch).
+ */
+declare type ContentView = {
+    kind: "main";
+} | {
+    kind: "in_force";
+} | {
+    kind: "change_set";
+    changeSetId: string;
+};
+
+/** What a new Content copies (`createContent`'s copy_from). */
+declare type CopyFrom = {
+    revisionId: string;
+} | {
+    releaseId: string;
+};
+
+export declare function createStubBlueprintSource(blueprints?: BlueprintInfo[], releases?: BlueprintReleaseInfo[]): BlueprintSource;
+
+export declare function createStubContenthubClient(options?: StubContenthubClientOptions): ContenthubClient;
+
+export declare function createStubStatusSource(statuses?: ChangeSetStatusInfo[]): StatusSource;
+
+/** One edge of one Revision. */
+declare interface Edge {
+    sourceContentId: string;
+    sourceRevisionId: string;
+    /** fieldkit's Path of the value it comes from; "" for the Blueprint edge. */
+    path: string;
+    kind: EdgeKind;
+    /** Exactly one of the three targets is set. */
+    targetContentId: string;
+    targetAssetId: string;
+    targetBlueprintReleaseId: string;
+    /** The Release the edge is pinned to; "" when it follows the Release In Force. */
+    pinReleaseId: string;
+}
+
+/** What kind of edge of the Content Graph (ADR 0009). */
+declare type EdgeKind = "reference" | "toc" | "include" | "exclude" | "replace" | "annotate" | "link" | "footnote" | "anchor" | "media" | "blueprint" | "unspecified";
+
+/** One field that differs between two Revisions. */
+declare interface FieldChange {
+    /** "/" and the field's accessor. */
+    path: string;
+    kind: "added" | "removed" | "changed";
+    /** Absent on the side that doesn't hold the field. */
+    before?: unknown;
+    after?: unknown;
+}
+
+/** One decision of a merge resolution: a side's value, or the editor's own. */
+declare type FieldResolution = {
+    path: string;
+    side: "ours" | "theirs";
+} | {
+    path: string;
+    value: unknown;
+};
+
+/** An unpinned edge a Repeal or Withdrawal will leave pointing at a gap. */
+declare interface GapReferrer {
+    edge: Edge;
+    /** The Release holding the edge. */
+    releaseId: string;
+}
+
+/** One field a merge resolution must decide, with each side's value. */
+declare interface MergeField {
+    /** "/" and the field's accessor, as a Violation spells it. */
+    path: string;
+    /** Where within the field it stopped. */
+    conflictPaths: string[];
+    /** The field's value in base, ours (the Branch's head) and theirs; absent on a side without it. */
+    base?: unknown;
+    ours?: unknown;
+    theirs?: unknown;
+}
+
+/** A pinned edge whose Release is superseded, or is not the one In Force today. */
+declare interface OutdatedPin {
+    edge: Edge;
+    /** "" if none. */
+    supersededByReleaseId: string;
+    /** The target's Release In Force today; "" in a gap. */
+    inForceReleaseId: string;
+}
+
+/**
+ * A merge on a Branch that stopped (CONTEXT.md, Conflict), with what its
+ * resolution decides: saves on the Branch and Publish wait until it is
+ * resolved or aborted.
+ */
+declare interface PendingMerge {
+    branchId: string;
+    contentId: string;
+    reason: PendingMergeReason;
+    /** The Branch's head, which a resolution names as the head it built on. */
+    oursRevisionId: string;
+    /** What the Branch was merging. */
+    theirsRevisionId: string;
+    /** Whether theirs is what a Carry-forward link carries rather than Main's head. */
+    carried: boolean;
+    /** The fields a resolution must decide, by path. */
+    fields: MergeField[];
+    /** Every other field, merged. */
+    merged: Record<string, unknown>;
+}
+
+/** Why Update from Main stopped a merge: Conflicts, or merged data the Blueprint Release refuses. */
+declare type PendingMergeReason = "conflict" | "invalid";
+
+/** Which Branch holds a Pending Merge: the Branch editor shows the merge itself. */
+declare interface PendingMergeRef {
+    branchId: string;
+    contentId: string;
+}
+
+/** A Repeal or Withdrawal planned, and the referrers it will leave with a gap. */
+declare interface PlannedEnd {
+    plannedRelease: PlannedRelease;
+    /** A warning, never a refusal (ADR 0009). */
+    gapReferrers: GapReferrer[];
+}
+
+/**
+ * A Release a Change Set will cut when it is published (CONTEXT.md, Planned
+ * Release). Its id is the Release's id from the moment it is planned.
+ */
+declare interface PlannedRelease {
+    id: string;
+    contentId: string;
+    kind: ReleaseKind;
+    /** The editorial Branch whose head at Publish it pins; "" for a Branch-less kind. */
+    branchId: string;
+    /** The Revision a Branch-less kind re-pins; "" for a Branch's Release. */
+    revisionId: string;
+    /** Absent for undated Content. */
+    validityPeriod?: ValidityPeriod;
+    /** Its Release Spec values, keyed by the Release Spec Field's accessor; absent for none. */
+    releaseSpec?: Record<string, unknown>;
+    /** The Releases it will Supersede. */
+    supersedesReleaseIds: string[];
+    /**
+     * Proposed by the Change Set, to end `proposedForReleaseId`, a Release a
+     * planned Validity Period cuts into: recomputed from the plans, never
+     * edited by hand.
+     */
+    proposed: boolean;
+    proposedForReleaseId: string;
+    /** For a proposed tail, the Release whose wording it resumes; "" otherwise. */
+    splitFromReleaseId: string;
+    /**
+     * For a Carry-forward link's proposal, whether a plan supersedes the
+     * Release it carries, so that Publish doesn't cut it.
+     */
+    withheld: boolean;
+}
+
+/**
+ * One Content as a Preview reads it (ReleaseService with a Change Set
+ * previewed): its Release In Force on a day as if the Change Set were
+ * published now.
+ */
+declare interface PreviewedContent {
+    /** The Release read, or the Planned Release the Change Set would cut. */
+    releaseId: string;
+    revisionId: string;
+    /** Whether it is one of the previewed Change Set's Planned Releases. */
+    planned: boolean;
+    /** Restricted Content the caller isn't granted on: the Preview's change is withheld. */
+    withheld: boolean;
+    /** Absent for undated Content. */
+    validityPeriod?: ValidityPeriod;
+    data: Record<string, unknown>;
+}
+
+/**
+ * One reason a Publish is refused, or would be (ADR 0015). Which ids are set
+ * depends on `code`; an id that doesn't apply is "".
+ */
+declare interface PublishBlocker {
+    /**
+     * versionkit's (moved_head, unplanned_branch, several_branches,
+     * behind_base, superseded_release, overlapping_periods, covers_release,
+     * pending_merge, nothing_in_force, withdrawal_with_chain, dated_changed,
+     * unpublished_dependency, discarded_dependency), the Content Graph's
+     * (dangling_pin, second_toc_parent, missing_asset), mediahub's
+     * (media_unavailable: it refused the caller's token), Required Checks'
+     * (outstanding_check) or the values' (missing_required_field: a required
+     * field `revisionId` leaves empty, at `path`). A code this build doesn't
+     * know shows as its code.
+     */
+    code: string;
+    contentId: string;
+    branchId: string;
+    expectedHeadId: string;
+    currentHeadId: string;
+    releaseId: string;
+    overlapsReleaseId: string;
+    dependencyChangeSetId: string;
+    path: string;
+    targetContentId: string;
+    assetId: string;
+    parentContentIds: string[];
+    requiredCheckId: string;
+    coveredReleaseId: string;
+    revisionId: string;
+}
+
+/** What a Publish did. */
+declare interface PublishOutcome {
+    changeSet: ChangeSet;
+    /** ISO 8601: the Publish Time every Release carries. */
+    publishTime: string;
+    releases: Release[];
+}
+
+/**
+ * Publish's dry run: what a Publish with the same reviewed heads would be
+ * refused with now, and what it would cut.
+ */
+declare interface PublishReview {
+    /** None means a Publish with these heads would succeed now. */
+    blockers: PublishBlocker[];
+    releases: Release[];
+    /** Published already with these heads: Publish would return its stored outcome. */
+    published: boolean;
+}
+
+/** One recorder grant: a member by name, or every member of the workspace. */
+declare type RecorderGrant = {
+    userId: string;
+} | {
+    everyMember: true;
+};
+
+/** An incoming edge, and where it was found: a Release In Force, or an open Change Set's Branch. */
+declare interface Referrer {
+    edge: Edge;
+    /** "" when found in a Change Set. */
+    releaseId: string;
+    /** "" when found in a Release. */
+    changeSetId: string;
+    branchId: string;
+}
+
+/** One page of `listReferrers`. */
+declare interface ReferrerList {
+    referrers: Referrer[];
+    /** Empty on the last page. */
+    nextPageToken: string;
+}
+
+/** A Release a Publish cut, or would cut. */
+declare interface Release {
+    id: string;
+    contentId: string;
+    kind: ReleaseKind;
+    branchId: string;
+    revisionId: string;
+    /** The Content's first Release: the moment it exists outside its Change Set. */
+    first: boolean;
+    supersedesReleaseIds: string[];
+    /** Absent for undated Content. */
+    validityPeriod?: ValidityPeriod;
+}
+
+/** How a Release comes to be (contenthub ADR 0016). */
+declare type ReleaseKind = "revision" | "date_only" | "repeal" | "withdrawal";
+
+/** A condition the workspace requires before Publish (CONTEXT.md, Required Check). */
+declare interface RequiredCheck {
+    id: string;
+    name: string;
+    scope: CheckScope;
+    /** The Blueprints whose Content it applies to; empty for every one. */
+    blueprintAccessors: string[];
+    /** Passed and waived are refused from whoever authored what it covers. */
+    independent: boolean;
+}
+
+/** What a Required Check is declared with, on create and on update alike. */
+declare interface RequiredCheckInput {
+    name: string;
+    scope: CheckScope;
+    /** Blueprint accessors; empty for every Blueprint. */
+    blueprintAccessors: string[];
+    independent: boolean;
+}
+
+/**
+ * Who records a Required Check's results (ADR 0017's 2026-10-03 amendment):
+ * every member of the workspace, the people granted by name, or both while
+ * an admin narrows it.
+ */
+declare interface RequiredCheckRecorders {
+    everyMember: boolean;
+    /** Sorted odon user ids. */
+    userIds: string[];
+}
+
+/**
+ * The Blueprint Release a Content's Revision pins, as contenthub validated
+ * and cached it (blueprinthub's Resolved Release): what its form is drawn
+ * from.
+ */
+declare interface ResolvedBlueprintRelease {
+    /** The Blueprint's name, as the released Revision holds it; "" if it holds none. */
+    displayName: string;
+    /** Whether its Content is Dated: its Releases carry a Validity Period. */
+    dated: boolean;
+    /** fieldkit's Resolved Spec fields, in Blueprint order. */
+    fields: ResolvedField[];
+    /**
+     * Its Release Spec: the fields every Release of its Content carries
+     * values for, which a Planned Release sets. Absent or empty for none.
+     */
+    releaseSpec?: ResolvedField[];
+    /** The opaque parts the fields pin (fieldkit ADR-0020), by kind and Release id. */
+    parts: Record<string, Record<string, unknown>>;
+}
+
+/**
+ * One field of a Blueprint Release, as its Resolved Release declares it:
+ * fieldkit's Field. The screens read its name and accessor and hand the
+ * rest to fieldkit untouched.
+ */
+declare interface ResolvedField {
+    field_type: string;
+    config: {
+        name: string;
+        api_accessor: string;
+        hidden?: boolean;
+    } & Record<string, unknown>;
+    children?: ResolvedField[];
+    [key: string]: unknown;
+}
+
+/** One immutable Revision of a Content, without its data. */
+declare interface Revision {
+    id: string;
+    contentId: string;
+    /** The Revision it was built on; "" for the Content's first. */
+    parentId: string;
+    /** The other side of a merge Revision; "" otherwise. */
+    secondParentId: string;
+    blueprintReleaseId: string;
+    /** ISO 8601. */
+    createTime: string;
+    /** The odon user who wrote it. */
+    author: string;
+    cause: RevisionCause;
+    /** The Branch it was written on, and that Branch's Change Set. */
+    branchId: string;
+    changeSetId: string;
+}
+
+/** Why a Revision was written. */
+declare type RevisionCause = "create" | "save" | "merge" | "resolve" | "upgrade" | "unspecified";
+
+/** How one Revision differs from a base, field by field. */
+declare interface RevisionComparison {
+    base: Revision;
+    revision: Revision;
+    changes: FieldChange[];
+}
+
+/** One page of `listRevisions`, newest first. */
+declare interface RevisionList {
+    revisions: Revision[];
+    /** Empty on the last page. */
+    nextPageToken: string;
+}
+
+/**
+ * The port a host fills with statushub (ADR 0020): the workspace's Change Set
+ * statuses, for their display names and colours. contenthub-ui depends on no
+ * statushub package. A host without statushub leaves the port empty, and the
+ * screens then show the bare slug and offer no status picker.
+ */
+declare interface StatusSource {
+    /** Every status of the workspace's `contenthub/change_set` catalogue, in its order. */
+    listChangeSetStatuses(): Promise<ChangeSetStatusInfo[]>;
+}
+
+export declare const STUB_NOW = "2026-10-01T09:00:00.000Z";
+
+/** A second member of the stub workspace, to assign and filter by. */
+export declare const STUB_OTHER_USER_ID = "user_ben";
+
+export declare const STUB_USER_ID = "user_stub";
+
+export declare const STUB_WORKSPACE_ID = "ws_stub";
+
+/** A blocker naming only what `fields` sets; every other id "", as on the wire. */
+export declare function stubBlocker(code: string, fields?: Partial<PublishBlocker>): PublishBlocker;
+
+/** A legal publisher's Block Reasons, in the service's order (by name). */
+export declare function stubBlockReasons(): BlockReason[];
+
+/** Their Releases, newest first per Blueprint. */
+export declare function stubBlueprintReleases(): BlueprintReleaseInfo[];
+
+/**
+ * The workspace's content Blueprints, as the `BlueprintSource` port answers,
+ * by name. Commentary has had no Release cut yet.
+ */
+export declare function stubBlueprints(): BlueprintInfo[];
+
+/**
+ * A gazette's Change Sets: one open with two Chains (§ 1 amended twice, so
+ * two Branches, and a paragraph born in it), one open with nothing in it yet,
+ * and one published correction. Newest first, as the service lists them.
+ */
+export declare function stubChangeSets(): ChangeSet[];
+
+/**
+ * statushub's seed catalogue for `contenthub/change_set` (spec #56, story 9),
+ * as the `StatusSource` port answers it. Colours are CSS names: statushub
+ * holds whatever CSS colour an admin chose.
+ */
+export declare function stubChangeSetStatuses(): ChangeSetStatusInfo[];
+
+/**
+ * A legal publisher's Collection tree, by name as the service lists it:
+ * Laws holding BGB and StGB, and Commentary beside it.
+ */
+export declare function stubCollections(): Collection[];
+
+/** A merge an Update from Main would stop on (see `conflicts`). */
+export declare interface StubConflict {
+    theirsRevisionId: string;
+    fields: MergeField[];
+    /** Every field but `fields`, merged. */
+    merged: Record<string, unknown>;
+    reason?: "conflict" | "invalid";
+    /** Already stored on the Branch, as an earlier Update from Main left it. */
+    pending?: boolean;
+}
+
+/**
+ * A Content of the stub workspace, every way the screens can read it. Not a
+ * service type: it is what the stub keeps to answer its reads.
+ */
+export declare interface StubContent {
+    id: string;
+    blueprintId: string;
+    blueprintReleaseId: string;
+    /** The Collections it is filed in, directly. */
+    collectionIds: string[];
+    /** Who maintains it; none when absent. */
+    assigneeIds?: string[];
+    /** Its Block; absent while it is not blocked. */
+    block?: ContentBlock;
+    /** When it was archived, ISO 8601; absent while it is not Archived. */
+    archiveTime?: string;
+    /** Its Main head; absent while it was born in an open Change Set. */
+    main?: StubHead;
+    /** The Release In Force today, and the head it pins; absent for none. */
+    inForce?: StubHead & {
+        releaseId: string;
+    };
+    /** The head of its Chain's last Branch in each Change Set it is in, by Change Set id. */
+    branches: Record<string, StubHead & {
+        branchId: string;
+    }>;
+    /** Its Timeline as known now; none when absent. */
+    timeline?: TimelineEntry[];
+    /** What open (or since closed) Change Sets plan for it, in the order planned. */
+    plannedReleases?: {
+        changeSetId: string;
+        plannedRelease: PlannedRelease;
+    }[];
+    /** Its Revisions, newest first, beyond what its heads imply; none when absent. */
+    revisions?: (Revision & {
+        data?: Record<string, unknown>;
+    })[];
+    /** The outgoing edges of its Revisions, each naming the Revision holding it. */
+    edges?: Edge[];
+}
+
+export declare interface StubContenthubClientOptions {
+    /** The workspace's Block Reasons to start from; the fixtures' by default. */
+    blockReasons?: BlockReason[];
+    /** The workspace's Change Sets to start from, newest first; the fixtures' by default. */
+    changeSets?: ChangeSet[];
+    /**
+     * statushub's `contenthub/change_set` catalogue the stub checks status
+     * moves against; the fixtures' by default.
+     */
+    statuses?: ChangeSetStatusInfo[];
+    /** The moves statushub allows, from slug to slugs; the fixtures' by default. */
+    statusTransitions?: Record<string, string[]>;
+    /** The workspace's Collections, by name; the fixtures' by default. */
+    collections?: Collection[];
+    /** The workspace's Content, every way it can be read; the fixtures' by default. */
+    contents?: StubContent[];
+    /**
+     * The Blueprint Releases contenthub can load, which `createContent`
+     * accepts; the fixtures' by default.
+     */
+    blueprintReleases?: {
+        id: string;
+        blueprintId: string;
+    }[];
+    /** The Resolved Releases `getContent` answers with, by Blueprint Release id; the fixtures' by default. */
+    resolvedReleases?: Record<string, ResolvedBlueprintRelease>;
+    /**
+     * The workspace's Required Checks; the fixtures' by default. The stub
+     * reads `blueprintAccessors` as Blueprint ids, the one name its Content
+     * carries.
+     */
+    requiredChecks?: RequiredCheck[];
+    /** Check Results recorded before, in the order they were recorded. */
+    checkResults?: (CheckResult & {
+        changeSetId: string;
+    })[];
+    /**
+     * Blockers the stub can't derive itself (versionkit's and the Content
+     * Graph's, such as covers_release or dangling_pin), by Change Set id:
+     * `validatePublish` and `publish` report them beside the ones it does
+     * derive (moved_head, the dependencies', outstanding_check).
+     */
+    publishBlockers?: Record<string, PublishBlocker[]>;
+    /** The Pending Merges `updateFromMain` leaves, by Change Set id; none by default. */
+    pendingMerges?: Record<string, PendingMergeRef[]>;
+    /**
+     * What an Update from Main would meet on a Branch, by Branch id: the
+     * fields it can't merge and the rest merged. `updateFromMain` stores it
+     * on the Branch as a Pending Merge; `pending` stores it from the start.
+     */
+    conflicts?: Record<string, StubConflict>;
+    /**
+     * contenthub's `authz.mode`: "guardian" by default. In "workspace" every
+     * restriction and grant is refused, as contenthub refuses them, and
+     * opening a Restricted Collection again is still allowed.
+     */
+    authzMode?: "workspace" | "guardian";
+    /** Grants on Restricted Collections, by Collection id, the owner's included. */
+    collectionGrants?: Record<string, CollectionGrant[]>;
+    /**
+     * The Change Sets, by id, holding work the caller can't see (Restricted
+     * Content, ADR 0017): `validatePublish`, `publish`, `discardChangeSet`
+     * and an `updateFromMain` without `chainId` refuse them with
+     * `WithheldWorkError`, as contenthub does.
+     */
+    withheld?: string[];
+    /**
+     * Who records each Required Check, by check id; a check not named here,
+     * and every new one, is recorded by every member. In guardian mode
+     * `recordCheckResult` refuses a caller who is no recorder, as contenthub
+     * does; in workspace mode every member records, and the recorder calls
+     * are refused.
+     */
+    recorders?: Record<string, RequiredCheckRecorders>;
+    /** The workspace's members, whom a grant may name; the stub identity's two by default. */
+    memberIds?: string[];
+    /**
+     * Whether the caller is a workspace admin, who manages every Restricted
+     * Collection's grants; true by default. Otherwise only an owner does.
+     */
+    admin?: boolean;
+    /** Who the token names: the creator of a new Change Set. STUB_USER_ID by default. */
+    userId?: string;
+    /** The time every write stamps; STUB_NOW by default. */
+    now?: () => string;
+}
+
+/**
+ * The Content behind the fixtures' Change Sets: § 1 BGB, amended in
+ * BGBl. 2026 I Nr. 270; § 2 BGB; § 4a BGB, born in that Change Set; § 211
+ * StGB; and a footnote filed nowhere, published but with no Release In Force
+ * yet (dated to start next year).
+ */
+export declare function stubContents(): StubContent[];
+
+/** One head of a Content: its Revision, data and when it was written. */
+export declare interface StubHead {
+    revisionId: string;
+    data: Record<string, unknown>;
+    /** ISO 8601. */
+    revisionCreateTime: string;
+}
+
+/** Who is looking, for anker's `TestHost` or `<HostProvider identity>`. */
+export declare function stubIdentity(): HostIdentity;
+
+/**
+ * § 3 BGB, repealed at the end of 2001: published, filed in BGB, with
+ * nothing In Force today or later, so it may be archived. Not among
+ * `stubContents()`, so the Library's fixtures stay as they are; pass it in
+ * with `contents` to a stub that needs it.
+ */
+export declare function stubRepealedContent(): StubContent;
+
+/**
+ * A legal publisher's Required Checks, by name: a print round trip once per
+ * Change Set, and a lawyer's review of each Branch, by someone who wrote
+ * none of it. Both apply to every Blueprint.
+ */
+export declare function stubRequiredChecks(): RequiredCheck[];
+
+/**
+ * The Resolved Releases contenthub holds for the fixtures' Blueprint
+ * Releases, by id, as `getContent` decodes them: a paragraph has a number
+ * and a heading, a footnote a text. Both are Dated.
+ */
+export declare function stubResolvedReleases(): Record<string, ResolvedBlueprintRelease>;
+
+/**
+ * The moves the stub's statushub allows, from slug to slugs. Anything else is
+ * refused with a reason, as statushub refuses it; a move away from an unknown
+ * status is never checked (contenthub ADR 0014).
+ */
+export declare function stubStatusTransitions(): Record<string, string[]>;
+
+/** One Release of a Content's Timeline (CONTEXT.md, Timeline), without its data. */
+declare interface TimelineEntry {
+    /** Its place in the Timeline, from 1. */
+    ordinal: number;
+    releaseId: string;
+    kind: ReleaseKind;
+    revisionId: string;
+    blueprintReleaseId: string;
+    /** Absent for undated Content. */
+    validityPeriod?: ValidityPeriod;
+    /** ISO 8601. */
+    publishTime: string;
+    first: boolean;
+}
+
+/** What Update from Main did to a Change Set. */
+declare interface UpdateFromMainOutcome {
+    changeSet: ChangeSet;
+    /** The Branches whose heads moved to a merge Revision. */
+    mergedBranchIds: string[];
+    /** The Branches this update left with a Pending Merge. */
+    conflicted: PendingMergeRef[];
+    /** Branches with a Pending Merge from before, which it left alone. */
+    pending: PendingMergeRef[];
+    /** Carry-forward links taken out of their Chains. */
+    endedBranchIds: string[];
+}
+
+/**
+ * The calendar days a Release of Dated Content is In Force, both included,
+ * as YYYY-MM-DD; `lastDay` is "" for an open end.
+ */
+declare interface ValidityPeriod {
+    firstDay: string;
+    lastDay: string;
+}
+
+export { }