pr-merge-queue 0.0.0-stage → 0.0.0

package/dist/unblock-prs/github.d.mts

@@ -0,0 +1,739 @@
+/**
+ * Everything that reads or writes GitHub or `git`, and nothing that decides.
+ * The API client and the `git` runner are shared with the other commands
+ * (`tools/scripts/lib/`).
+ */
+import { type CheckRunReport, type Claim, type NativeStackEntry, type ReviewState, type RulesetRequirements } from 'pr-report-core';
+import { Result } from 'ts-data-forge';
+import * as t from 'ts-fortress';
+import { type ApiContext } from '../lib/index.mjs';
+import { type BaseChange, type IssueOrder, type OwnSetAsideComment, type PullRequest } from './types.mjs';
+/**
+ * The credential and the repository every call here takes, and the branch
+ * the queue lands on. `repoOption` is `--repo owner/name`, when given.
+ */
+export declare const checkPreflight: (repoOption: string | undefined) => Promise<Result<Readonly<{
+    api: ApiContext;
+    defaultBranch: string;
+}>, string>>;
+/**
+ * The open pull requests, newest first, at most {@link OPEN_LIMIT} of them
+ * as `gh pr list` read. GraphQL, because `mergeStateStatus` is not in REST.
+ */
+export declare const listPullRequests: (api: ApiContext) => Promise<Result<readonly PullRequest[], string>>;
+export declare const viewPullRequest: (api: ApiContext, prNumber: number) => Promise<Result<PullRequest, string>>;
+/**
+ * `REVIEW_REQUIRED`, `CHANGES_REQUESTED`, `APPROVED`, or empty when the
+ * rules ask for no review. Read only when a green pull request will not
+ * merge, to say what holds it.
+ */
+export declare const viewReviewDecision: (api: ApiContext, prNumber: number) => Promise<Result<string, string>>;
+/**
+ * A pull request as GraphQL answers it, in the shape every module here reads
+ * ({@link PullRequestSchema}): only the labels differ, a connection there and
+ * a list here.
+ */
+export declare const pullRequestOfNode: (node: t.TypeOf<typeof PullRequestNodeSchema>) => PullRequest;
+declare const PullRequestNodeSchema: Readonly<{
+    typeName: string;
+    defaultValue: Readonly<{
+        autoMergeRequest: unknown;
+        baseRefName: string;
+        body: string;
+        headRefName: string;
+        headRefOid: string;
+        id: string;
+        isCrossRepository: boolean;
+        isDraft: boolean;
+        labels: Readonly<{
+            nodes: readonly Readonly<{
+                name: string;
+            }>[];
+        }>;
+        mergeStateStatus: string;
+        number: number;
+        state: string;
+        title: string;
+    }>;
+    is: (a: unknown) => a is Readonly<{
+        autoMergeRequest: unknown;
+        baseRefName: string;
+        body: string;
+        headRefName: string;
+        headRefOid: string;
+        id: string;
+        isCrossRepository: boolean;
+        isDraft: boolean;
+        labels: Readonly<{
+            nodes: readonly Readonly<{
+                name: string;
+            }>[];
+        }>;
+        mergeStateStatus: string;
+        number: number;
+        state: string;
+        title: string;
+    }>;
+    assertIs: (a: unknown) => asserts a is Readonly<{
+        autoMergeRequest: unknown;
+        baseRefName: string;
+        body: string;
+        headRefName: string;
+        headRefOid: string;
+        id: string;
+        isCrossRepository: boolean;
+        isDraft: boolean;
+        labels: Readonly<{
+            nodes: readonly Readonly<{
+                name: string;
+            }>[];
+        }>;
+        mergeStateStatus: string;
+        number: number;
+        state: string;
+        title: string;
+    }>;
+    cast: (a: unknown) => Readonly<{
+        autoMergeRequest: unknown;
+        baseRefName: string;
+        body: string;
+        headRefName: string;
+        headRefOid: string;
+        id: string;
+        isCrossRepository: boolean;
+        isDraft: boolean;
+        labels: Readonly<{
+            nodes: readonly Readonly<{
+                name: string;
+            }>[];
+        }>;
+        mergeStateStatus: string;
+        number: number;
+        state: string;
+        title: string;
+    }>;
+    fill: (a: unknown) => Readonly<{
+        autoMergeRequest: unknown;
+        baseRefName: string;
+        body: string;
+        headRefName: string;
+        headRefOid: string;
+        id: string;
+        isCrossRepository: boolean;
+        isDraft: boolean;
+        labels: Readonly<{
+            nodes: readonly Readonly<{
+                name: string;
+            }>[];
+        }>;
+        mergeStateStatus: string;
+        number: number;
+        state: string;
+        title: string;
+    }>;
+    prune: <B extends Readonly<{
+        autoMergeRequest: unknown;
+        baseRefName: string;
+        body: string;
+        headRefName: string;
+        headRefOid: string;
+        id: string;
+        isCrossRepository: boolean;
+        isDraft: boolean;
+        labels: Readonly<{
+            nodes: readonly Readonly<{
+                name: string;
+            }>[];
+        }>;
+        mergeStateStatus: string;
+        number: number;
+        state: string;
+        title: string;
+    }>>(a: B) => Readonly<{
+        autoMergeRequest: unknown;
+        baseRefName: string;
+        body: string;
+        headRefName: string;
+        headRefOid: string;
+        id: string;
+        isCrossRepository: boolean;
+        isDraft: boolean;
+        labels: Readonly<{
+            nodes: readonly Readonly<{
+                name: string;
+            }>[];
+        }>;
+        mergeStateStatus: string;
+        number: number;
+        state: string;
+        title: string;
+    }>;
+    validate: (a: unknown) => Result<Readonly<{
+        autoMergeRequest: unknown;
+        baseRefName: string;
+        body: string;
+        headRefName: string;
+        headRefOid: string;
+        id: string;
+        isCrossRepository: boolean;
+        isDraft: boolean;
+        labels: Readonly<{
+            nodes: readonly Readonly<{
+                name: string;
+            }>[];
+        }>;
+        mergeStateStatus: string;
+        number: number;
+        state: string;
+        title: string;
+    }>, readonly Readonly<{
+        path: readonly string[];
+        actualValue: unknown;
+        expectedType: string;
+        typeName: string;
+        details?: t.ValidationErrorDetails | undefined;
+    }>[]>;
+    structure?: t.TypeStructure;
+    annotations?: t.TypeAnnotations;
+    optional?: true;
+}> & Readonly<{
+    shape: {
+        readonly number: t.ConstrainedType<number, Readonly<{
+            readonly finite: undefined;
+            readonly int: undefined;
+            readonly safeInteger: undefined;
+            readonly nonZero: undefined;
+            readonly negative: undefined;
+            readonly nonNegative: undefined;
+            readonly positive: undefined;
+            readonly nonPositive: undefined;
+            readonly gt: undefined;
+            readonly gte: undefined;
+            readonly min: undefined;
+            readonly lt: undefined;
+            readonly lte: undefined;
+            readonly max: undefined;
+            readonly multipleOf: undefined;
+            readonly step: undefined;
+        }>>;
+        readonly id: t.ConstrainedType<string, Readonly<{
+            readonly nonempty: undefined;
+            readonly minLength: undefined;
+            readonly maxLength: undefined;
+            readonly startsWith: undefined;
+            readonly endsWith: undefined;
+            readonly includes: undefined;
+            readonly uppercase: undefined;
+            readonly lowercase: undefined;
+            readonly regex: undefined;
+        }>>;
+        readonly title: t.ConstrainedType<string, Readonly<{
+            readonly nonempty: undefined;
+            readonly minLength: undefined;
+            readonly maxLength: undefined;
+            readonly startsWith: undefined;
+            readonly endsWith: undefined;
+            readonly includes: undefined;
+            readonly uppercase: undefined;
+            readonly lowercase: undefined;
+            readonly regex: undefined;
+        }>>;
+        readonly body: t.ConstrainedType<string, Readonly<{
+            readonly nonempty: undefined;
+            readonly minLength: undefined;
+            readonly maxLength: undefined;
+            readonly startsWith: undefined;
+            readonly endsWith: undefined;
+            readonly includes: undefined;
+            readonly uppercase: undefined;
+            readonly lowercase: undefined;
+            readonly regex: undefined;
+        }>>;
+        readonly state: t.ConstrainedType<string, Readonly<{
+            readonly nonempty: undefined;
+            readonly minLength: undefined;
+            readonly maxLength: undefined;
+            readonly startsWith: undefined;
+            readonly endsWith: undefined;
+            readonly includes: undefined;
+            readonly uppercase: undefined;
+            readonly lowercase: undefined;
+            readonly regex: undefined;
+        }>>;
+        readonly headRefName: t.ConstrainedType<string, Readonly<{
+            readonly nonempty: undefined;
+            readonly minLength: undefined;
+            readonly maxLength: undefined;
+            readonly startsWith: undefined;
+            readonly endsWith: undefined;
+            readonly includes: undefined;
+            readonly uppercase: undefined;
+            readonly lowercase: undefined;
+            readonly regex: undefined;
+        }>>;
+        readonly headRefOid: t.ConstrainedType<string, Readonly<{
+            readonly nonempty: undefined;
+            readonly minLength: undefined;
+            readonly maxLength: undefined;
+            readonly startsWith: undefined;
+            readonly endsWith: undefined;
+            readonly includes: undefined;
+            readonly uppercase: undefined;
+            readonly lowercase: undefined;
+            readonly regex: undefined;
+        }>>;
+        readonly baseRefName: t.ConstrainedType<string, Readonly<{
+            readonly nonempty: undefined;
+            readonly minLength: undefined;
+            readonly maxLength: undefined;
+            readonly startsWith: undefined;
+            readonly endsWith: undefined;
+            readonly includes: undefined;
+            readonly uppercase: undefined;
+            readonly lowercase: undefined;
+            readonly regex: undefined;
+        }>>;
+        readonly isCrossRepository: Readonly<{
+            typeName: string;
+            defaultValue: boolean;
+            is: (a: unknown) => a is boolean;
+            assertIs: (a: unknown) => asserts a is boolean;
+            cast: (a: unknown) => boolean;
+            fill: (a: unknown) => boolean;
+            prune: <B extends boolean>(a: B) => boolean;
+            validate: (a: unknown) => Result<boolean, readonly Readonly<{
+                path: readonly string[];
+                actualValue: unknown;
+                expectedType: string;
+                typeName: string;
+                details?: t.ValidationErrorDetails | undefined;
+            }>[]>;
+            structure?: t.TypeStructure;
+            annotations?: t.TypeAnnotations;
+            optional?: true;
+        }>;
+        readonly isDraft: Readonly<{
+            typeName: string;
+            defaultValue: boolean;
+            is: (a: unknown) => a is boolean;
+            assertIs: (a: unknown) => asserts a is boolean;
+            cast: (a: unknown) => boolean;
+            fill: (a: unknown) => boolean;
+            prune: <B extends boolean>(a: B) => boolean;
+            validate: (a: unknown) => Result<boolean, readonly Readonly<{
+                path: readonly string[];
+                actualValue: unknown;
+                expectedType: string;
+                typeName: string;
+                details?: t.ValidationErrorDetails | undefined;
+            }>[]>;
+            structure?: t.TypeStructure;
+            annotations?: t.TypeAnnotations;
+            optional?: true;
+        }>;
+        readonly mergeStateStatus: t.ConstrainedType<string, Readonly<{
+            readonly nonempty: undefined;
+            readonly minLength: undefined;
+            readonly maxLength: undefined;
+            readonly startsWith: undefined;
+            readonly endsWith: undefined;
+            readonly includes: undefined;
+            readonly uppercase: undefined;
+            readonly lowercase: undefined;
+            readonly regex: undefined;
+        }>>;
+        readonly autoMergeRequest: Readonly<{
+            typeName: string;
+            defaultValue: unknown;
+            is: (a: unknown) => a is unknown;
+            assertIs: (a: unknown) => asserts a is unknown;
+            cast: (a: unknown) => unknown;
+            fill: (a: unknown) => unknown;
+            prune: <B extends unknown>(a: B) => unknown;
+            validate: (a: unknown) => Result<unknown, readonly Readonly<{
+                path: readonly string[];
+                actualValue: unknown;
+                expectedType: string;
+                typeName: string;
+                details?: t.ValidationErrorDetails | undefined;
+            }>[]>;
+            structure?: t.TypeStructure;
+            annotations?: t.TypeAnnotations;
+            optional?: true;
+        }>;
+        readonly labels: Readonly<{
+            typeName: string;
+            defaultValue: Readonly<{
+                nodes: readonly Readonly<{
+                    name: string;
+                }>[];
+            }>;
+            is: (a: unknown) => a is Readonly<{
+                nodes: readonly Readonly<{
+                    name: string;
+                }>[];
+            }>;
+            assertIs: (a: unknown) => asserts a is Readonly<{
+                nodes: readonly Readonly<{
+                    name: string;
+                }>[];
+            }>;
+            cast: (a: unknown) => Readonly<{
+                nodes: readonly Readonly<{
+                    name: string;
+                }>[];
+            }>;
+            fill: (a: unknown) => Readonly<{
+                nodes: readonly Readonly<{
+                    name: string;
+                }>[];
+            }>;
+            prune: <B extends Readonly<{
+                nodes: readonly Readonly<{
+                    name: string;
+                }>[];
+            }>>(a: B) => Readonly<{
+                nodes: readonly Readonly<{
+                    name: string;
+                }>[];
+            }>;
+            validate: (a: unknown) => Result<Readonly<{
+                nodes: readonly Readonly<{
+                    name: string;
+                }>[];
+            }>, readonly Readonly<{
+                path: readonly string[];
+                actualValue: unknown;
+                expectedType: string;
+                typeName: string;
+                details?: t.ValidationErrorDetails | undefined;
+            }>[]>;
+            structure?: t.TypeStructure;
+            annotations?: t.TypeAnnotations;
+            optional?: true;
+        }> & Readonly<{
+            shape: {
+                readonly nodes: Readonly<{
+                    typeName: string;
+                    defaultValue: readonly Readonly<{
+                        name: string;
+                    }>[];
+                    is: (a: unknown) => a is readonly Readonly<{
+                        name: string;
+                    }>[];
+                    assertIs: (a: unknown) => asserts a is readonly Readonly<{
+                        name: string;
+                    }>[];
+                    cast: (a: unknown) => readonly Readonly<{
+                        name: string;
+                    }>[];
+                    fill: (a: unknown) => readonly Readonly<{
+                        name: string;
+                    }>[];
+                    prune: <B extends readonly Readonly<{
+                        name: string;
+                    }>[]>(a: B) => readonly Readonly<{
+                        name: string;
+                    }>[];
+                    validate: (a: unknown) => Result<readonly Readonly<{
+                        name: string;
+                    }>[], readonly Readonly<{
+                        path: readonly string[];
+                        actualValue: unknown;
+                        expectedType: string;
+                        typeName: string;
+                        details?: t.ValidationErrorDetails | undefined;
+                    }>[]>;
+                    structure?: t.TypeStructure;
+                    annotations?: t.TypeAnnotations;
+                    optional?: true;
+                }>;
+            };
+        }>;
+    };
+}>;
+/**
+ * The tip of `branch` on `origin`, by its whole ref name
+ * (`headShaFromListing`): the default branch read as the version pull
+ * request's branch is a set-aside recorded against a base that never moves.
+ */
+export declare const remoteSha: (branch: string) => Promise<Result<string, string>>;
+/**
+ * What GitHub enforces on the branch, every ruleset that applies to it
+ * together — rather than what `repo-settings/` declares, which changes
+ * nothing until it is applied.
+ */
+export declare const readBranchRules: (api: ApiContext, branch: string) => Promise<Result<RulesetRequirements, string>>;
+/**
+ * `CODEOWNERS` on the default branch, and what `pr-report-core`'s
+ * `review-hold.mts` reads about each of `numbers`, in one GraphQL request.
+ * `undefined` for a repository without `.github/CODEOWNERS`, the one of the
+ * three places GitHub looks that this repository uses.
+ *
+ * Every number goes in as a variable, and each pull request comes back under
+ * its own alias.
+ */
+export declare const readReviewStates: (api: ApiContext, numbers: readonly number[], defaultBranch: string) => Promise<Result<Readonly<{
+    codeOwners: string | undefined;
+    states: ReadonlyMap<number, ReviewState>;
+}>, string>>;
+/**
+ * What the issues the open pull requests close add to the merge order
+ * (`merge-after.mts`'s `issueOrderOf`): one GraphQL request for what GitHub
+ * links and how it marked the bodies, and one more for the keyword-closed
+ * issues it did not link, only when there are any.
+ */
+export declare const readIssueOrder: (api: ApiContext, numbers: readonly number[]) => Promise<Result<IssueOrder, string>>;
+export declare const addSkipCiLabel: (api: ApiContext, prNumber: number) => Promise<Result<undefined, string>>;
+/**
+ * This account's set-aside comment on each of `numbers` that has one. See
+ * {@link readOwnComments}.
+ */
+export declare const readSetAsideComments: (api: ApiContext, numbers: readonly number[]) => Promise<Result<ReadonlyMap<number, OwnSetAsideComment>, string>>;
+/**
+ * This account's set-aside comment, and the standing claim a session wrote
+ * (`claims.mts`), on each of `numbers` that has one, in one GraphQL request:
+ * every number goes in as a variable and each pull request comes back under
+ * its own alias. `pr-report-core`'s `set-aside.mts` says why only
+ * `viewerDidAuthor` counts; of several of a kind, the oldest is the one.
+ */
+export declare const readOwnComments: (api: ApiContext, numbers: readonly number[]) => Promise<Result<Readonly<{
+    setAside: ReadonlyMap<number, OwnSetAsideComment>;
+    claims: ReadonlyMap<number, Claim>;
+}>, string>>;
+/**
+ * Writes `body` as the pull request's set-aside comment: over `existing`,
+ * this account's own, when there is one — a pull request has one, edited in
+ * place — and as a new comment otherwise.
+ */
+export declare const writeSetAsideCommentOn: (api: ApiContext, prNumber: number, existing: number | undefined, body: string) => Promise<Result<undefined, string>>;
+/**
+ * Every change of the pull request's base its timeline records, oldest
+ * first; `stack.mts` reads which branch GitHub moved it off.
+ *
+ * GraphQL, because the REST timeline does not say which branches a change of
+ * base was between.
+ */
+export declare const readBaseChanges: (api: ApiContext, prNumber: number) => Promise<Result<readonly BaseChange[], string>>;
+/**
+ * The pull request's place in one of GitHub's native stacks, or `undefined`
+ * when it is in none. GraphQL, because REST does not know them.
+ */
+export declare const readNativeStack: (api: ApiContext, prNumber: number) => Promise<Result<NativeStackEntry | undefined, string>>;
+/**
+ * The head the last merged pull request from `branch` was merged at, and the
+ * commit its merge made, or `undefined` when none was — the layer a
+ * retargeted pull request was stacked on, whose commits it may still carry.
+ */
+export declare const mergedHeadOf: (api: ApiContext, branch: string) => Promise<Result<MergedHead | undefined, string>>;
+/**
+ * The last merged of `pulls`, closed pull requests from one branch, or
+ * `undefined` when none of them merged.
+ */
+export declare const latestMergedHead: (pulls: readonly t.TypeOf<typeof MergedPullSchema>[]) => MergedHead | undefined;
+export type MergedHead = Readonly<{
+    number: number;
+    headSha: string;
+    /** The squash commit on the base; GitHub may not have it for a moment. */
+    mergeCommit: string | undefined;
+}>;
+declare const MergedPullSchema: Readonly<{
+    typeName: string;
+    defaultValue: Readonly<{
+        head: Readonly<{
+            sha: string;
+        }>;
+        merge_commit_sha: string | null;
+        merged_at: string | null;
+        number: number;
+    }>;
+    is: (a: unknown) => a is Readonly<{
+        head: Readonly<{
+            sha: string;
+        }>;
+        merge_commit_sha: string | null;
+        merged_at: string | null;
+        number: number;
+    }>;
+    assertIs: (a: unknown) => asserts a is Readonly<{
+        head: Readonly<{
+            sha: string;
+        }>;
+        merge_commit_sha: string | null;
+        merged_at: string | null;
+        number: number;
+    }>;
+    cast: (a: unknown) => Readonly<{
+        head: Readonly<{
+            sha: string;
+        }>;
+        merge_commit_sha: string | null;
+        merged_at: string | null;
+        number: number;
+    }>;
+    fill: (a: unknown) => Readonly<{
+        head: Readonly<{
+            sha: string;
+        }>;
+        merge_commit_sha: string | null;
+        merged_at: string | null;
+        number: number;
+    }>;
+    prune: <B extends Readonly<{
+        head: Readonly<{
+            sha: string;
+        }>;
+        merge_commit_sha: string | null;
+        merged_at: string | null;
+        number: number;
+    }>>(a: B) => Readonly<{
+        head: Readonly<{
+            sha: string;
+        }>;
+        merge_commit_sha: string | null;
+        merged_at: string | null;
+        number: number;
+    }>;
+    validate: (a: unknown) => Result<Readonly<{
+        head: Readonly<{
+            sha: string;
+        }>;
+        merge_commit_sha: string | null;
+        merged_at: string | null;
+        number: number;
+    }>, readonly Readonly<{
+        path: readonly string[];
+        actualValue: unknown;
+        expectedType: string;
+        typeName: string;
+        details?: t.ValidationErrorDetails | undefined;
+    }>[]>;
+    structure?: t.TypeStructure;
+    annotations?: t.TypeAnnotations;
+    optional?: true;
+}> & Readonly<{
+    shape: {
+        readonly number: t.ConstrainedType<number, Readonly<{
+            readonly finite: undefined;
+            readonly int: undefined;
+            readonly safeInteger: undefined;
+            readonly nonZero: undefined;
+            readonly negative: undefined;
+            readonly nonNegative: undefined;
+            readonly positive: undefined;
+            readonly nonPositive: undefined;
+            readonly gt: undefined;
+            readonly gte: undefined;
+            readonly min: undefined;
+            readonly lt: undefined;
+            readonly lte: undefined;
+            readonly max: undefined;
+            readonly multipleOf: undefined;
+            readonly step: undefined;
+        }>>;
+        readonly head: Readonly<{
+            typeName: string;
+            defaultValue: Readonly<{
+                sha: string;
+            }>;
+            is: (a: unknown) => a is Readonly<{
+                sha: string;
+            }>;
+            assertIs: (a: unknown) => asserts a is Readonly<{
+                sha: string;
+            }>;
+            cast: (a: unknown) => Readonly<{
+                sha: string;
+            }>;
+            fill: (a: unknown) => Readonly<{
+                sha: string;
+            }>;
+            prune: <B extends Readonly<{
+                sha: string;
+            }>>(a: B) => Readonly<{
+                sha: string;
+            }>;
+            validate: (a: unknown) => Result<Readonly<{
+                sha: string;
+            }>, readonly Readonly<{
+                path: readonly string[];
+                actualValue: unknown;
+                expectedType: string;
+                typeName: string;
+                details?: t.ValidationErrorDetails | undefined;
+            }>[]>;
+            structure?: t.TypeStructure;
+            annotations?: t.TypeAnnotations;
+            optional?: true;
+        }> & Readonly<{
+            shape: {
+                readonly sha: t.ConstrainedType<string, Readonly<{
+                    readonly nonempty: undefined;
+                    readonly minLength: undefined;
+                    readonly maxLength: undefined;
+                    readonly startsWith: undefined;
+                    readonly endsWith: undefined;
+                    readonly includes: undefined;
+                    readonly uppercase: undefined;
+                    readonly lowercase: undefined;
+                    readonly regex: undefined;
+                }>>;
+            };
+        }>;
+        readonly merge_commit_sha: Readonly<{
+            typeName: string;
+            defaultValue: string | null;
+            is: (a: unknown) => a is string | null;
+            assertIs: (a: unknown) => asserts a is string | null;
+            cast: (a: unknown) => string | null;
+            fill: (a: unknown) => string | null;
+            prune: <B extends string | null>(a: B) => string | null;
+            validate: (a: unknown) => Result<string | null, readonly Readonly<{
+                path: readonly string[];
+                actualValue: unknown;
+                expectedType: string;
+                typeName: string;
+                details?: t.ValidationErrorDetails | undefined;
+            }>[]>;
+            structure?: t.TypeStructure;
+            annotations?: t.TypeAnnotations;
+            optional?: true;
+        }>;
+        readonly merged_at: Readonly<{
+            typeName: string;
+            defaultValue: string | null;
+            is: (a: unknown) => a is string | null;
+            assertIs: (a: unknown) => asserts a is string | null;
+            cast: (a: unknown) => string | null;
+            fill: (a: unknown) => string | null;
+            prune: <B extends string | null>(a: B) => string | null;
+            validate: (a: unknown) => Result<string | null, readonly Readonly<{
+                path: readonly string[];
+                actualValue: unknown;
+                expectedType: string;
+                typeName: string;
+                details?: t.ValidationErrorDetails | undefined;
+            }>[]>;
+            structure?: t.TypeStructure;
+            annotations?: t.TypeAnnotations;
+            optional?: true;
+        }>;
+    };
+}>;
+/**
+ * Arms auto-merge, squash being the one method the ruleset allows. The
+ * mutation refuses when nothing holds the pull request, where
+ * `gh pr merge --auto` would merge it on the spot.
+ */
+export declare const armAutoMerge: (api: ApiContext, nodeId: string) => Promise<Result<undefined, string>>;
+/**
+ * Every check run GitHub Actions reported on one commit, every job of every
+ * workflow rather than only the required aggregates, so that a failure can
+ * be traced to the matrix entry under the aggregate. Other apps' runs — the
+ * codecov ones — are left out: nothing here can act on them, and none is
+ * required.
+ */
+export declare const listCheckRuns: (api: ApiContext, headSha: string) => Promise<Result<readonly CheckRunReport[], string>>;
+export declare const removeWorktree: (worktreeDir: string) => Promise<void>;
+export {};
+//# sourceMappingURL=github.d.mts.map