@pome-sh/checks 0.1.0

package/dist/_types/twin-github/src/types.d.ts

@@ -0,0 +1,244 @@
+import type { TwinDatabase } from "../../sdk/db.js";
+export type { RecorderEvent } from "../../wire/index.js";
+export type GitHubCloneDatabase = TwinDatabase;
+export type GitHubStateSeed = {
+    users?: SeedUser[];
+    repositories: SeedRepository[];
+};
+export type SeedUser = {
+    login: string;
+    type?: "User" | "Organization";
+    name?: string;
+};
+export type SeedRepository = {
+    owner: string;
+    name: string;
+    description?: string;
+    private?: boolean;
+    default_branch?: string;
+    collaborators?: string[];
+    labels?: Array<{
+        name: string;
+        color?: string;
+        description?: string;
+    }>;
+    files?: Array<{
+        path: string;
+        content: string;
+        branch?: string;
+    }>;
+    issues?: Array<{
+        number?: number;
+        title: string;
+        body?: string;
+        state?: "open" | "closed";
+        labels?: string[];
+        assignees?: string[];
+    }>;
+    pull_requests?: Array<{
+        number?: number;
+        title: string;
+        body?: string;
+        head: string;
+        base?: string;
+        state?: "open" | "closed";
+        author?: string;
+        reviews?: Array<{
+            author: string;
+            state?: "APPROVED" | "CHANGES_REQUESTED" | "COMMENTED";
+            body?: string;
+        }>;
+        statuses?: Array<{
+            context?: string;
+            state?: "error" | "failure" | "pending" | "success";
+            description?: string;
+        }>;
+    }>;
+};
+export type RepoRow = {
+    id: number;
+    owner: string;
+    name: string;
+    full_name: string;
+    description: string;
+    private: 0 | 1;
+    default_branch: string;
+    fork: 0 | 1;
+    parent_full_name: string | null;
+    entity_counter: number;
+    created_at: string;
+    updated_at: string;
+};
+export type BranchRow = {
+    id: number;
+    repo_id: number;
+    name: string;
+    head_sha: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export type CommitRow = {
+    sha: string;
+    repo_id: number;
+    message: string;
+    author_login: string;
+    committer_login: string;
+    parent_sha: string | null;
+    tree_sha: string;
+    created_at: string;
+};
+export type FileRow = {
+    repo_id: number;
+    branch: string;
+    path: string;
+    content: string;
+    sha: string;
+    size: number;
+    updated_at: string;
+};
+export type LabelRow = {
+    repo_id: number;
+    name: string;
+    color: string;
+    description: string;
+};
+export type IssueRow = {
+    repo_id: number;
+    number: number;
+    title: string;
+    body: string;
+    state: "open" | "closed";
+    user_login: string;
+    assignee_login: string | null;
+    created_at: string;
+    updated_at: string;
+    closed_at: string | null;
+};
+export type IssueCommentRow = {
+    id: number;
+    repo_id: number;
+    issue_number: number;
+    body: string;
+    user_login: string;
+    created_at: string;
+    updated_at: string;
+};
+export type PullRequestRow = {
+    repo_id: number;
+    number: number;
+    title: string;
+    body: string;
+    state: "open" | "closed";
+    user_login: string;
+    head_repo_id: number;
+    head_ref: string;
+    head_sha: string | null;
+    base_repo_id: number;
+    base_ref: string;
+    base_sha: string | null;
+    merged: 0 | 1;
+    merge_commit_sha: string | null;
+    created_at: string;
+    updated_at: string;
+    closed_at: string | null;
+    merged_at: string | null;
+};
+export type PullRequestReviewRow = {
+    id: number;
+    repo_id: number;
+    pull_number: number;
+    user_login: string;
+    state: "APPROVED" | "CHANGES_REQUESTED" | "COMMENTED";
+    body: string;
+    commit_sha: string | null;
+    submitted_at: string;
+};
+export type PullRequestFileRow = {
+    repo_id: number;
+    pull_number: number;
+    filename: string;
+    status: "added" | "modified" | "removed" | "renamed";
+    additions: number;
+    deletions: number;
+    changes: number;
+    blob_url: string;
+    raw_url: string;
+    contents_url: string;
+    patch: string;
+};
+export type CommitStatusRow = {
+    id: number;
+    repo_id: number;
+    sha: string;
+    state: "error" | "failure" | "pending" | "success";
+    context: string;
+    description: string;
+    target_url: string;
+    created_at: string;
+    updated_at: string;
+};
+export type MilestoneRow = {
+    repo_id: number;
+    number: number;
+    title: string;
+    state: "open" | "closed";
+    description: string;
+    due_on: string | null;
+    creator_login: string;
+    created_at: string;
+    updated_at: string;
+    closed_at: string | null;
+};
+export type TagRow = {
+    repo_id: number;
+    name: string;
+    commit_sha: string;
+    created_at: string;
+};
+export type ReleaseRow = {
+    id: number;
+    repo_id: number;
+    tag_name: string;
+    target_commitish: string;
+    name: string | null;
+    body: string;
+    draft: 0 | 1;
+    prerelease: 0 | 1;
+    author_login: string;
+    created_at: string;
+    published_at: string | null;
+};
+export type CheckRunRow = {
+    id: number;
+    repo_id: number;
+    head_sha: string;
+    name: string;
+    status: "queued" | "in_progress" | "completed";
+    conclusion: "success" | "failure" | "neutral" | "cancelled" | "timed_out" | "action_required" | "skipped" | "stale" | null;
+    details_url: string;
+    external_id: string;
+    output_title: string | null;
+    output_summary: string | null;
+    started_at: string;
+    completed_at: string | null;
+};
+export type PullRequestReviewCommentRow = {
+    id: number;
+    repo_id: number;
+    pull_number: number;
+    path: string;
+    body: string;
+    user_login: string;
+    created_at: string;
+    updated_at: string;
+    line: number | null;
+    side: "LEFT" | "RIGHT" | null;
+    commit_sha: string | null;
+    in_reply_to_id: number | null;
+};
+export type CollaboratorRow = {
+    repo_id: number;
+    login: string;
+    permission: string;
+    invitation_state: "pending" | "accepted";
+};

package/dist/_types/twin-gmail/src/check-kind.d.ts

@@ -0,0 +1,3 @@
+import type { CheckDefinition } from "../../sdk/checks.js";
+import type { GmailCheckState } from "./check-state.js";
+export type Check<TArgs extends Record<string, string>> = CheckDefinition<GmailCheckState, TArgs>;

package/dist/_types/twin-gmail/src/check-state.d.ts

@@ -0,0 +1,138 @@
+import { type CheckOutcome } from "../../sdk/checks.js";
+/** A resolver must be able to say WHY it found nothing: the ways of finding
+ *  nothing get different verdicts. Same shape and same reason as twin-github's.
+ *
+ *  F-1197 added the pointers, also twin-github's: `path` is where the resolution
+ *  landed, `searched` is the collection a failed lookup scanned. Both optional on
+ *  the missing arm because gmail's commonest refusal is `state_incomplete` — the
+ *  collection is absent from the export entirely, so there is nowhere to point
+ *  and citing anything would be an affordance to nowhere. */
+export type Resolved<T> = {
+    found: T;
+    path: string;
+} | {
+    missing: string;
+    searched?: string;
+};
+/** The exported collections a pointer can address. Named because six
+ *  declarations reach for them and a literal `"/messageLabels"` typed out six
+ *  times is six chances to typo one into a pointer that resolves to nothing —
+ *  and the mis-cased `/messagelabels` would look right in a diff. */
+export declare const MESSAGES_PATH: string;
+export declare const DRAFTS_PATH: string;
+export declare const LABELS_PATH: string;
+export declare const MESSAGE_LABELS_PATH: string;
+/** The `skipped` outcome an unresolvable lookup produces, citing where it
+ *  looked. Gmail abstains where twin-github fails — a message the export does
+ *  not carry cannot be attested either way — so this is `missOutcome` with
+ *  `skipped`, exactly as twin-slack's `missSkip` is. */
+export declare function missSkip(miss: {
+    missing: string;
+    searched?: string;
+}): CheckOutcome;
+export interface GmailCheckStateMailbox {
+    email?: string;
+    displayName?: string;
+}
+export interface GmailCheckStateMessage {
+    mailboxEmail?: string;
+    id?: string;
+    threadId?: string;
+    from?: string;
+    to?: string[] | null;
+    cc?: string[] | null;
+    bcc?: string[] | null;
+    subject?: string;
+    bodyOmitted?: boolean;
+}
+export interface GmailCheckStateLabel {
+    mailboxEmail?: string;
+    id?: string;
+    name?: string;
+    type?: string;
+}
+export interface GmailCheckStateMessageLabel {
+    mailboxEmail?: string;
+    messageId?: string;
+    labelId?: string;
+}
+export interface GmailCheckStateDraft {
+    mailboxEmail?: string;
+    id?: string;
+    messageId?: string;
+}
+export interface GmailCheckStateBounds {
+    messageBodiesOmitted?: boolean;
+    largeMailbox?: boolean;
+    truncatedCollections?: string[] | null;
+}
+export interface GmailCheckState {
+    mailboxes?: GmailCheckStateMailbox[] | null;
+    messages?: GmailCheckStateMessage[] | null;
+    drafts?: GmailCheckStateDraft[] | null;
+    labels?: GmailCheckStateLabel[] | null;
+    messageLabels?: GmailCheckStateMessageLabel[] | null;
+    exportBounds?: GmailCheckStateBounds | null;
+}
+/**
+ * Was this collection capped on the way out?
+ *
+ * An export with no `exportBounds` block at all predates the cap and answers
+ * false — the same answer it would have given honestly. Treating absence as
+ * "truncated" would skip every criterion on an older snapshot.
+ */
+export declare function isTruncated(state: GmailCheckState, collection: string): boolean;
+/**
+ * The message a criterion names, with the outcomes a negative criterion must
+ * tell apart:
+ *   - no `messages` key → `state_incomplete`; we cannot attest anything
+ *   - present, id absent, collection CAPPED → `collection_truncated`; absent from
+ *     a truncated list is not absent, and answering `not_found` here would
+ *     false-fail a correct agent on a large mailbox
+ *   - present, id absent, not capped → `message_not_found`
+ *   - present in more than one mailbox → `message_ambiguous`
+ *
+ * The ambiguity arm is gmail's answer to github's `{repo}` slot. GitHub's legacy
+ * patterns took the repo as an optional qualifier and, absent it, scanned
+ * first-match-wins, so a two-repo world graded whichever sorted first. Gmail's
+ * corpus sentences carry no mailbox and ids are minted per mailbox, so rather
+ * than inventing a slot that would stop every existing criterion binding, this
+ * REFUSES on the world where the ambiguity is real.
+ */
+export declare function resolveMessage(state: GmailCheckState, id: string): Resolved<GmailCheckStateMessage>;
+/**
+ * Every label id that counts as `wanted`, lower-cased for comparison.
+ *
+ * Matches a label row by id OR by display name, because the corpus names both
+ * kinds: `Label_follow_up` is an id, `Follow Up` is the name of the same label.
+ * The bare `wanted` is always included so the join still works when the `labels`
+ * collection was capped away — a `messageLabels` row carries the bare id
+ * regardless.
+ */
+export declare function labelIdsFor(state: GmailCheckState, wanted: string): Set<string>;
+/**
+ * Does this message carry the named label?
+ *
+ * Reads the `messageLabels` join. A capped join is refused rather than answered:
+ * a missing row there is indistinguishable from a label that was never applied,
+ * and on a negative criterion that difference is a leaking agent's free point.
+ */
+export declare function messageCarriesLabel(state: GmailCheckState, messageId: string, wanted: string): Resolved<boolean>;
+/**
+ * The label a criterion names BY NAME.
+ *
+ * Deliberately does not fall back to the id. "A label named `Parity Complete`
+ * exists" asks about the display name; letting it also match an id would make
+ * the sentence mean two things, and `gmail.message-has-label` is the check that
+ * speaks ids.
+ */
+export declare function resolveLabelByName(state: GmailCheckState, name: string): Resolved<GmailCheckStateLabel>;
+/**
+ * Who a draft is addressed to — `to` + `cc`, from the backing MESSAGE.
+ *
+ * The exported draft row carries no addressing at all, so a predicate reading it
+ * alone would answer "no draft is addressed to anyone", always. A draft whose
+ * message did not survive the export contributes nothing rather than throwing;
+ * the caller decides whether that emptiness is answerable.
+ */
+export declare function draftRecipients(state: GmailCheckState, draft: GmailCheckStateDraft): string[];

package/dist/_types/twin-gmail/src/checks.d.ts

@@ -0,0 +1,19 @@
+export type { Check } from "./check-kind.js";
+export type { GmailCheckState, GmailCheckStateDraft, GmailCheckStateLabel, GmailCheckStateMailbox, GmailCheckStateMessage, GmailCheckStateMessageLabel, } from "./check-state.js";
+export declare const GMAIL_CHECKS: readonly [import("./check-kind.js").Check<{
+    message: string;
+    label: string;
+}>, import("./check-kind.js").Check<{
+    label: string;
+}>, import("./check-kind.js").Check<{
+    email: string;
+}>, import("./check-kind.js").Check<{
+    count: string;
+}>, import("./check-kind.js").Check<{
+    mailbox: string;
+    count: string;
+    label: string;
+}>, import("./check-kind.js").Check<{
+    label: string;
+    count: string;
+}>, import("./check-kind.js").Check<Record<string, never>>];

package/dist/_types/twin-gmail/src/faults.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { GmailTwinDatabase } from "./types.js";
+export declare const gmailFaultSchema: z.ZodObject<{
+    name: z.ZodEnum<{
+        "rate-limited": "rate-limited";
+    }>;
+    target: z.ZodDefault<z.ZodString>;
+    succeedFirst: z.ZodDefault<z.ZodNumber>;
+    throttleFor: z.ZodDefault<z.ZodNumber>;
+    retryAfterSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type GmailFault = z.output<typeof gmailFaultSchema>;
+/**
+ * Increment the per-operation call counter and, if a `rate-limited` fault is
+ * armed for `operation`, throw a 429 during the throttle window. Deterministic
+ * and clock-free: calls 1..succeedFirst pass, the next `throttleFor` calls
+ * throw, every call after passes. EVERY matching call (including throttled
+ * ones) advances the counter, so an agent that retries with backoff clears the
+ * window while one that doesn't leaves those sends undelivered.
+ */
+export declare function checkFault(db: GmailTwinDatabase, operation: string): void;

package/dist/_types/twin-gmail/src/seed.d.ts

@@ -0,0 +1,247 @@
+import { z } from "zod";
+import type { GmailStateSeed, SeedMailbox } from "./types.js";
+export declare const gmailSeedSchema: z.ZodObject<{
+    primaryMailbox: z.ZodObject<{
+        email: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        displayName: z.ZodDefault<z.ZodString>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            color: z.ZodOptional<z.ZodObject<{
+                textColor: z.ZodOptional<z.ZodString>;
+                backgroundColor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        messages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            id: z.ZodOptional<z.ZodString>;
+            threadId: z.ZodOptional<z.ZodString>;
+            raw: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            to: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            cc: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            bcc: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            subject: z.ZodDefault<z.ZodString>;
+            text: z.ZodDefault<z.ZodString>;
+            html: z.ZodDefault<z.ZodString>;
+            date: z.ZodOptional<z.ZodString>;
+            messageId: z.ZodOptional<z.ZodString>;
+            inReplyTo: z.ZodOptional<z.ZodString>;
+            references: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            attachments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                filename: z.ZodString;
+                mimeType: z.ZodDefault<z.ZodString>;
+                disposition: z.ZodDefault<z.ZodEnum<{
+                    attachment: "attachment";
+                    inline: "inline";
+                }>>;
+                contentId: z.ZodOptional<z.ZodString>;
+                data: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        drafts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            threadId: z.ZodOptional<z.ZodString>;
+            raw: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            to: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            cc: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            bcc: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            subject: z.ZodDefault<z.ZodString>;
+            text: z.ZodDefault<z.ZodString>;
+            html: z.ZodDefault<z.ZodString>;
+            date: z.ZodOptional<z.ZodString>;
+            messageId: z.ZodOptional<z.ZodString>;
+            inReplyTo: z.ZodOptional<z.ZodString>;
+            references: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            attachments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                filename: z.ZodString;
+                mimeType: z.ZodDefault<z.ZodString>;
+                disposition: z.ZodDefault<z.ZodEnum<{
+                    attachment: "attachment";
+                    inline: "inline";
+                }>>;
+                contentId: z.ZodOptional<z.ZodString>;
+                data: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        filters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            criteria: z.ZodDefault<z.ZodObject<{
+                from: z.ZodOptional<z.ZodString>;
+                to: z.ZodOptional<z.ZodString>;
+                subject: z.ZodOptional<z.ZodString>;
+                query: z.ZodOptional<z.ZodString>;
+                negatedQuery: z.ZodOptional<z.ZodString>;
+                hasAttachment: z.ZodOptional<z.ZodBoolean>;
+                excludeChats: z.ZodOptional<z.ZodBoolean>;
+                size: z.ZodOptional<z.ZodNumber>;
+                sizeComparison: z.ZodOptional<z.ZodEnum<{
+                    larger: "larger";
+                    smaller: "smaller";
+                }>>;
+            }, z.core.$strict>>;
+            action: z.ZodDefault<z.ZodObject<{
+                addLabelIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                removeLabelIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                forward: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            verificationStatus: z.ZodDefault<z.ZodEnum<{
+                accepted: "accepted";
+                pending: "pending";
+            }>>;
+        }, z.core.$strict>>>;
+        sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            sendAsEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            displayName: z.ZodDefault<z.ZodString>;
+            replyToAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            isPrimary: z.ZodDefault<z.ZodBoolean>;
+            isDefault: z.ZodDefault<z.ZodBoolean>;
+            verificationStatus: z.ZodDefault<z.ZodEnum<{
+                accepted: "accepted";
+                pending: "pending";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    mailboxes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        email: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        displayName: z.ZodDefault<z.ZodString>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            color: z.ZodOptional<z.ZodObject<{
+                textColor: z.ZodOptional<z.ZodString>;
+                backgroundColor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        messages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            id: z.ZodOptional<z.ZodString>;
+            threadId: z.ZodOptional<z.ZodString>;
+            raw: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            to: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            cc: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            bcc: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            subject: z.ZodDefault<z.ZodString>;
+            text: z.ZodDefault<z.ZodString>;
+            html: z.ZodDefault<z.ZodString>;
+            date: z.ZodOptional<z.ZodString>;
+            messageId: z.ZodOptional<z.ZodString>;
+            inReplyTo: z.ZodOptional<z.ZodString>;
+            references: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            attachments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                filename: z.ZodString;
+                mimeType: z.ZodDefault<z.ZodString>;
+                disposition: z.ZodDefault<z.ZodEnum<{
+                    attachment: "attachment";
+                    inline: "inline";
+                }>>;
+                contentId: z.ZodOptional<z.ZodString>;
+                data: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        drafts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            threadId: z.ZodOptional<z.ZodString>;
+            raw: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            to: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            cc: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            bcc: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            subject: z.ZodDefault<z.ZodString>;
+            text: z.ZodDefault<z.ZodString>;
+            html: z.ZodDefault<z.ZodString>;
+            date: z.ZodOptional<z.ZodString>;
+            messageId: z.ZodOptional<z.ZodString>;
+            inReplyTo: z.ZodOptional<z.ZodString>;
+            references: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            attachments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                filename: z.ZodString;
+                mimeType: z.ZodDefault<z.ZodString>;
+                disposition: z.ZodDefault<z.ZodEnum<{
+                    attachment: "attachment";
+                    inline: "inline";
+                }>>;
+                contentId: z.ZodOptional<z.ZodString>;
+                data: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        filters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            criteria: z.ZodDefault<z.ZodObject<{
+                from: z.ZodOptional<z.ZodString>;
+                to: z.ZodOptional<z.ZodString>;
+                subject: z.ZodOptional<z.ZodString>;
+                query: z.ZodOptional<z.ZodString>;
+                negatedQuery: z.ZodOptional<z.ZodString>;
+                hasAttachment: z.ZodOptional<z.ZodBoolean>;
+                excludeChats: z.ZodOptional<z.ZodBoolean>;
+                size: z.ZodOptional<z.ZodNumber>;
+                sizeComparison: z.ZodOptional<z.ZodEnum<{
+                    larger: "larger";
+                    smaller: "smaller";
+                }>>;
+            }, z.core.$strict>>;
+            action: z.ZodDefault<z.ZodObject<{
+                addLabelIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                removeLabelIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                forward: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        forwardingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            forwardingEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            verificationStatus: z.ZodDefault<z.ZodEnum<{
+                accepted: "accepted";
+                pending: "pending";
+            }>>;
+        }, z.core.$strict>>>;
+        sendAs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            sendAsEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            displayName: z.ZodDefault<z.ZodString>;
+            replyToAddress: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            isPrimary: z.ZodDefault<z.ZodBoolean>;
+            isDefault: z.ZodDefault<z.ZodBoolean>;
+            verificationStatus: z.ZodDefault<z.ZodEnum<{
+                accepted: "accepted";
+                pending: "pending";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    deliveryMode: z.ZodDefault<z.ZodEnum<{
+        "sender-only": "sender-only";
+        "seeded-mailboxes": "seeded-mailboxes";
+    }>>;
+    clock: z.ZodDefault<z.ZodString>;
+    faults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodEnum<{
+            "rate-limited": "rate-limited";
+        }>;
+        target: z.ZodDefault<z.ZodString>;
+        succeedFirst: z.ZodDefault<z.ZodNumber>;
+        throttleFor: z.ZodDefault<z.ZodNumber>;
+        retryAfterSeconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ParsedGmailStateSeed = z.output<typeof gmailSeedSchema>;
+export declare function parseSeed(input: unknown): ParsedGmailStateSeed;
+/**
+ * `Record<string, string | undefined>` rather than `NodeJS.ProcessEnv`, which is
+ * structurally the same thing but an AMBIENT global. This signature is vendored
+ * into `@pome-sh/checks`'s published declarations, and an ambient reference there
+ * makes a consumer's `tsc` fail with TS2503 unless they happen to have
+ * `@types/node` installed — a dependency this package should not impose to
+ * describe a plain string map.
+ */
+export declare function loadSeedFromEnv(env?: Record<string, string | undefined>): ParsedGmailStateSeed;
+/** Primary agent mailbox used by default / scenario seeds. */
+export declare const DEFAULT_GMAIL_AGENT_EMAIL = "pome-agent@pome-twin.test";
+/**
+ * Multi-thread inbox used by `defaultSeedState` and CLI Gmail scenarios:
+ * welcome, build (+ reply), unread support, and an unsent draft.
+ */
+export declare function agentPathInboxMailbox(email?: string): SeedMailbox;
+export declare function defaultSeedState(): GmailStateSeed;