@gitkraken/core-gitlens 0.6.0 → 0.7.1

package/dist/plus/git-github/api/github.d.ts

@@ -1,521 +1,524 @@
-import type { Endpoints } from '@octokit/types';
-import type { Account, UnidentifiedAuthor } from '../../../git/models/author.js';
-import type { DefaultBranch } from '../../../git/models/defaultBranch.js';
-import type { Issue, IssueSearchCriteria, IssueShape, IssueSorting } from '../../../git/models/issue.js';
-import type { IssueOrPullRequest } from '../../../git/models/issueOrPullRequest.js';
-import type { PullRequest, PullRequestSearchCriteria, PullRequestShape, PullRequestState, PullRequestStateFilter } from '../../../git/models/pullRequest.js';
-import { PullRequestMergeMethod } from '../../../git/models/pullRequest.js';
-import type { Provider } from '../../../git/models/remoteProvider.js';
-import type { RepositoryMetadata } from '../../../git/models/repositoryMetadata.js';
-import type { GitRevisionRange } from '../../../git/models/revision.js';
-import type { GitUser } from '../../../git/models/user.js';
-import type { RepositoryVisibility } from '../../../git/providers/types.js';
-import type { Event } from '../../../utils/event.js';
-import type { PagedResult } from '../../../utils/paging.js';
-import type { GitHubBlame, GitHubBranch, GitHubCommit, GitHubCommitRef, GitHubContributor, GitHubPagedResult, GitHubPullRequestState, GitHubSshSigningKey, GitHubTag } from '../models.js';
-import type { GitHubApiConfig } from './config.js';
-import type { GitHubTokenInfo } from './token.js';
+import { PagedResult } from "../../../utils/paging.js";
+import { Event } from "../../../utils/event.js";
+import { RepositoryVisibility } from "../../../git/providers/types.js";
+import { GitRevisionRange } from "../../../git/models/revision.js";
+import { Provider } from "../../../git/models/remoteProvider.js";
+import { GitUser } from "../../../git/models/user.js";
+import { IssueOrPullRequest, IssueOrPullRequestState } from "../../../git/models/issueOrPullRequest.js";
+import { Issue, IssueSearchCriteria, IssueShape, IssueSorting } from "../../../git/models/issue.js";
+import { PullRequest, PullRequestMergeMethod, PullRequestSearchCriteria, PullRequestShape, PullRequestStateFilter } from "../../../git/models/pullRequest.js";
+import { Account, UnidentifiedAuthor } from "../../../git/models/author.js";
+import { DefaultBranch } from "../../../git/models/defaultBranch.js";
+import { RepositoryMetadata } from "../../../git/models/repositoryMetadata.js";
+import { GitHubApiConfig } from "./config.js";
+import { GitHubBlame, GitHubBranch, GitHubCommit, GitHubCommitRef, GitHubContributor, GitHubPagedResult, GitHubPullRequestState, GitHubSshSigningKey, GitHubTag } from "../models.js";
+import { GitHubTokenInfo } from "./token.js";
+import { Endpoints } from "@octokit/types";
+//#region ../plus/git-github/src/api/github.d.ts
 /** One page of a multi-search issue request, with its composite cursor across every alias. */
 export interface AliasedIssueSearchResult {
-    values: IssueShape[];
-    /** Opaque composite cursor; absent when every alias is exhausted. */
-    cursor?: string;
-    hasMore: boolean;
-    page: number;
-    /** True when the read cannot return everything — GitHub's search ceiling, or an unusable continuation. */
-    truncated: boolean;
-    /**
-     * The largest `issueCount` any single alias reported, which is what {@link githubSearchResultLimit} applies
-     * to (the ceiling is per search, not per request). Absent when no request was made — every alias was already
-     * exhausted — so `undefined` means "not reported", never zero matches.
-     */
-    totalCount?: number;
+  values: IssueShape[];
+  /** Opaque composite cursor; absent when every alias is exhausted. */
+  cursor?: string;
+  hasMore: boolean;
+  page: number;
+  /** True when the read cannot return everything — GitHub's search ceiling, or an unusable continuation. */
+  truncated: boolean;
+  /**
+   * The largest `issueCount` any single alias reported, which is what {@link githubSearchResultLimit} applies
+   * to (the ceiling is per search, not per request). Absent when no request was made — every alias was already
+   * exhausted — so `undefined` means "not reported", never zero matches.
+   */
+  totalCount?: number;
 }
 /** One page of the filtered pull-request search. */
 export interface PullRequestSearchResult {
-    values: PullRequestShape[];
-    /** Opaque cursor carrying each active facet continuation plus the positional page. */
-    cursor?: string;
-    hasMore: boolean;
-    page: number;
-    /** True at GitHub's search ceiling or when GitHub advertises a page without a usable cursor. */
-    truncated: boolean;
-    /**
-     * The largest pre-ceiling `issueCount` any relationship × state facet reported, which is what
-     * {@link githubSearchResultLimit} applies to. Never the number of rows reachable after that ceiling.
-     */
-    totalCount?: number;
+  values: PullRequestShape[];
+  /** Opaque cursor carrying each active facet continuation plus the positional page. */
+  cursor?: string;
+  hasMore: boolean;
+  page: number;
+  /** True at GitHub's search ceiling or when GitHub advertises a page without a usable cursor. */
+  truncated: boolean;
+  /**
+   * The largest pre-ceiling `issueCount` any relationship × state facet reported, which is what
+   * {@link githubSearchResultLimit} applies to. Never the number of rows reachable after that ceiling.
+   */
+  totalCount?: number;
 }
 /** One layer of a stack, as returned by the stacks REST API. Ordered bottom to top. */
 export interface GitHubStackLayer {
-    number: number;
-    state: string;
-    draft?: boolean;
-    merged_at?: string | null;
-    head: {
-        ref: string;
-        sha: string;
-    };
+  number: number;
+  state: string;
+  draft?: boolean;
+  merged_at?: string | null;
+  head: {
+    ref: string;
+    sha: string;
+  };
 }
 export interface GitHubStackResource {
-    id: string;
-    number: number;
-    /** The stack's trunk — what the bottom member targets. */
-    base: {
-        ref: string;
-        sha?: string;
-    };
-    /** False once every member has merged; such a stack can no longer be extended. */
-    open?: boolean;
-    /** Members ordered bottom to top. */
-    pull_requests: GitHubStackLayer[];
+  id: string;
+  number: number;
+  /** The stack's trunk — what the bottom member targets. */
+  base: {
+    ref: string;
+    sha?: string;
+  };
+  /** False once every member has merged; such a stack can no longer be extended. */
+  open?: boolean;
+  /** Members ordered bottom to top. */
+  pull_requests: GitHubStackLayer[];
 }
 export declare class GitHubApi {
-    readonly config: GitHubApiConfig;
-    private readonly _onDidReauthenticate;
-    get onDidReauthenticate(): Event<void>;
-    private readonly _disposables;
-    constructor(config: GitHubApiConfig);
-    dispose(): void;
-    private resetCaches;
-    getCurrentAccount(provider: Provider, token: GitHubTokenInfo, options?: {
-        baseUrl?: string;
-        avatarSize?: number;
-    }): Promise<Account | undefined>;
-    getAccountForCommit(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, rev: string, options?: {
-        baseUrl?: string;
-        avatarSize?: number;
-    }): Promise<Account | UnidentifiedAuthor | undefined>;
-    getAccountForEmail(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, email: string, options?: {
-        baseUrl?: string;
-        avatarSize?: number;
-    }): Promise<Account | undefined>;
-    getAccountsForEmails(provider: Provider, token: GitHubTokenInfo, emails: string[], options?: {
-        baseUrl?: string;
-    }): Promise<Map<string, string>>;
-    getDefaultBranch(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, options?: {
-        baseUrl?: string;
-    }): Promise<DefaultBranch | undefined>;
-    getIssueOrPullRequest(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, number: number, options?: {
-        baseUrl?: string;
-    }): Promise<IssueOrPullRequest | undefined>;
-    getIssue(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, number: number, options?: {
-        baseUrl?: string;
-        avatarSize?: number;
-        includeBody?: boolean;
-    }): Promise<Issue | undefined>;
-    getPullRequest(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, number: number, options?: {
-        baseUrl?: string;
-        avatarSize?: number;
-    }): Promise<PullRequest | undefined>;
-    getPullRequestForBranch(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, branch: string, options?: {
-        baseUrl?: string;
-        avatarSize?: number;
-        include?: GitHubPullRequestState[];
-    }): Promise<PullRequest | undefined>;
-    getPullRequestForCommit(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, rev: string, options?: {
-        baseUrl?: string;
-        avatarSize?: number;
-    }, cancellation?: AbortSignal): Promise<PullRequest | undefined>;
-    getRepositoryMetadata(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, options?: {
-        baseUrl?: string;
-    }, cancellation?: AbortSignal): Promise<RepositoryMetadata | undefined>;
-    getBlame(token: GitHubTokenInfo, owner: string, repo: string, ref: string, path: string): Promise<GitHubBlame>;
-    getBranches(token: GitHubTokenInfo, owner: string, repo: string, options?: {
-        query?: string;
-        cursor?: string;
-        limit?: number;
-    }): Promise<PagedResult<GitHubBranch>>;
-    getCommit(token: GitHubTokenInfo, owner: string, repo: string, ref: string): Promise<(GitHubCommit & {
-        viewer?: string;
-    }) | undefined>;
-    getCommitForFile(token: GitHubTokenInfo, owner: string, repo: string, ref: string, path: string): Promise<(GitHubCommit & {
-        viewer?: string;
-    }) | undefined>;
-    getBranchesWithCommits(token: GitHubTokenInfo, owner: string, repo: string, refs: string[], mode: 'contains' | 'pointsAt', date?: Date): Promise<string[]>;
-    getCommitCount(token: GitHubTokenInfo, owner: string, repo: string, ref: string): Promise<number | undefined>;
-    getBranchWithCommit(token: GitHubTokenInfo, owner: string, repo: string, branch: string, refs: string[], mode: 'contains' | 'pointsAt', date?: Date): Promise<string[]>;
-    getCommits(token: GitHubTokenInfo, owner: string, repo: string, ref: string, options?: {
-        after?: string;
-        all?: boolean;
-        authors?: GitUser[];
-        before?: string;
-        limit?: number;
-        path?: string;
-        since?: string | Date;
-        until?: string | Date;
-    }): Promise<PagedResult<GitHubCommit> & {
-        viewer?: string;
-    }>;
-    getCommitShas(token: GitHubTokenInfo, owner: string, repo: string, ref: string, options?: {
-        after?: string;
-        before?: string;
-        limit?: number;
-        path?: string;
-        since?: string | Date;
-        until?: string | Date;
-    }): Promise<PagedResult<string>>;
-    private getCommitsCoreRange;
-    private getCommitsCoreSingle;
-    getCommitRefs(token: GitHubTokenInfo, owner: string, repo: string, ref: string, options?: {
-        after?: string;
-        before?: string;
-        first?: number;
-        last?: number;
-        path?: string;
-        since?: string;
-        until?: string;
-    }): Promise<GitHubPagedResult<GitHubCommitRef> | undefined>;
-    getTagsWithCommit(token: GitHubTokenInfo, owner: string, repo: string, ref: string, date: Date): Promise<string[]>;
-    getNextCommitRefs(token: GitHubTokenInfo, owner: string, repo: string, ref: string, path: string, sha: string): Promise<string[]>;
-    private getCommitDate;
-    getContributors(token: GitHubTokenInfo, owner: string, repo: string): Promise<GitHubContributor[]>;
-    getUserSshSigningKeys(provider: Provider | undefined, token: GitHubTokenInfo, username: string, options?: {
-        baseUrl?: string;
-    }): Promise<GitHubSshSigningKey[]>;
-    getCurrentUserSshSigningKeys(provider: Provider | undefined, token: GitHubTokenInfo, options?: {
-        baseUrl?: string;
-    }): Promise<GitHubSshSigningKey[]>;
-    getDefaultBranchName(token: GitHubTokenInfo, owner: string, repo: string): Promise<string | undefined>;
-    getCurrentUser(token: GitHubTokenInfo, owner: string, repo: string): Promise<GitUser | undefined>;
-    getComparison(token: GitHubTokenInfo, owner: string, repo: string, range: GitRevisionRange): Promise<Endpoints['GET /repos/{owner}/{repo}/compare/{basehead}']['response']['data'] | undefined>;
-    getRepositoryVisibility(token: GitHubTokenInfo, owner: string, repo: string): Promise<RepositoryVisibility | undefined>;
-    getTags(token: GitHubTokenInfo, owner: string, repo: string, options?: {
-        query?: string;
-        cursor?: string;
-        limit?: number;
-    }): Promise<PagedResult<GitHubTag>>;
-    resolveReference(token: GitHubTokenInfo, owner: string, repo: string, ref: string, path?: string): Promise<string | undefined>;
-    searchCommits(token: GitHubTokenInfo, query: string, options?: {
-        cursor?: string;
-        limit?: number;
-        order?: 'asc' | 'desc' | undefined;
-        sort?: 'author-date' | 'committer-date' | undefined;
-    }): Promise<GitHubPagedResult<GitHubCommit> | undefined>;
-    searchCommitShas(token: GitHubTokenInfo, query: string, options?: {
-        cursor?: string;
-        limit?: number;
-        order?: 'asc' | 'desc' | undefined;
-        sort?: 'author-date' | 'committer-date' | undefined;
-    }): Promise<GitHubPagedResult<{
-        sha: string;
-        authorDate: number;
-        committerDate: number;
-    }> | undefined>;
-    private _enterpriseVersions;
-    private getEnterpriseVersion;
-    private requestWithRetries;
-    private delayWithAbort;
-    private readonly _pendingGraphQL;
-    private graphql;
-    private request;
-    /**
-     * REST call for routes `@octokit/types` doesn't describe yet — currently the stacked-pull-request
-     * merge APIs, which are in public preview and absent from the generated endpoint map. Prefer
-     * `request` for anything typed.
-     */
-    private requestPreview;
-    private requestCore;
-    private _defaults;
-    private getDefaults;
-    private handleRequestError;
-    private handleException;
-    private showAuthenticationErrorMessage;
-    private createEnterpriseAvatarUrl;
-    /**
-     * One page of the current user's pull requests, filtered by state and optionally by an explicit
-     * relationship qualifier. Backs the PR sweeps, which drain it page by page.
-     *
-     * Ordering is part of the contract, not an option: always `sort:updated` (most recently updated first), which is
-     * {@link searchPullRequestsPage}'s DEFAULT rather than its only order — that read takes a `criteria.sort`, this
-     * one does not, because a sweep's recency window is what its page budget is defined against. A caller that stops
-     * before `hasMore` clears — every sweep with a
-     * page budget — therefore retains a well-defined recency window instead of an arbitrary slice of GitHub's
-     * relevance ranking.
-     */
-    searchMyPullRequestsPage(provider: Provider, token: GitHubTokenInfo, options?: {
-        search?: string;
-        user?: string;
-        repos?: string[];
-        baseUrl?: string;
-        avatarSize?: number;
-        silent?: boolean;
-        state?: PullRequestStateFilter;
-        cursor?: string;
-        /**
-         * Uses the lightweight PR fragment while retaining identity, body, author, repository, and branch refs.
-         * Intended for aggregate/list surfaces that do not consume review, check, or diff statistics.
-         */
-        summary?: boolean;
-        /**
-         * Adds GitHub's provider-native `involves:@me` relationship. Disable when `search` already carries
-         * an explicit relationship qualifier such as `author:@me` or `review-requested:@me`.
-         */
-        includeDefaultInvolvement?: boolean;
-    }, cancellation?: AbortSignal): Promise<{
-        values: PullRequest[];
-        cursor?: string;
-        hasMore: boolean;
-        truncated: boolean;
-    }>;
-    /**
-     * The whole list rather than a page: this read has no cursor to hand back (its `IntegrationResult<T[]>` return
-     * has no paging channel at all), so it drains up to {@link maxMyPullRequestSearchPages} pages itself.
-     *
-     * Draining instead of taking one page is what lets the full projection page at the reduced size everywhere
-     * (see the `limit` in {@link searchMyPullRequestsPage}): a single page would otherwise have to ask for 100
-     * nodes of the selection GitHub rejects at that size, purely because this caller cannot resume. Ordering is
-     * `sort:updated`, so the pages compose into a defined window rather than a shifting relevance ranking, and the
-     * drain stops as soon as GitHub reports no next page.
-     */
-    searchMyPullRequests(provider: Provider, token: GitHubTokenInfo, options?: {
-        search?: string;
-        user?: string;
-        repos?: string[];
-        baseUrl?: string;
-        avatarSize?: number;
-        silent?: boolean;
-        state?: PullRequestStateFilter;
-    }, cancellation?: AbortSignal): Promise<PullRequest[]>;
-    /**
-     * The current user's issues: authored ∪ assigned ∪ mentioned, each its own aliased search behind one composite
-     * cursor. Bound to `@me` by construction, unlike {@link searchIssuesPage}.
-     *
-     * Ordering is OPT-IN here, and that asymmetry with {@link searchIssuesPage} is deliberate: this read has never
-     * requested a sort, so GitHub has always answered it in relevance order. Emitting a default would change which
-     * issues its already-shipped consumers see, so an omitted `sort` still emits no `sort:` qualifier at all and
-     * keeps today's result. Pass one to get a defined order — which is also what makes a page budget meaningful,
-     * since relevance ranking can shift under an unchanged upstream.
-     */
-    searchMyIssues(provider: Provider, token: GitHubTokenInfo, options?: {
-        search?: string;
-        user?: string;
-        repos?: string[];
-        baseUrl?: string;
-        avatarSize?: number;
-        includeBody?: boolean;
-        includeAllAssignees?: boolean;
-        cursor?: string;
-        /** Requested order. Omitted leaves GitHub's relevance order, which is what this read has always served. */
-        sort?: IssueSorting;
-        /**
-         * Which of the three "my issues" searches to run. Omitted runs all three (GitHub's own definition of
-         * "mine": authored ∪ assigned ∪ mentioned). Supplied, only the `true` ones run — so a caller wanting
-         * `assignee:@me` parity asks for `{ assigned: true }` instead of filtering the union client-side (which
-         * can't work: the dropped items still counted toward this page, so `hasMore`/`cursor` would describe a
-         * different result set than `values`).
-         *
-         * At least one must be `true`; an all-`false` set reads nothing rather than silently widening back to
-         * the union. The facade never sends one (an empty filter set means "unfiltered" there).
-         */
-        categories?: {
-            authored?: boolean;
-            assigned?: boolean;
-            mentioned?: boolean;
-        };
-    }, cancellation?: AbortSignal): Promise<AliasedIssueSearchResult | undefined>;
-    /**
-     * The filtered issue search: issues matching structured criteria over a repository/org scope, with no forced
-     * relationship to the current user. The issue counterpart of {@link searchMyPullRequestsPage}, and distinct
-     * from {@link searchMyIssues}, which is permanently bound to `@me`.
-     *
-     * Ordering is `criteria.sort`, defaulting to most-recently-updated-first — the order this read served before
-     * ordering was an option, so an omitted `sort` emits the identical query. What is NOT optional is that SOME
-     * order is always requested: without one GitHub answers in relevance order, and at the result ceiling that
-     * makes which rows are reachable a function of GitHub's ranking rather than of the request. A key GitHub can't
-     * express (`closed`, `priority`, …) is refused by the facade before the request, not silently downgraded.
-     *
-     * With more than one relationship the page is a UNION of several searches, each ordered by the provider; the
-     * merged page is re-sorted here so the whole page honors the requested key. Across pages the order is still
-     * per-alias — see {@link searchIssuesByAlias}. Note a union can also serve the same issue on two pages when
-     * its relationships OVERLAP (an issue both authored by and assigned to the user sits at different depths in
-     * the two), which predates the ceiling slide and is a property of unioning independent walks: measured at 50
-     * repeats over 450 issues with no ceiling involved. Dedupe by url if that matters to the surface.
-     *
-     * GitHub's per-query result ceiling is NOT terminal here: an alias that runs out of pages while capped
-     * continues bounded to the far side of its own last item, which is a fresh query with a fresh budget. Bounded
-     * per alias, since they exhaust independently. Only a ceiling an alias cannot slide past (a sort key with no
-     * usable range qualifier) is reported as an omission.
-     *
-     * Each requested relationship becomes its own aliased search, unioned and deduped by url; with none, a single
-     * search runs over the scope alone. `criteria.text` and the other free-form values are sanitized so user input
-     * cannot inject a qualifier and re-scope the search — see {@link toGitHubIssueSearchQualifiers}.
-     */
-    searchIssuesPage(provider: Provider, token: GitHubTokenInfo, options?: {
-        repos?: string[];
-        org?: string;
-        criteria?: IssueSearchCriteria;
-        baseUrl?: string;
-        avatarSize?: number;
-        includeBody?: boolean;
-        cursor?: string;
-        pageSize?: number;
-    }, cancellation?: AbortSignal): Promise<AliasedIssueSearchResult | undefined>;
-    /**
-     * Reads back the per-alias ceiling-slide bounds a prior page sealed into its cursor.
-     *
-     * Each value is validated against the EXACT shape {@link toGitHubIssueSearchSlideQualifier} emits, not merely
-     * checked for being a string. A cursor is caller-supplied data on a round trip, so an unvalidated value here
-     * would be a qualifier of someone else's choosing appended to the search: `org:evil-corp` in a cursor would
-     * re-scope the read. Anything unrecognized yields no bound, which restarts that alias at the top — a repeated
-     * page, which is the safe failure.
-     */
-    private parseSlidesFromCursor;
-    /**
-     * Counts issues for several scopes in ONE request, transferring no issues at all — each scope is an aliased
-     * `search` selecting only `issueCount`, with `first: 0` so no nodes are fetched.
-     *
-     * This is what makes a "this will fetch ~N issues" preview affordable: measured against the live API, 30
-     * aliased counts cost a single rate-limit point. It is still a network request per chunk, so a caller is
-     * expected to debounce and cache.
-     *
-     * Returns counts positionally — one per input scope, same order — because a caller-supplied key must never
-     * reach the GraphQL document (it would break it); the aliases are generated. `undefined` in a slot means the
-     * response omitted that alias, which the caller reports as "not counted" rather than as zero.
-     */
-    countIssues(provider: Provider, token: GitHubTokenInfo, scopes: readonly {
-        repos?: string[];
-        org?: string;
-        criteria?: IssueSearchCriteria;
-    }[], options?: {
-        baseUrl?: string;
-    }, cancellation?: AbortSignal): Promise<(number | undefined)[]>;
+  readonly config: GitHubApiConfig;
+  private readonly _onDidReauthenticate;
+  get onDidReauthenticate(): Event<void>;
+  private readonly _disposables;
+  constructor(config: GitHubApiConfig);
+  dispose(): void;
+  private resetCaches;
+  getCurrentAccount(provider: Provider, token: GitHubTokenInfo, options?: {
+    baseUrl?: string;
+    avatarSize?: number;
+  }): Promise<Account | undefined>;
+  getAccountForCommit(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, rev: string, options?: {
+    baseUrl?: string;
+    avatarSize?: number;
+  }): Promise<Account | UnidentifiedAuthor | undefined>;
+  getAccountForEmail(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, email: string, options?: {
+    baseUrl?: string;
+    avatarSize?: number;
+  }): Promise<Account | undefined>;
+  getAccountsForEmails(provider: Provider, token: GitHubTokenInfo, emails: string[], options?: {
+    baseUrl?: string;
+  }): Promise<Map<string, string>>;
+  getDefaultBranch(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, options?: {
+    baseUrl?: string;
+  }): Promise<DefaultBranch | undefined>;
+  getIssueOrPullRequest(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, number: number, options?: {
+    baseUrl?: string;
+  }): Promise<IssueOrPullRequest | undefined>;
+  getIssue(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, number: number, options?: {
+    baseUrl?: string;
+    avatarSize?: number;
+    includeBody?: boolean;
+  }): Promise<Issue | undefined>;
+  getPullRequest(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, number: number, options?: {
+    baseUrl?: string;
+    avatarSize?: number;
+  }): Promise<PullRequest | undefined>;
+  getPullRequestForBranch(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, branch: string, options?: {
+    baseUrl?: string;
+    avatarSize?: number;
+    include?: GitHubPullRequestState[];
+  }): Promise<PullRequest | undefined>;
+  getPullRequestForCommit(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, rev: string, options?: {
+    baseUrl?: string;
+    avatarSize?: number;
+  }, cancellation?: AbortSignal): Promise<PullRequest | undefined>;
+  getRepositoryMetadata(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, options?: {
+    baseUrl?: string;
+  }, cancellation?: AbortSignal): Promise<RepositoryMetadata | undefined>;
+  getBlame(token: GitHubTokenInfo, owner: string, repo: string, ref: string, path: string): Promise<GitHubBlame>;
+  getBranches(token: GitHubTokenInfo, owner: string, repo: string, options?: {
+    query?: string;
+    cursor?: string;
+    limit?: number;
+  }): Promise<PagedResult<GitHubBranch>>;
+  getCommit(token: GitHubTokenInfo, owner: string, repo: string, ref: string): Promise<(GitHubCommit & {
+    viewer?: string;
+  }) | undefined>;
+  getCommitForFile(token: GitHubTokenInfo, owner: string, repo: string, ref: string, path: string): Promise<(GitHubCommit & {
+    viewer?: string;
+  }) | undefined>;
+  getBranchesWithCommits(token: GitHubTokenInfo, owner: string, repo: string, refs: string[], mode: 'contains' | 'pointsAt', date?: Date): Promise<string[]>;
+  getCommitCount(token: GitHubTokenInfo, owner: string, repo: string, ref: string): Promise<number | undefined>;
+  getBranchWithCommit(token: GitHubTokenInfo, owner: string, repo: string, branch: string, refs: string[], mode: 'contains' | 'pointsAt', date?: Date): Promise<string[]>;
+  getCommits(token: GitHubTokenInfo, owner: string, repo: string, ref: string, options?: {
+    after?: string;
+    all?: boolean;
+    authors?: GitUser[];
+    before?: string;
+    limit?: number;
+    path?: string;
+    since?: string | Date;
+    until?: string | Date;
+  }): Promise<PagedResult<GitHubCommit> & {
+    viewer?: string;
+  }>;
+  getCommitShas(token: GitHubTokenInfo, owner: string, repo: string, ref: string, options?: {
+    after?: string;
+    before?: string;
+    limit?: number;
+    path?: string;
+    since?: string | Date;
+    until?: string | Date;
+  }): Promise<PagedResult<string>>;
+  private getCommitsCoreRange;
+  private getCommitsCoreSingle;
+  getCommitRefs(token: GitHubTokenInfo, owner: string, repo: string, ref: string, options?: {
+    after?: string;
+    before?: string;
+    first?: number;
+    last?: number;
+    path?: string;
+    since?: string;
+    until?: string;
+  }): Promise<GitHubPagedResult<GitHubCommitRef> | undefined>;
+  getTagsWithCommit(token: GitHubTokenInfo, owner: string, repo: string, ref: string, date: Date): Promise<string[]>;
+  getNextCommitRefs(token: GitHubTokenInfo, owner: string, repo: string, ref: string, path: string, sha: string): Promise<string[]>;
+  private getCommitDate;
+  getContributors(token: GitHubTokenInfo, owner: string, repo: string): Promise<GitHubContributor[]>;
+  getUserSshSigningKeys(provider: Provider | undefined, token: GitHubTokenInfo, username: string, options?: {
+    baseUrl?: string;
+  }): Promise<GitHubSshSigningKey[]>;
+  getCurrentUserSshSigningKeys(provider: Provider | undefined, token: GitHubTokenInfo, options?: {
+    baseUrl?: string;
+  }): Promise<GitHubSshSigningKey[]>;
+  getDefaultBranchName(token: GitHubTokenInfo, owner: string, repo: string): Promise<string | undefined>;
+  getCurrentUser(token: GitHubTokenInfo, owner: string, repo: string): Promise<GitUser | undefined>;
+  getComparison(token: GitHubTokenInfo, owner: string, repo: string, range: GitRevisionRange): Promise<Endpoints['GET /repos/{owner}/{repo}/compare/{basehead}']['response']['data'] | undefined>;
+  getRepositoryVisibility(token: GitHubTokenInfo, owner: string, repo: string): Promise<RepositoryVisibility | undefined>;
+  getTags(token: GitHubTokenInfo, owner: string, repo: string, options?: {
+    query?: string;
+    cursor?: string;
+    limit?: number;
+  }): Promise<PagedResult<GitHubTag>>;
+  resolveReference(token: GitHubTokenInfo, owner: string, repo: string, ref: string, path?: string): Promise<string | undefined>;
+  searchCommits(token: GitHubTokenInfo, query: string, options?: {
+    cursor?: string;
+    limit?: number;
+    order?: 'asc' | 'desc' | undefined;
+    sort?: 'author-date' | 'committer-date' | undefined;
+  }): Promise<GitHubPagedResult<GitHubCommit> | undefined>;
+  searchCommitShas(token: GitHubTokenInfo, query: string, options?: {
+    cursor?: string;
+    limit?: number;
+    order?: 'asc' | 'desc' | undefined;
+    sort?: 'author-date' | 'committer-date' | undefined;
+  }): Promise<GitHubPagedResult<{
+    sha: string;
+    authorDate: number;
+    committerDate: number;
+  }> | undefined>;
+  private _enterpriseVersions;
+  private getEnterpriseVersion;
+  private requestWithRetries;
+  private delayWithAbort;
+  private readonly _pendingGraphQL;
+  private graphql;
+  private request;
+  /**
+   * REST call for routes `@octokit/types` doesn't describe yet — currently the stacked-pull-request
+   * merge APIs, which are in public preview and absent from the generated endpoint map. Prefer
+   * `request` for anything typed.
+   */
+  private requestPreview;
+  private requestCore;
+  private _defaults;
+  private getDefaults;
+  private handleRequestError;
+  private handleException;
+  private showAuthenticationErrorMessage;
+  private createEnterpriseAvatarUrl;
+  /**
+   * One page of the current user's pull requests, filtered by state and optionally by an explicit
+   * relationship qualifier. Backs the PR sweeps, which drain it page by page.
+   *
+   * Ordering is part of the contract, not an option: always `sort:updated` (most recently updated first), which is
+   * {@link searchPullRequestsPage}'s DEFAULT rather than its only order — that read takes a `criteria.sort`, this
+   * one does not, because a sweep's recency window is what its page budget is defined against. A caller that stops
+   * before `hasMore` clears — every sweep with a
+   * page budget — therefore retains a well-defined recency window instead of an arbitrary slice of GitHub's
+   * relevance ranking.
+   */
+  searchMyPullRequestsPage(provider: Provider, token: GitHubTokenInfo, options?: {
+    search?: string;
+    user?: string;
+    repos?: string[];
+    baseUrl?: string;
+    avatarSize?: number;
+    silent?: boolean;
+    state?: PullRequestStateFilter;
+    cursor?: string;
     /**
-     * Resolves several issues BY COORDINATE — `(owner, repo, number)` — in one request, via aliased `repository`
-     * fields rather than aliased searches.
-     *
-     * Aliasing the point read rather than {@link searchIssuesByAlias} is the whole design, and each difference
-     * matters to the caller this exists for (correlating a branch name to the issue it references):
-     * - it resolves by EXACT NUMBER, where a search answers a relevance question;
-     * - no result ceiling applies, so there is no partial window to reason about;
-     * - and a null is a PROVEN ABSENCE rather than "not found within a page budget", which is what makes a miss
-     *   cacheable. That last one is the point: a caller that cannot prove absence re-walks its budget forever.
-     *
-     * Returns POSITIONALLY — one slot per input coordinate, in order — for the same reason {@link countIssues}
-     * does: a caller's key is arbitrary text and would break the GraphQL document, so the aliases are generated
-     * and the caller maps back by index. `undefined` in a slot means the issue does not exist (or is not visible
-     * to this token), never that the read failed; a failure throws.
+     * Uses the lightweight PR fragment while retaining identity, body, author, repository, and branch refs.
+     * Intended for aggregate/list surfaces that do not consume review, check, or diff statistics.
      */
-    getIssuesBatch(provider: Provider, token: GitHubTokenInfo, coordinates: readonly {
-        owner: string;
-        repo: string;
-        number: number;
-    }[], options?: {
-        baseUrl?: string;
-        avatarSize?: number;
-        includeBody?: boolean;
-    }, cancellation?: AbortSignal): Promise<(IssueShape | undefined)[]>;
+    summary?: boolean;
     /**
-     * The PR twin of {@link countIssues}: counts pull requests for several scopes in ONE request via aliased
-     * `search` fields selecting only `issueCount` with `first: 0`. Same positional/undefined contract as the issue
-     * count.
-     *
-     * The one difference is states. {@link toGitHubPullRequestSearchFacets} fans a scope's states out into one
-     * `search` each, so this reports the count the SAME way {@link searchPullRequestsPage} reports its total — the
-     * LARGEST facet's `issueCount`, not their sum: the result ceiling applies per search, so the max is what
-     * `exceedsProviderLimit` compares against, and summing would claim a total the read never surfaces. Relationships
-     * are OR-ed and can't be a single count; the facade refuses a multi-relationship scope, so at most one is here.
+     * Adds GitHub's provider-native `involves:@me` relationship. Disable when `search` already carries
+     * an explicit relationship qualifier such as `author:@me` or `review-requested:@me`.
      */
-    countPullRequests(provider: Provider, token: GitHubTokenInfo, scopes: readonly {
-        repos?: string[];
-        org?: string;
-        criteria?: PullRequestSearchCriteria;
-    }[], options?: {
-        baseUrl?: string;
-    }, cancellation?: AbortSignal): Promise<(number | undefined)[]>;
-    /**
-     * The aliased-search engine behind every GitHub issue search: one GraphQL request carrying N independently
-     * cursored `search` fields, `@include`-gated so an exhausted or unrequested one costs nothing.
-     *
-     * It exists as one implementation because the properties that make it correct are subtle and must not be
-     * reproduced per read: each alias advances on its OWN cursor and is dropped from the request once exhausted
-     * (so a finished search is never re-queried, which would re-emit its first page); results are mapped
-     * node-by-node so one unmappable issue can't discard the page; the union is deduped by `url` rather than by
-     * `IssueShape.id`, which for some providers is a per-repository number; and a provider that claims another
-     * page while withholding its `endCursor` is reported as truncated instead of paged forever.
-     *
-     * {@link searchMyIssues} is one configuration of it (its three `@me` categories), and its alias names are
-     * that read's published cursor keys.
-     *
-     * `searches` must have unique aliases, each a valid GraphQL name that is none of `page`, `truncated` or
-     * `sort` — the composite cursor keys aliases at its top level, alongside those three reserved fields.
-     *
-     * `sort` is the order the caller asked for, which this does two things with. Each alias comes back ordered by
-     * it (the qualifier is already in `searches[].query`), but the UNION of several aliases is not, so the merged
-     * page is re-sorted here; and the key is recorded in the cursor, so a continuation that changed it THROWS
-     * rather than serving a sequence with gaps and repeats. Omitted means the caller asked for no order at all
-     * ({@link searchMyIssues}'s default), which re-sorts nothing and pins nothing.
-     *
-     * `legacySort` is the order the calling read produced BEFORE this field existed, and is what a cursor with no
-     * recorded key is compared against — such a cursor is not of unknown order, it is of that read's old one.
-     */
-    private searchIssuesByAlias;
-    /**
-     * Searches pull requests over a repository/org or current-user relationship scope. One GraphQL document carries
-     * every active relationship × state facet, so one HTTP request serves one page even when the logical search is
-     * a union. The cursor preserves each facet's continuation plus the positional page.
-     *
-     * Ordering is `criteria.sort`, defaulting to most-recently-updated-first — the order this read served before it
-     * was expressible. It is requested of the provider AND re-applied to the merged page, because the page is a
-     * union of facets and no per-facet server order describes it. The sort is part of the cursor fingerprint, so
-     * changing it invalidates a threaded cursor exactly as changing the text or the scope does. User text is
-     * sanitized before it reaches the provider query. See {@link toGitHubPullRequestSearchFacets}.
-     */
-    searchPullRequestsPage(provider: Provider, token: GitHubTokenInfo, options?: {
-        repos?: string[];
-        org?: string;
-        criteria?: PullRequestSearchCriteria;
-        baseUrl?: string;
-        avatarSize?: number;
-        cursor?: string;
-        pageSize?: number;
-        /**
-         * Uses the lightweight PR fragment, retaining identity, body, author, repository, branch refs, and stack
-         * info while omitting review, check, and diff statistics. It also replaces the flat per-facet default with
-         * a budget multi-facet searches share across their active facets, so it raises the page with up to three of
-         * them and LOWERS it from four on.
-         */
-        summary?: boolean;
-    }, cancellation?: AbortSignal): Promise<PullRequestSearchResult | undefined>;
-    searchPullRequests(provider: Provider, token: GitHubTokenInfo, options?: {
-        search?: string;
-        user?: string;
-        repos?: string[];
-        baseUrl?: string;
-        avatarSize?: number;
-        include?: PullRequestState[];
-    }, cancellation?: AbortSignal): Promise<PullRequest[]>;
+    includeDefaultInvolvement?: boolean;
+  }, cancellation?: AbortSignal): Promise<{
+    values: PullRequest[];
+    cursor?: string;
+    hasMore: boolean;
+    truncated: boolean;
+  }>;
+  /**
+   * The whole list rather than a page: this read has no cursor to hand back (its `IntegrationResult<T[]>` return
+   * has no paging channel at all), so it drains up to {@link maxMyPullRequestSearchPages} pages itself.
+   *
+   * Draining instead of taking one page is what lets the full projection page at the reduced size everywhere
+   * (see the `limit` in {@link searchMyPullRequestsPage}): a single page would otherwise have to ask for 100
+   * nodes of the selection GitHub rejects at that size, purely because this caller cannot resume. Ordering is
+   * `sort:updated`, so the pages compose into a defined window rather than a shifting relevance ranking, and the
+   * drain stops as soon as GitHub reports no next page.
+   */
+  searchMyPullRequests(provider: Provider, token: GitHubTokenInfo, options?: {
+    search?: string;
+    user?: string;
+    repos?: string[];
+    baseUrl?: string;
+    avatarSize?: number;
+    silent?: boolean;
+    state?: PullRequestStateFilter;
+  }, cancellation?: AbortSignal): Promise<PullRequest[]>;
+  /**
+   * The current user's issues: authored ∪ assigned ∪ mentioned, each its own aliased search behind one composite
+   * cursor. Bound to `@me` by construction, unlike {@link searchIssuesPage}.
+   *
+   * Ordering is OPT-IN here, and that asymmetry with {@link searchIssuesPage} is deliberate: this read has never
+   * requested a sort, so GitHub has always answered it in relevance order. Emitting a default would change which
+   * issues its already-shipped consumers see, so an omitted `sort` still emits no `sort:` qualifier at all and
+   * keeps today's result. Pass one to get a defined order — which is also what makes a page budget meaningful,
+   * since relevance ranking can shift under an unchanged upstream.
+   */
+  searchMyIssues(provider: Provider, token: GitHubTokenInfo, options?: {
+    search?: string;
+    user?: string;
+    repos?: string[];
+    baseUrl?: string;
+    avatarSize?: number;
+    includeBody?: boolean;
+    includeAllAssignees?: boolean;
+    cursor?: string;
+    /** Per aliased search, not per page: a full union page holds up to `3 × pageSize` nodes. Capped at 100. */
+    pageSize?: number;
+    /** Requested order. Omitted leaves GitHub's relevance order, which is what this read has always served. */
+    sort?: IssueSorting;
     /**
-     * Every stack in the repository, each with its members bottom to top.
+     * Which of the three "my issues" searches to run. Omitted runs all three (GitHub's own definition of
+     * "mine": authored ∪ assigned ∪ mentioned). Supplied, only the `true` ones run — so a caller wanting
+     * `assignee:@me` parity asks for `{ assigned: true }` instead of filtering the union client-side (which
+     * can't work: the dropped items still counted toward this page, so `hasMore`/`cursor` would describe a
+     * different result set than `values`).
      *
-     * One request regardless of how many pull requests are involved — which is what makes it the right
-     * shape for list surfaces, whose pull requests arrive through the shared providers API and so carry no
-     * stack membership of their own. Callers join the result by pull request number.
-     *
-     * A `404` means the repository isn't enrolled in the stacked-pull-requests preview; that's reported as
-     * `undefined` rather than an error, since "no stacks" and "not available" both mean nothing to show.
+     * At least one must be `true`; an all-`false` set reads nothing rather than silently widening back to
+     * the union. The facade never sends one (an empty filter set means "unfiltered" there).
      */
-    getRepositoryStacks(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, options?: {
-        baseUrl?: string;
-    }, cancellation?: AbortSignal): Promise<GitHubStackResource[] | undefined>;
+    categories?: {
+      authored?: boolean;
+      assigned?: boolean;
+      mentioned?: boolean;
+    };
+  }, cancellation?: AbortSignal): Promise<AliasedIssueSearchResult | undefined>;
+  /**
+   * The filtered issue search: issues matching structured criteria over a repository/org scope, with no forced
+   * relationship to the current user. The issue counterpart of {@link searchMyPullRequestsPage}, and distinct
+   * from {@link searchMyIssues}, which is permanently bound to `@me`.
+   *
+   * Ordering is `criteria.sort`, defaulting to most-recently-updated-first — the order this read served before
+   * ordering was an option, so an omitted `sort` emits the identical query. What is NOT optional is that SOME
+   * order is always requested: without one GitHub answers in relevance order, and at the result ceiling that
+   * makes which rows are reachable a function of GitHub's ranking rather than of the request. A key GitHub can't
+   * express (`closed`, `priority`, …) is refused by the facade before the request, not silently downgraded.
+   *
+   * With more than one relationship the page is a UNION of several searches, each ordered by the provider; the
+   * merged page is re-sorted here so the whole page honors the requested key. Across pages the order is still
+   * per-alias — see {@link searchIssuesByAlias}. Note a union can also serve the same issue on two pages when
+   * its relationships OVERLAP (an issue both authored by and assigned to the user sits at different depths in
+   * the two), which predates the ceiling slide and is a property of unioning independent walks: measured at 50
+   * repeats over 450 issues with no ceiling involved. Dedupe by url if that matters to the surface.
+   *
+   * GitHub's per-query result ceiling is NOT terminal here: an alias that runs out of pages while capped
+   * continues bounded to the far side of its own last item, which is a fresh query with a fresh budget. Bounded
+   * per alias, since they exhaust independently. Only a ceiling an alias cannot slide past (a sort key with no
+   * usable range qualifier) is reported as an omission.
+   *
+   * Each requested relationship becomes its own aliased search, unioned and deduped by url; with none, a single
+   * search runs over the scope alone. `criteria.text` and the other free-form values are sanitized so user input
+   * cannot inject a qualifier and re-scope the search — see {@link toGitHubIssueSearchQualifiers}.
+   */
+  searchIssuesPage(provider: Provider, token: GitHubTokenInfo, options?: {
+    repos?: string[];
+    org?: string;
+    criteria?: IssueSearchCriteria;
+    baseUrl?: string;
+    avatarSize?: number;
+    includeBody?: boolean;
+    cursor?: string;
+    pageSize?: number;
+  }, cancellation?: AbortSignal): Promise<AliasedIssueSearchResult | undefined>;
+  /**
+   * Reads back the per-alias ceiling-slide bounds a prior page sealed into its cursor.
+   *
+   * Each value is validated against the EXACT shape {@link toGitHubIssueSearchSlideQualifier} emits, not merely
+   * checked for being a string. A cursor is caller-supplied data on a round trip, so an unvalidated value here
+   * would be a qualifier of someone else's choosing appended to the search: `org:evil-corp` in a cursor would
+   * re-scope the read. Anything unrecognized yields no bound, which restarts that alias at the top — a repeated
+   * page, which is the safe failure.
+   */
+  private parseSlidesFromCursor;
+  /**
+   * Counts issues for several scopes in ONE request, transferring no issues at all — each scope is an aliased
+   * `search` selecting only `issueCount`, with `first: 0` so no nodes are fetched.
+   *
+   * This is what makes a "this will fetch ~N issues" preview affordable: measured against the live API, 30
+   * aliased counts cost a single rate-limit point. It is still a network request per chunk, so a caller is
+   * expected to debounce and cache.
+   *
+   * Returns counts positionally — one per input scope, same order — because a caller-supplied key must never
+   * reach the GraphQL document (it would break it); the aliases are generated. `undefined` in a slot means the
+   * response omitted that alias, which the caller reports as "not counted" rather than as zero.
+   */
+  countIssues(provider: Provider, token: GitHubTokenInfo, scopes: readonly {
+    repos?: string[];
+    org?: string;
+    criteria?: IssueSearchCriteria;
+  }[], options?: {
+    baseUrl?: string;
+  }, cancellation?: AbortSignal): Promise<(number | undefined)[]>;
+  /**
+   * Resolves several issues BY COORDINATE — `(owner, repo, number)` — in one request, via aliased `repository`
+   * fields rather than aliased searches.
+   *
+   * Aliasing the point read rather than {@link searchIssuesByAlias} is the whole design, and each difference
+   * matters to the caller this exists for (correlating a branch name to the issue it references):
+   * - it resolves by EXACT NUMBER, where a search answers a relevance question;
+   * - no result ceiling applies, so there is no partial window to reason about;
+   * - and a null is a PROVEN ABSENCE rather than "not found within a page budget", which is what makes a miss
+   *   cacheable. That last one is the point: a caller that cannot prove absence re-walks its budget forever.
+   *
+   * Returns POSITIONALLY — one slot per input coordinate, in order — for the same reason {@link countIssues}
+   * does: a caller's key is arbitrary text and would break the GraphQL document, so the aliases are generated
+   * and the caller maps back by index. `undefined` in a slot means the issue does not exist (or is not visible
+   * to this token), never that the read failed; a failure throws.
+   */
+  getIssuesBatch(provider: Provider, token: GitHubTokenInfo, coordinates: readonly {
+    owner: string;
+    repo: string;
+    number: number;
+  }[], options?: {
+    baseUrl?: string;
+    avatarSize?: number;
+    includeBody?: boolean;
+  }, cancellation?: AbortSignal): Promise<(IssueShape | undefined)[]>;
+  /**
+   * The PR twin of {@link countIssues}: counts pull requests for several scopes in ONE request via aliased
+   * `search` fields selecting only `issueCount` with `first: 0`. Same positional/undefined contract as the issue
+   * count.
+   *
+   * The one difference is states. {@link toGitHubPullRequestSearchFacets} fans a scope's states out into one
+   * `search` each, so this reports the count the SAME way {@link searchPullRequestsPage} reports its total — the
+   * LARGEST facet's `issueCount`, not their sum: the result ceiling applies per search, so the max is what
+   * `exceedsProviderLimit` compares against, and summing would claim a total the read never surfaces. Relationships
+   * are OR-ed and can't be a single count; the facade refuses a multi-relationship scope, so at most one is here.
+   */
+  countPullRequests(provider: Provider, token: GitHubTokenInfo, scopes: readonly {
+    repos?: string[];
+    org?: string;
+    criteria?: PullRequestSearchCriteria;
+  }[], options?: {
+    baseUrl?: string;
+  }, cancellation?: AbortSignal): Promise<(number | undefined)[]>;
+  /**
+   * The aliased-search engine behind every GitHub issue search: one GraphQL request carrying N independently
+   * cursored `search` fields, `@include`-gated so an exhausted or unrequested one costs nothing.
+   *
+   * It exists as one implementation because the properties that make it correct are subtle and must not be
+   * reproduced per read: each alias advances on its OWN cursor and is dropped from the request once exhausted
+   * (so a finished search is never re-queried, which would re-emit its first page); results are mapped
+   * node-by-node so one unmappable issue can't discard the page; the union is deduped by `url` rather than by
+   * `IssueShape.id`, which for some providers is a per-repository number; and a provider that claims another
+   * page while withholding its `endCursor` is reported as truncated instead of paged forever.
+   *
+   * {@link searchMyIssues} is one configuration of it (its three `@me` categories), and its alias names are
+   * that read's published cursor keys.
+   *
+   * `searches` must have unique aliases, each a valid GraphQL name that is none of `page`, `truncated` or
+   * `sort` — the composite cursor keys aliases at its top level, alongside those three reserved fields.
+   *
+   * `sort` is the order the caller asked for, which this does two things with. Each alias comes back ordered by
+   * it (the qualifier is already in `searches[].query`), but the UNION of several aliases is not, so the merged
+   * page is re-sorted here; and the key is recorded in the cursor, so a continuation that changed it THROWS
+   * rather than serving a sequence with gaps and repeats. Omitted means the caller asked for no order at all
+   * ({@link searchMyIssues}'s default), which re-sorts nothing and pins nothing.
+   *
+   * `legacySort` is the order the calling read produced BEFORE this field existed, and is what a cursor with no
+   * recorded key is compared against — such a cursor is not of unknown order, it is of that read's old one.
+   */
+  private searchIssuesByAlias;
+  /**
+   * Searches pull requests over a repository/org or current-user relationship scope. One GraphQL document carries
+   * every active relationship × state facet, so one HTTP request serves one page even when the logical search is
+   * a union. The cursor preserves each facet's continuation plus the positional page.
+   *
+   * Ordering is `criteria.sort`, defaulting to most-recently-updated-first — the order this read served before it
+   * was expressible. It is requested of the provider AND re-applied to the merged page, because the page is a
+   * union of facets and no per-facet server order describes it. The sort is part of the cursor fingerprint, so
+   * changing it invalidates a threaded cursor exactly as changing the text or the scope does. User text is
+   * sanitized before it reaches the provider query. See {@link toGitHubPullRequestSearchFacets}.
+   */
+  searchPullRequestsPage(provider: Provider, token: GitHubTokenInfo, options?: {
+    repos?: string[];
+    org?: string;
+    criteria?: PullRequestSearchCriteria;
+    baseUrl?: string;
+    avatarSize?: number;
+    cursor?: string;
+    pageSize?: number;
     /**
-     * Merges a stacked pull request, and with it every layer below it.
-     *
-     * Stacks cannot go through `mergePullRequest` — GitHub rejects stacked pull requests on the legacy
-     * synchronous merge endpoints and mutations. The replacement is asynchronous: submit, then poll a
-     * ticket until it reaches a terminal state.
+     * Uses the lightweight PR fragment, retaining identity, body, author, repository, branch refs, and stack
+     * info while omitting review, check, and diff statistics. It also replaces the flat per-facet default with
+     * a budget multi-facet searches share across their active facets, so it raises the page with up to three of
+     * them and LOWERS it from four on.
      */
-    mergeStackedPullRequest(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, pullNumber: number, expectedSourceSha: string, options?: {
-        mergeMethod?: PullRequestMergeMethod;
-        baseUrl?: string;
-    }, cancellation?: AbortSignal): Promise<boolean>;
-    mergePullRequest(provider: Provider, token: GitHubTokenInfo, nodeId: string, expectedSourceSha: string, options?: {
-        mergeMethod?: PullRequestMergeMethod;
-        baseUrl?: string;
-    }, cancellation?: AbortSignal): Promise<boolean>;
+    summary?: boolean;
+  }, cancellation?: AbortSignal): Promise<PullRequestSearchResult | undefined>;
+  searchPullRequests(provider: Provider, token: GitHubTokenInfo, options?: {
+    search?: string;
+    user?: string;
+    repos?: string[];
+    baseUrl?: string;
+    avatarSize?: number;
+    include?: IssueOrPullRequestState[];
+  }, cancellation?: AbortSignal): Promise<PullRequest[]>;
+  /**
+   * Every stack in the repository, each with its members bottom to top.
+   *
+   * One request regardless of how many pull requests are involved — which is what makes it the right
+   * shape for list surfaces, whose pull requests arrive through the shared providers API and so carry no
+   * stack membership of their own. Callers join the result by pull request number.
+   *
+   * A `404` means the repository isn't enrolled in the stacked-pull-requests preview; that's reported as
+   * `undefined` rather than an error, since "no stacks" and "not available" both mean nothing to show.
+   */
+  getRepositoryStacks(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, options?: {
+    baseUrl?: string;
+  }, cancellation?: AbortSignal): Promise<GitHubStackResource[] | undefined>;
+  /**
+   * Merges a stacked pull request, and with it every layer below it.
+   *
+   * Stacks cannot go through `mergePullRequest` — GitHub rejects stacked pull requests on the legacy
+   * synchronous merge endpoints and mutations. The replacement is asynchronous: submit, then poll a
+   * ticket until it reaches a terminal state.
+   */
+  mergeStackedPullRequest(provider: Provider, token: GitHubTokenInfo, owner: string, repo: string, pullNumber: number, expectedSourceSha: string, options?: {
+    mergeMethod?: PullRequestMergeMethod;
+    baseUrl?: string;
+  }, cancellation?: AbortSignal): Promise<boolean>;
+  mergePullRequest(provider: Provider, token: GitHubTokenInfo, nodeId: string, expectedSourceSha: string, options?: {
+    mergeMethod?: PullRequestMergeMethod;
+    baseUrl?: string;
+  }, cancellation?: AbortSignal): Promise<boolean>;
 }
-export declare function toGitHubSearchStateQualifier(include: PullRequestState[] | undefined): string;
+export declare function toGitHubSearchStateQualifier(include: IssueOrPullRequestState[] | undefined): string;
 export declare function filterPullRequestsBySearchState<T extends {
-    state: PullRequestState;
-}>(pullRequests: T[], include: PullRequestState[] | undefined): T[];
+  state: IssueOrPullRequestState;
+}>(pullRequests: T[], include: IssueOrPullRequestState[] | undefined): T[];
+//#endregion
 //# sourceMappingURL=github.d.ts.map