@extrovert.dev/mcp 0.1.0-pre.3

package/dist/fixtures.d.ts

@@ -0,0 +1,676 @@
+/**
+ * Offline fixture store.
+ *
+ * Every method here maps 1:1 onto a REST call in `client.ts`. Live MCP sessions
+ * use the Go REST API by default; this store is used for tests and offline demos
+ * when `EXTROVERT_MOCK=1`.
+ *
+ * The store is intentionally stateful within a process: creating an inbox,
+ * sending mail, and waiting for a reply all mutate the same in-memory data, so
+ * the example agent flow (redeem -> create_inbox -> send -> wait_for_email)
+ * produces coherent results offline.
+ */
+import type { Attachment, AttachmentDownload, AttachmentInput, BatchUpdateResult, Category, ContactListDirection, ContactListEntry, ContactListKind, DeleteResult, Domain, DomainOffboard, EnrollmentResult, GraduationStatus, Inbox, Job, KeyTier, MailboxCredentials, Message, Page, Review, ReviewDecisionContext, ReviewerDecisionResult, ReviewPolicy, RiskDial, CategoryPacingState, ReviewEventsResult, ReviewFeedback, ReviewTurn, Rule, RuleAuditEntry, ProblemField, ScanBacklogStatus, SendEmailResult, SendResult, SubmitForReviewResult, SuppressionEntry, SuppressionPrecheck, ReputationRollup, ReputationFinding, ListDeliverabilityFindingsInput, Thread, ThreadDetail, SignUpResult, VerifyResult, WaitForEmailResult, Webhook, WebhookEvent, WhoAmI } from "./types.js";
+import type { AckReviewEventInput, GetRuleAuditInput, GetRulesInput, InboxMetadataPatch, ListReviewEventsInput, ListReviewsInput, PostReviewChatInput, ProposeCategoryInput, RestampReviewInput, ReviewerDecideInput, SaveRuleInput, SubmitForReviewInput, SubmitForwardForReviewInput, SubmitRevisionInput, SubmitReplyForReviewInput, UpdateCategoryInput, WaitForReviewEventInput } from "./client.js";
+/**
+ * The recipient the mock seeds an active org-scope suppression for, so the
+ * suppression reads (check/list/revoke) and the `recipient_suppressed`
+ * send-rejection path have deterministic data offline.
+ */
+export declare const SEEDED_SUPPRESSED_RECIPIENT = "unsubscribed@example.com";
+/**
+ * The recipient whose delivery ALWAYS fails at the mock's outbound-provider boundary, so the
+ * `approved -> failed` edge and its terminal `send_failed` nudge are drivable
+ * offline. Without it the mock could only ever demonstrate the happy path, and a
+ * drain loop that never sees `send_failed` is a drain loop nobody proved
+ * terminates on failure — which is exactly how the missing terminal nudges
+ * survived unnoticed.
+ */
+export declare const SEEDED_SEND_FAILURE_RECIPIENT = "bounce@example.com";
+export declare class FixtureStore {
+    private inboxes;
+    private messages;
+    /** message id -> stored attachments (mock mirror of the real MIME parts). */
+    private attachments;
+    /** webhook id -> registered webhook (mock mirror of extrovert_webhooks). */
+    private webhooks;
+    /** entry id -> contact-list entry (mock mirror of extrovert_contact_lists). */
+    private contactLists;
+    /** domain name -> onboarded domain (mock mirror of extrovert_domains). */
+    private domains;
+    /** job id -> async job status (mock mirror of extrovert_jobs; currently only
+     *  the domain-offboard teardown enqueues one). */
+    private jobs;
+    /** suppression id -> recipient opt-out row (mock mirror of extrovert_suppressions). */
+    private suppressions;
+    /** review id -> review request (mock mirror of extrovert_review_requests). */
+    private reviews;
+    /** review id -> append-only thread turns (mock mirror of the turn log). */
+    private reviewTurns;
+    /**
+     * review id -> reviewer hand-back count (M8 Slice B circuit breaker (a)). The wire
+     * Review shape doesn't carry hop_count, so the mock tracks it here to surface the
+     * max_hops breaker on the decision context + reviewer_decide.
+     */
+    private reviewHopCounts;
+    /**
+     * review id -> durable nudges for that review (mock mirror of
+     * extrovert_review_nudges), oldest-first with a per-review monotonic seq. The
+     * authoritative liveness queue (spec §4.5) the agent drains/acks.
+     */
+    private reviewEvents;
+    /** review id -> the agent's last-acked seq (the per-(agent, review) cursor). */
+    private reviewEventCursors;
+    /** review id -> the thread a queued reply/forward delivers into (materialized at submit). */
+    private reviewThreads;
+    /** review id -> the opaque parent message id a queued reply threads to. */
+    private reviewParents;
+    /** category id -> category (mock mirror of extrovert_categories, D9/D10). */
+    private categories;
+    /** rule id -> writing rule (mock mirror of extrovert_writing_rules, D2/D11). */
+    private rules;
+    /** udo id -> change/undo audit row (mock mirror of extrovert_rule_undo_log). */
+    private ruleAudit;
+    /** human_email -> mock self-signup state (in-memory OTP). */
+    private signups;
+    /** "<scope>:<client_id>" -> the created resource id, mirroring the server's
+     *  idempotency replay (a repeat with the same key returns the first result). */
+    private idempotency;
+    private readonly agentId;
+    /**
+     * The ceiling tier of the session's key (redesign §3.1). Default `project`
+     * (legacy bare `pk_agent_` behavior). Drives the bare-vs-wildcard list ceiling:
+     * an `org` key must pick a breadth (`breadth_required`); a non-org key cannot use
+     * the org wildcard (`forbidden_scope`). Mirrors the live choke-point so the
+     * isolation contract is exercised offline.
+     */
+    private readonly keyTier;
+    /**
+     * The org's review policy, mirrored offline so the mock enforces the SAME tree
+     * the server does.
+     *
+     * The default is `require_review` — deliberately, and matching the column
+     * default every real account gets. A mock that defaulted to `allow_direct` would
+     * teach every offline agent that a bare send just sends, which is precisely the
+     * lie that let the wire bug live for months: the mock passed while the real API
+     * refused. Override it with `EXTROVERT_MOCK_REVIEW_POLICY=allow_direct` when a
+     * test needs a delivered message rather than a queued review.
+     */
+    private readonly reviewPolicy;
+    /**
+     * The `front_run_next` nudge keys already enqueued, so N identical retries
+     * against a terminal review collapse to ONE row (the server dedupes on a
+     * deterministic key over reason + review + terminal state + parent revision).
+     */
+    private frontRunKeys;
+    constructor(opts?: {
+        keyTier?: KeyTier;
+        reviewPolicy?: ReviewPolicy;
+    });
+    /** The resolved review policy for this account (mock mirror of the inbox read). */
+    effectiveReviewPolicy(): ReviewPolicy;
+    /**
+     * Persist a review and recompute the derived `closed` flag from its state. Every
+     * mutation goes through here so `closed` can never drift from `state` — an agent
+     * polling `closed` after a crash is trusting exactly this.
+     */
+    private commitReview;
+    /**
+     * The mock mirror of the submit-time D3 gate. A resolved-review send REQUIRES an
+     * intent; a bare send/reply/forward has none by construction, so under anything
+     * but an explicitly-asserted direct mode on an `allow_direct` account it is
+     * refused — nothing sent, nothing queued.
+     */
+    private resolvedModeIsReview;
+    /**
+     * The SUBMIT-TIME pre-flight: contact lists and list-unsubscribe suppression,
+     * run against the resolved recipient set BEFORE the intent gate.
+     *
+     * The order matters and mirrors the server exactly. A blocked or suppressed
+     * recipient is a fact about the message that no amount of intent will fix, so
+     * answering `intent_required` first would send the agent off to add an intent
+     * and retry straight into the same wall. Running it before the review is created
+     * also means no human is ever handed a draft that could never have been sent.
+     */
+    private preflight;
+    /**
+     * Reject a BARE send/reply/forward under a policy that requires review. The
+     * error mirrors the server's 422 `intent_required` remediation, including the
+     * `retry_with` example, so an offline agent recovers exactly the way it would
+     * against the live API.
+     */
+    private requireDirectSendAllowed;
+    signUp(input: {
+        human_email: string;
+        username?: string;
+    }): SignUpResult;
+    verify(otp: string): VerifyResult;
+    whoami(): WhoAmI;
+    redeemEnrollment(token: string, agentHandle?: string): EnrollmentResult;
+    createInbox(opts: {
+        username?: string;
+        domain?: string;
+        displayName?: string;
+        inboundWebhookUrl?: string;
+        metadata?: InboxMetadataPatch;
+        projectId?: string;
+        clientId?: string;
+    }): Inbox;
+    listInboxes(opts?: {
+        limit?: number;
+        project?: string;
+        wildcard?: boolean;
+    } | number): Page<Inbox>;
+    getInbox(idOrAddress: string): Inbox | undefined;
+    /** Update an inbox's settings in place (mirrors PATCH /v1/inboxes/{inbox_id}). */
+    updateInbox(idOrAddress: string, opts: {
+        displayName?: string;
+        inboundWebhookUrl?: string;
+        dailySendLimit?: number;
+        metadata?: InboxMetadataPatch | null;
+        projectId?: string;
+    }): Inbox | undefined;
+    getCredentials(idOrAddress: string): MailboxCredentials;
+    deleteInbox(idOrAddress: string): {
+        id: string;
+        deleted: true;
+    } | undefined;
+    /**
+     * A BARE send — no mode/intent/category_id. Policy-gated exactly like the live
+     * endpoint: only an `allow_direct` account delivers here; under `require_review`
+     * (the default) this is 422 `intent_required` with the remediation attached, and
+     * nothing is sent or queued.
+     */
+    sendEmail(opts: {
+        inbox: string;
+        to: string[];
+        subject: string;
+        text: string;
+        html?: string;
+        cc?: string[];
+        bcc?: string[];
+        reply_to?: string;
+        headers?: Record<string, string>;
+        attachments?: AttachmentInput[];
+    }): SendEmailResult;
+    /**
+     * The actual mock delivery, shared by the bare direct path and the review
+     * loop's approve/auto-send dispatch. Policy is enforced by the CALLERS, never
+     * here: an approved review has already passed the human and must deliver.
+     */
+    private deliverSend;
+    /**
+     * Thread-aware reply (mock). Resolves the parent by message_id or the latest
+     * message in thread_id, derives recipients/subject server-side, and returns the
+     * canonical `{message_id, thread_id}` — matching the real API contract.
+     */
+    replyEmail(opts: {
+        inbox: string;
+        threadId?: string;
+        messageId?: string;
+        text?: string;
+        html?: string;
+        cc?: string[];
+        bcc?: string[];
+        replyTo?: string;
+        replyAll?: boolean;
+        attachments?: AttachmentInput[];
+    }): SendResult;
+    /** The mock reply delivery, shared by the direct path and approval dispatch. */
+    private deliverReply;
+    /**
+     * Forward an existing message to new recipients (mock). Policy-gated like send
+     * and reply: a forward quotes an entire received thread to arbitrary NEW
+     * recipients, so leaving it ungated would make it the documented bypass.
+     */
+    forwardEmail(opts: {
+        inbox: string;
+        messageId: string;
+        to: string[];
+        cc?: string[];
+        bcc?: string[];
+        text?: string;
+        html?: string;
+    }): SendResult;
+    /** The mock forward delivery, shared by the direct path and approval dispatch. */
+    private deliverForward;
+    /**
+     * Submit a new message for review (mock). Mirrors the server's deterministic
+     * routing: a `direct` mode is sent immediately (`kind:"sent"`); otherwise the
+     * message is parked in `needs_review` (`kind:"queued_for_review"`). Intent is
+     * required when the resolved mode is review (D3).
+     */
+    submitForReview(input: SubmitForReviewInput): SubmitForReviewResult;
+    /** Submit an in-thread reply for review (mock). Same routing as submitForReview. */
+    submitReplyForReview(input: SubmitReplyForReviewInput): SubmitForReviewResult;
+    /**
+     * Submit a forward for review (mock). Same routing as submitForReview, with the
+     * forward's subject + quoted body MATERIALIZED here so the human reviews the
+     * exact bytes that go out rather than a body re-derived from the live parent at
+     * approval time (which would silently discard the reviewer's edit).
+     */
+    submitForwardForReview(input: SubmitForwardForReviewInput): SubmitForReviewResult;
+    /** Resolve a reply's parent by message id, else the latest message in a thread. */
+    private resolveReplyParent;
+    /**
+     * Record the review row that governed a DIRECT (policy-permitted) send, park it
+     * in the terminal `auto_sent` state with `send_path: agent_direct`, and emit its
+     * one terminal `sent` nudge.
+     *
+     * The direct path used to hand back no handle at all, which meant an agent that
+     * crashed between the request and the response could never ask what became of
+     * the message. Leaving the dominant path handle-less would have entrenched
+     * exactly the crash-recovery hole the review loop exists to close.
+     */
+    private recordDirectReview;
+    /**
+     * Enqueue the ONE terminal nudge a finished review is allowed to produce.
+     *
+     * The invariant a drain loop is written against: every review that reaches
+     * `sent`, `auto_sent`, `failed` or `cancelled` emits exactly one terminal nudge,
+     * and it is the last and highest-`seq` nudge that review will ever produce. The
+     * payload carries everything the agent needs to stop — including WHY a send
+     * failed, which was previously stored and exposed on no surface at all.
+     */
+    private enqueueTerminalNudge;
+    /**
+     * Best-effort `front_run_next` nudge for an agent that tried to mutate a review
+     * somebody else already finished. It is enqueued OUTSIDE any transition (there
+     * is none) and deduped on a deterministic key, so a retry loop hitting the same
+     * 409 with the same parent_revision collapses N identical nudges to ONE row.
+     */
+    private enqueueFrontRunNudge;
+    /**
+     * The mock mirror of the 409 taxonomy for a review-mutating verb. A terminal row
+     * and a wrong-phase row are DIFFERENT errors on purpose: one must never be
+     * retried, the other needs a different verb. Collapsing them to a single
+     * "conflict" is what made a skill's one 409 handler retry a sent message forever.
+     */
+    private assertMutable;
+    /** List review requests (mock), newest-first, with optional state/category/inbox filters. */
+    listReviews(input?: ListReviewsInput): Page<Review>;
+    /** Get one review request (mock). */
+    getReview(id: string): Review;
+    /** Get a review's append-only thread turns (mock). */
+    getReviewTurns(id: string): Page<ReviewTurn>;
+    /**
+     * Get the human's assembled feedback for a review (mock; M5): the diff + the
+     * human comments/rejection turns + the decision (derived from state) + the rules
+     * born from this review. Mirrors the server's $0-LLM assembly.
+     */
+    getReviewFeedback(id: string): ReviewFeedback;
+    /**
+     * Post a chat turn on a review's thread (mock; M5): append an agent_question turn,
+     * flip in_review -> chatting on the first turn, enqueue a feedback_added event.
+     * Idempotent-key dedup is the transport's concern (replayed there); the mock just
+     * appends one turn per call.
+     */
+    postReviewChat(input: PostReviewChatInput): Review;
+    /**
+     * Post a new agent draft under a parent_revision CAS (mock; M5). A mismatch is a
+     * 409 STALE with NO mutation (D17); a clean CAS re-renders the draft in place
+     * (revision++), returns to needs_review, and enqueues a redraft_requested event.
+     */
+    submitRevision(input: SubmitRevisionInput): Review;
+    /** Withdraw a pending review (mock; M5) to the terminal cancelled state. */
+    cancelReview(id: string): Review;
+    /**
+     * Re-stamp a draft's rules-version WITHOUT redrafting (mock; D19/§8 $0 escape valve).
+     * Advances the version the draft is current against; no revision bump, no body change.
+     * A terminal/approved draft 409s; against_version < 0 is invalid.
+     */
+    restampReview(input: RestampReviewInput): Review;
+    /** Get the reviewer's decision context for a review (mock; §9). */
+    getReviewDecisionContext(id: string): ReviewDecisionContext;
+    /**
+     * Submit a reviewer decision (mock; §9). approve/edit → the platform "sends" with the
+     * composer's creds (kind=sent, send_path=reviewer_approved); reject → back to the
+     * composer (needs_review, hop_count++) UNLESS a breaker forces the human; escalate →
+     * the human queue. revision/version are the CAS (409 STALE on mismatch, NO mutation).
+     */
+    reviewerDecide(input: ReviewerDecideInput): ReviewerDecisionResult;
+    /**
+     * Browse the registry (mock), newest-first, excluding merged/soft-deleted
+     * (merged_into set). `match` is a pure lexical filter (every token must appear in
+     * name+description) — NO LLM, mirroring the server.
+     */
+    listCategories(match?: string): Page<Category>;
+    /** Get one category (mock); throws NotFound on an unknown id. */
+    getCategory(id: string): Category;
+    /** Propose a category (mock): stands immediately, author_kind=agent. */
+    proposeCategory(input: ProposeCategoryInput): Category;
+    /** Rename / re-describe a category (mock) — metadata only (D10). */
+    updateCategory(input: UpdateCategoryInput): Category;
+    /** The mock account-default risk dial (mirrors the server defaults). */
+    private accountDial;
+    /**
+     * Read the effective risk dial (mock): the account default + every category with
+     * an inherited (null override) effective dial. The mock category carries no risk-
+     * dial overrides, so every category inherits — effective == account.
+     */
+    getRiskDial(): RiskDial;
+    /** The next rung up the graduation ladder ("" if none). */
+    private nextGraduationState;
+    /**
+     * Read a category's graduation gate status (mock). The mock category has no
+     * counters, so it reports zero clean approvals / zero drift against the account
+     * defaults; can_graduate is true for supervised→auto_notify (no maturity gate).
+     */
+    getGraduationStatus(categoryId: string): GraduationStatus;
+    /**
+     * Propose graduating a category (mock): records nothing mutating and returns the
+     * current gate status. It does NOT flip the bit (D16) — the category state is
+     * unchanged.
+     */
+    proposeGraduation(categoryId: string, _evidence?: Record<string, unknown>): GraduationStatus;
+    /**
+     * Read the D19/§8 backlog-reconciliation status (mock): counts the QUEUED drafts in a
+     * category that are stale vs current-enough against the current rules-version. The
+     * mock has no per-draft composed_* stamps, so every queued draft reads current-enough;
+     * the contract shape is exercised (the integer-compare is covered by the Go tests).
+     */
+    getBacklogStatus(categoryId: string): ScanBacklogStatus;
+    /**
+     * Read the demand-driven pacing state (mock — M7 Slice B/§8): the cursor + effective
+     * window/ceiling/interval + each queued draft's classification. The mock has no cursor
+     * (nothing reviewed) and no composed_* stamps, so every queued draft reads in-window-
+     * fresh until the window fills, then ahead; the contract shape is exercised (the
+     * cursor/staleness mechanics are covered by the Go tests).
+     */
+    getPacingState(categoryId: string): CategoryPacingState;
+    /** rank a rule for the §7 ladder (mock mirror of the server's deterministic order). */
+    private ruleRank;
+    /**
+     * Get the ORDERED active rule set (mock). Applies the §7 precedence ladder and the
+     * category-before-general concatenation, mirroring the server (NO LLM).
+     */
+    getRules(input?: GetRulesInput): Page<Rule>;
+    /** Save / edit a rule (mock) — append-only by supersession (D11). */
+    saveRule(input: SaveRuleInput): Rule;
+    /** Promote a rule between the category and general layers (mock, via supersession). */
+    promoteRule(id: string, toScope: "general" | "category"): Rule;
+    /** Retire a rule (mock) — soft delete; history survives. */
+    retireRule(id: string): Rule;
+    /** Read the rule/category change audit log (mock). */
+    getRuleAudit(input?: GetRuleAuditInput): Page<RuleAuditEntry>;
+    /** Undo a rule change (mock) — restore the prior version; idempotent (re-undo 409). */
+    undoRuleChange(udoId: string): Rule;
+    /** recordRuleAudit appends one change/undo audit row (mock). */
+    private recordRuleAudit;
+    /**
+     * enqueueReviewEvent appends a durable nudge for a review with the next
+     * per-review monotonic seq (mock mirror of the server's enqueue-on-transition).
+     * Used by the seed + (in a fuller mock) by transition handlers.
+     */
+    private enqueueReviewEvent;
+    /** Drain the next un-acked review events (mock), FIFO per review + cursors. */
+    listReviewEvents(input?: ListReviewEventsInput): ReviewEventsResult;
+    /**
+     * Long-poll for a review event (mock). Offline there is nothing to wait FOR, so
+     * it returns the immediate drain (empty when caught up) — matching the server's
+     * "empty on timeout" contract.
+     */
+    waitForReviewEvent(input?: WaitForReviewEventInput): ReviewEventsResult;
+    /** Ack review events (mock): advance per-review cursors monotonically. */
+    ackReviewEvent(input: AckReviewEventInput): {
+        cursors: ReviewEventsResult["cursors"];
+    };
+    /**
+     * createReviewRecord mints a needs_review row + the intent (agent_note) and
+     * initial-draft (agent_draft) turns, mirroring the server's submit-time writes.
+     */
+    private createReviewRecord;
+    listMessages(opts: {
+        inbox: string;
+        limit?: number;
+        offset?: number;
+        unreadOnly?: boolean;
+        from?: string;
+        to?: string;
+        subject?: string;
+    }): Page<Message>;
+    /** Fetch a single message by id across all inboxes (mirrors GET /v1/messages/{id}). */
+    getMessage(id: string): Message;
+    /** Toggle the \Seen flag for a message by id (mirrors PATCH .../messages/{id}). */
+    markRead(id: string, read: boolean): Message;
+    listThreads(opts: {
+        inbox: string;
+        limit?: number;
+    }): Page<Thread>;
+    /** Fetch one thread (with its messages, oldest-first) by id under an inbox. */
+    getThread(idOrAddress: string, threadId: string): ThreadDetail;
+    /**
+     * Delete a message by id (mirrors DELETE .../messages/{id}). The mock moves the
+     * message to a Trash folder (soft delete) or removes it outright when expunge is
+     * set or it already lives in Trash. Throws NotFoundError when absent.
+     */
+    deleteMessage(idOrAddress: string, id: string, expunge: boolean): DeleteResult;
+    /**
+     * Delete every message in a thread by id (mirrors DELETE .../threads/{id}).
+     * Moves them to Trash (soft) or removes them (expunge / already in Trash).
+     */
+    deleteThread(idOrAddress: string, threadId: string, expunge: boolean): DeleteResult;
+    /**
+     * Batch mark read/unread and/or move folder for a list of message ids under one
+     * inbox (mirrors PATCH .../messages/batch). Ids not present in the inbox are
+     * reported in `failed`; the rest in `updated`.
+     */
+    batchUpdateMessages(idOrAddress: string, ids: string[], read: boolean | undefined, folder: string | undefined): BatchUpdateResult;
+    /** Build the canonical Thread wire shape (snippet, participant strings). */
+    private toThread;
+    search(opts: {
+        query: string;
+        inbox?: string;
+        limit?: number;
+    }): Page<Message>;
+    /**
+     * Offline `wait_for_email`. Resolves as soon as a matching inbound message is
+     * present. Because `sendEmail` queues an auto-reply ~1.2s out, the demo flow
+     * resolves quickly; otherwise it resolves against an already-seeded OTP mail.
+     */
+    waitForEmail(opts: {
+        inbox: string;
+        from?: string;
+        subject?: string;
+        regex?: string;
+        linkHint?: string;
+        timeoutMs: number;
+        pollMs?: number;
+    }): Promise<WaitForEmailResult>;
+    private resolveInbox;
+    private requireInbox;
+    private appendMessage;
+    /** List a message's attachment metadata (mirrors the list endpoint). */
+    listAttachments(messageId: string): Page<Attachment>;
+    /** Fetch one attachment's bytes + metadata (mirrors the download endpoint). */
+    getAttachment(messageId: string, attachmentId: string): AttachmentDownload;
+    /** Register a webhook; returns the row WITH the one-time signing secret. */
+    registerWebhook(input: {
+        url: string;
+        events?: WebhookEvent[];
+        inbox?: string;
+        clientId?: string;
+    }): Webhook;
+    /** List webhooks (secret redacted). */
+    listWebhooks(): Page<Webhook>;
+    /** Get one webhook (secret redacted). Throws NotFoundError when absent. */
+    getWebhook(id: string): Webhook;
+    /**
+     * Update a webhook in place (secret redacted in the response). Every field is
+     * optional; an unset field leaves the stored value untouched (PATCH semantics).
+     * Throws NotFoundError when absent.
+     */
+    updateWebhook(id: string, input: {
+        url?: string;
+        events?: WebhookEvent[];
+        inbox?: string;
+        active?: boolean;
+    }): Webhook;
+    /** Delete a webhook. Throws NotFoundError when absent. */
+    deleteWebhook(id: string): {
+        id: string;
+        deleted: true;
+    };
+    /** Add one allow/block entry scoped to an inbox. */
+    addContactListEntry(inbox: string, input: {
+        kind: ContactListKind;
+        direction?: ContactListDirection;
+        pattern?: string;
+    }): ContactListEntry;
+    /** List the entries governing an inbox (inbox-specific + account-wide). */
+    listContactListEntries(inbox: string): Page<ContactListEntry>;
+    /** Delete a contact-list entry by id. Throws NotFoundError when absent. */
+    deleteContactListEntry(_inbox: string, id: string): {
+        id: string;
+        deleted: true;
+    };
+    /** Onboard a domain. Mirrors the server's per-mode record set + status. */
+    onboardDomain(input: {
+        domain: string;
+        mode?: "shared" | "ns_delegated" | "manual" | "purchased";
+        mail_host_ip?: string;
+        scope?: "org" | "project";
+        project_id?: string;
+    }): Domain;
+    /** List onboarded domains (records omitted on the summary, mirroring the server). */
+    listDomains(): Page<Domain>;
+    /** Get one domain's detail + the records to set, inline. Throws NotFoundError when absent. */
+    getDomain(domain: string): Domain;
+    /** Trigger/refresh verification; returns the (re-read) detail. Throws when absent. */
+    verifyDomain(domain: string): Domain;
+    /**
+     * Offboard (remove) a domain. Throws NotFoundError when absent. Mirrors the live
+     * API's async contract: it returns an accepted teardown job (there is no job
+     * runner in-fixture, so the row is removed synchronously and a synthetic
+     * succeeded job is reported).
+     */
+    offboardDomain(domain: string): DomainOffboard;
+    /** Get one async job's poll status (mirrors `GET /v1/jobs/{job_id}`). Throws NotFoundError when absent. */
+    getJob(jobId: string): Job;
+    /**
+     * Pre-check whether the caller's org suppresses a recipient (mirrors
+     * `GET /v1/suppressions?recipient=…`): `{recipient, suppressed, rows}` over the
+     * active (non-revoked) org rows for that canonicalized recipient.
+     */
+    precheckSuppression(recipient: string): SuppressionPrecheck;
+    /** Offline deliverability rollup (mirrors `GET /v1/reputation`): healthy, no data. */
+    getReputation(): ReputationRollup;
+    /** Offline findings list (mirrors `GET /v1/reputation/findings`): empty. */
+    listDeliverabilityFindings(_input?: ListDeliverabilityFindingsInput): Page<ReputationFinding>;
+    /** List the caller's own org suppression rows (mirrors the paged `GET /v1/suppressions`). */
+    listSuppressions(input: {
+        scope?: "org" | "shared_domain" | "global";
+        include_revoked?: boolean;
+        limit?: number;
+        cursor?: string;
+    }): Page<SuppressionEntry>;
+    /**
+     * Revoke one org-scope suppression row (mirrors `POST /v1/suppressions/{id}/revoke`);
+     * a reason is required. Throws NotFoundError when the id is unknown or not the
+     * caller's own org row (global/shared rows are platform-operator only → 404).
+     */
+    revokeSuppression(id: string, reason: string): SuppressionEntry;
+    /**
+     * Reject the WHOLE send if ANY recipient has an active org-scope suppression,
+     * naming exactly the suppressed addresses (never the scope/origin) so the caller
+     * can drop them and retry — mirroring the live `recipient_suppressed` (422) path.
+     */
+    private enforceSuppression;
+    /**
+     * Enforce the send-direction contact lists for an inbox: reject a block-listed
+     * recipient, or any recipient outside the allowlist when allowlist mode is on.
+     */
+    private enforceSendPolicy;
+    /** Drop a believable inbound OTP reply into the thread shortly after a send. */
+    private queueAutoReply;
+    private seed;
+}
+/** Thrown when an inbox/thread cannot be resolved (maps to API 404). */
+export declare class NotFoundError extends Error {
+    constructor(message: string);
+}
+/** Thrown when a send is rejected by an inbox's contact lists (maps to API 403). */
+export declare class BlockedError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when a send is rejected because one or more recipients have opted out
+ * (list-unsubscribe / suppression; maps to API 422 `recipient_suppressed`). The
+ * message names exactly the suppressed addresses so the agent can drop them and
+ * retry; `recipients` carries the same list machine-readably.
+ */
+export declare class SuppressedError extends Error {
+    readonly recipients: string[];
+    constructor(recipients: string[]);
+}
+/** Thrown when a project_id assertion does not match the key's bound project (maps to API 403). */
+export declare class ForbiddenError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when an org-tier key issues a bare list that needs an explicit breadth
+ * pick (maps to API 400 `breadth_required`; redesign §4.1). The message names the
+ * next call (a project id or the org wildcard).
+ */
+export declare class BreadthRequiredError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when a send/reply/forward is refused because the account's review policy
+ * requires an intent (maps to API 422 `intent_required`; D3).
+ *
+ * `problemErrors` carries the SAME `{field, code, detail}` hints the live problem
+ * body does — including the `retry_with` example — because the offline error is
+ * useless as practice if it is less actionable than the real one.
+ */
+export declare class IntentRequiredError extends Error {
+    readonly problemErrors?: ProblemField[];
+    constructor(message: string, problemErrors?: ProblemField[]);
+}
+/** Thrown on a conflicting/idempotent-replay mutation (maps to API 409). */
+export declare class ConflictError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when `text` and its deprecated `body` alias disagree (maps to API 400
+ * `conflicting_alias`). There is no safe guess: picking a winner would relay the
+ * wrong bytes from the customer's own domain to a real recipient.
+ */
+export declare class ConflictingAliasError extends Error {
+    readonly problemErrors: ProblemField[];
+    constructor(message: string);
+}
+/**
+ * Base for the review-loop 409s that carry the RECOVERY FACTS as problem fields:
+ * the current state / revision / version, plus one `allowed_action` per legal verb.
+ * A stale-CAS retry therefore needs no extra `get_review`, and a wrong-state agent
+ * is told what IS legal instead of retrying the same verb forever.
+ */
+export declare class ReviewConflictError extends ConflictError {
+    readonly problemErrors: ProblemField[];
+    constructor(message: string, review: Review);
+}
+/**
+ * 409 `stale` — the `(revision[,version])` you named is no longer current and
+ * NOTHING was mutated. The ONE 409 worth retrying: re-read, re-apply your edit on
+ * top of the other party's, resubmit with the new parent_revision. Bounded (<=3).
+ */
+export declare class StaleError extends ReviewConflictError {
+    constructor(message: string, review: Review);
+}
+/**
+ * 409 `wrong_state` — this VERB is illegal from the current state, but the draft
+ * is still live. NEVER retry the same verb; read the `allowed_action` hints and
+ * pick a legal one.
+ */
+export declare class WrongStateError extends ReviewConflictError {
+    constructor(message: string, review: Review);
+}
+/**
+ * 409 `terminal` — sent / auto_sent / cancelled. Nothing will ever succeed on this
+ * review. STOP; a `front_run_next` nudge is waiting in the drain.
+ */
+export declare class TerminalError extends ReviewConflictError {
+    constructor(message: string, review: Review);
+}
+//# sourceMappingURL=fixtures.d.ts.map