@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/plus/integrations/models/gitHostIntegration.d.ts

@@ -1,430 +1,435 @@
-import type { CollectionMetadata } from '@gitkraken/provider-apis';
-import type { Account, UnidentifiedAuthor } from '../../../git/models/author.js';
-import type { DefaultBranch } from '../../../git/models/defaultBranch.js';
-import type { IssueSearchCriteria, IssueShape } from '../../../git/models/issue.js';
-import type { IssueOrPullRequestState as PullRequestState } from '../../../git/models/issueOrPullRequest.js';
-import type { PullRequest, PullRequestMergeMethod, PullRequestSearchCriteria, PullRequestStackInfo, PullRequestStateFilter } from '../../../git/models/pullRequest.js';
-import type { RepositoryMetadata } from '../../../git/models/repositoryMetadata.js';
-import type { ResourceDescriptor } from '../../../git/models/resourceDescriptor.js';
-import type { PullRequestUrlIdentity } from '../../../git/utils/pullRequest.utils.js';
-import type { PagedResult } from '../../../utils/paging.js';
-import type { ProviderAuthenticationSession } from '../authentication/models.js';
-import type { IntegrationIds } from '../constants.js';
-import type { ProviderApiPagedResult, ProviderHierarchyResult, ProviderIssue, ProviderOrganization, ProviderPullRequest, ProviderRepoInput, ProviderReposInput, ProviderRepository } from '../providers/models.js';
-import { PullRequestFilter } from '../providers/models.js';
-import type { IntegrationResult, IntegrationType, ProviderIssueSearchPage, ProviderPullRequestSearchPage } from './integration.js';
-import { IntegrationBase } from './integration.js';
-import type { MyIssuesForReposOptions } from './issueReads.js';
+import { PagedResult } from "../../../utils/paging.js";
+import { ResourceDescriptor } from "../../../git/models/resourceDescriptor.js";
+import { IssueOrPullRequestState } from "../../../git/models/issueOrPullRequest.js";
+import { IssueSearchCriteria, IssueShape } from "../../../git/models/issue.js";
+import { PullRequest, PullRequestFilter, PullRequestMergeMethod, PullRequestSearchCriteria, PullRequestStackInfo, PullRequestStateFilter } from "../../../git/models/pullRequest.js";
+import { Account as Account$1, UnidentifiedAuthor } from "../../../git/models/author.js";
+import { DefaultBranch } from "../../../git/models/defaultBranch.js";
+import { RepositoryMetadata } from "../../../git/models/repositoryMetadata.js";
+import { PullRequestUrlIdentity } from "../../../git/utils/pullRequest.utils.js";
+import { ProviderAuthenticationSession } from "../authentication/models.js";
+import { IntegrationIds } from "../constants.js";
+import { MyIssuesForReposOptions, ProviderIssueSearchPage } from "./issueReads.js";
+import { ProviderPullRequestSearchPage } from "./pullRequestReads.js";
+import { IntegrationBase, IntegrationResult, IntegrationType } from "./integration.js";
+import { ProviderOrganization } from "../results.js";
+import { ProviderApiPagedResult, ProviderHierarchyResult, ProviderIssue, ProviderPullRequest, ProviderRepoInput, ProviderReposInput, ProviderRepository } from "../providers/models.js";
+import { CollectionMetadata } from "@gitkraken/provider-apis";
+//#region ../plus/integrations/src/models/gitHostIntegration.d.ts
 /** Read options for {@link GitHostIntegration.searchMyPullRequests} and the provider hook behind it. */
 export type SearchMyPullRequestsOptions = {
-    /** Suppresses the user-facing notification when the read fails. */
-    silent?: boolean;
-    /**
-     * PR states to include (open/closed/merged/all). Providers that cannot express it in a single query
-     * filter the normalized results; omitted preserves the historical open-only behavior.
-     */
-    state?: PullRequestStateFilter;
-    includeReviewRequested?: boolean;
+  /** Suppresses the user-facing notification when the read fails. */
+  silent?: boolean;
+  /**
+   * PR states to include (open/closed/merged/all). Providers that cannot express it in a single query
+   * filter the normalized results; omitted preserves the historical open-only behavior.
+   */
+  state?: PullRequestStateFilter;
+  includeReviewRequested?: boolean;
 };
 /** Read options for {@link GitHostIntegration.searchPullRequests} and the provider hook behind it. */
 export type SearchPullRequestsOptions = {
-    /** PR states to include; omitted preserves the provider's default. */
-    include?: PullRequestState[];
+  /** PR states to include; omitted preserves the provider's default. */
+  include?: IssueOrPullRequestState[];
 };
 type MyPullRequestsForReposOptions = {
+  filters?: PullRequestFilter[];
+  cursor?: string;
+  customUrl?: string;
+  page?: number;
+  pageSize?: number;
+  /** PR states to include; when omitted the provider returns its default (open only). */
+  state?: PullRequestStateFilter | PullRequestStateFilter[];
+  /** Requests the lightweight row shape without per-row build status or commit count. */
+  summary?: boolean;
+};
+export declare abstract class GitHostIntegration<ID extends IntegrationIds = IntegrationIds, T extends ResourceDescriptor = ResourceDescriptor> extends IntegrationBase<ID> {
+  readonly type: IntegrationType;
+  getAccountForEmail(repo: T, email: string, options?: {
+    avatarSize?: number;
+  }): Promise<Account$1 | undefined>;
+  protected abstract getProviderAccountForEmail(session: ProviderAuthenticationSession, repo: T, email: string, options?: {
+    avatarSize?: number;
+  }): Promise<Account$1 | undefined>;
+  /**
+   * Returns the SSH signing keys (full OpenSSH-format `<type> <key> [comment]` strings) registered by the accounts
+   * matching the given emails on this integration, for building an `allowed_signers` file. Keyed by lowercased email;
+   * emails with no match (and unsupported integrations) are absent. Batching the lookups is left to the integration.
+   */
+  getSshSigningKeysForEmails(repo: T, emails: string[]): Promise<Map<string, string[]>>;
+  /** Override in integrations that expose users' SSH signing keys. Defaults to none. */
+  protected getProviderSshSigningKeysForEmails(_session: ProviderAuthenticationSession, _repo: T, _emails: string[]): Promise<Map<string, string[]>>;
+  getAccountForCommit(repo: T, rev: string, options?: {
+    avatarSize?: number;
+  }): Promise<Account$1 | UnidentifiedAuthor | undefined>;
+  protected abstract getProviderAccountForCommit(session: ProviderAuthenticationSession, repo: T, rev: string, options?: {
+    avatarSize?: number;
+  }): Promise<Account$1 | UnidentifiedAuthor | undefined>;
+  getDefaultBranch(repo: T, options?: {
+    cancellation?: AbortSignal;
+    expiryOverride?: boolean | number;
+  }): Promise<DefaultBranch | undefined>;
+  getRepoInfo?(repo: {
+    owner: string;
+    name: string;
+    project?: string;
+    connectionId?: string;
+  }): Promise<ProviderRepository | undefined>;
+  /** Stack membership for every stacked pull request in the repository, keyed by pull request number.
+   *  Only hosts with a stacks concept implement this (currently GitHub). */
+  getStacksByPullRequestNumber?(owner: string, repo: string, cancellation?: AbortSignal): Promise<Map<number, PullRequestStackInfo> | undefined>;
+  protected abstract getProviderDefaultBranch({ accessToken }: ProviderAuthenticationSession, repo: T, cancellation?: AbortSignal): Promise<DefaultBranch | undefined>;
+  getRepositoryMetadata(repo: T, options?: {
+    cancellation?: AbortSignal;
+    expiryOverride?: boolean | number;
+  }): Promise<RepositoryMetadata | undefined>;
+  protected abstract getProviderRepositoryMetadata(session: ProviderAuthenticationSession, repo: T, cancellation?: AbortSignal): Promise<RepositoryMetadata | undefined>;
+  /**
+   * Whether this git host implements generic org discovery. False for providers that register no
+   * {@link getProviderOrganizationsForUser} hook (e.g. Bitbucket Data Center) — the facade uses this to
+   * report `unsupported` instead of a silent empty list, which is indistinguishable from "has no orgs".
+   */
+  get supportsOrganizationDiscovery(): boolean;
+  /** Whether this git host implements generic repository discovery ({@link getProviderRepositoriesForOrg}). */
+  get supportsRepositoryDiscovery(): boolean;
+  /**
+   * Whether this git host has a project tier between org and repo ({@link getProviderProjectsForOrg}). Only
+   * Azure DevOps does; the facade uses this to skip the read entirely rather than call a core that returns
+   * `undefined` for a session-less reason and be misread as a broken connection.
+   */
+  get supportsProjectDiscovery(): boolean;
+  /**
+   * Whether this git host implements the account-wide user-affiliated repository read
+   * ({@link getProviderRepositoriesForUser}) — the org-less `gk provider repos <provider>` equivalent.
+   */
+  get supportsUserRepositoryDiscovery(): boolean;
+  /**
+   * Whether this git host exposes issues on the ProviderBackend surface. Most git hosts do; a host with no
+   * usable issue tracker overrides this to false — Bitbucket Cloud (deprecated in favor of dedicated issue
+   * integrations like Jira) and Bitbucket Data Center (never had one) — so the facade reports issues as
+   * unsupported instead of serving a partial/deprecated source or failing inside a provider client that
+   * registers no issue function at all.
+   *
+   * Keep this in sync with {@link ProviderMetadata.supportedIssueFilters}: a provider that declares no issue
+   * filters and no issue read is answering the same capability question twice, and the two must agree.
+   */
+  get supportsIssues(): boolean;
+  /**
+   * Lists the organizations (orgs/workspaces/groups) the current user belongs to on this host.
+   * `truncated === true` means the defensive page-drain backstop stopped before the upstream listing was
+   * exhausted.
+   *
+   * Resolves the session for `connectionId` (or the primary connection when omitted, honoring multi-account
+   * reads) and recovers a thrown error into `{ error }` so callers can surface it as a warning instead of
+   * swallowing it to `undefined`.
+   */
+  getOrganizationsForUserResult(connectionId?: string): Promise<IntegrationResult<ProviderHierarchyResult<ProviderOrganization> | undefined>>;
+  protected getProviderOrganizationsForUser?(session: ProviderAuthenticationSession): Promise<ProviderHierarchyResult<ProviderOrganization> | undefined>;
+  /**
+   * Result-returning list of the projects a git host exposes beneath its orgs, unified into the
+   * {@link ProviderOrganization} shape. Only Azure DevOps has a project tier between org and repo; other
+   * git hosts have none and leave {@link getProviderProjectsForOrg} undefined, so this returns `undefined`
+   * for them (the ProviderBackend facade then treats them as having no projects). With `org`, scopes to
+   * that org's projects; without, returns projects across every org the user can see.
+   */
+  getProjectsForOrgResult(org?: string, connectionId?: string): Promise<IntegrationResult<ProviderHierarchyResult<ProviderOrganization> | undefined>>;
+  protected getProviderProjectsForOrg?(session: ProviderAuthenticationSession, org?: string): Promise<ProviderHierarchyResult<ProviderOrganization> | undefined>;
+  /**
+   * Lists repositories under the given organization (org/workspace/group) one page at a time — follow
+   * `paging.cursor` to page, or drain with the integrations provider paging helper.
+   * `options.project` is only meaningful for Azure DevOps, whose repos are scoped by `org` + `project`;
+   * every other host ignores it. (Azure without a project can't page its cross-project merge, so it
+   * returns all matches in a single page.) `truncated === true` means the defensive page-drain
+   * backstop stopped before the upstream listing was exhausted.
+   *
+   * Resolves the session for `connectionId` (or the primary connection when omitted) and recovers a thrown
+   * error into `{ error }`, so a caller surfaces it as a warning instead of a silent `undefined`.
+   */
+  getRepositoriesForOrgResult(org: string, options?: {
+    project?: string;
+    cursor?: string;
+    connectionId?: string;
+  }): Promise<IntegrationResult<ProviderHierarchyResult<ProviderRepository> | undefined>>;
+  protected getProviderRepositoriesForOrg?(session: ProviderAuthenticationSession, org: string, options?: {
+    project?: string;
+    cursor?: string;
+  }): Promise<ProviderHierarchyResult<ProviderRepository> | undefined>;
+  /**
+   * Result-returning account-wide, user-affiliated repository read (the org-less
+   * `gk provider repos <provider>` equivalent): repositories the user owns, collaborates on, or can
+   * access through org membership — NOT every repo of every org. Optional: providers without a native
+   * user-affiliated listing (Bitbucket workspaces, Azure orgs, which require an org/workspace scope)
+   * leave the hook undefined and the facade reports the read as unsupported so callers fan out per org.
+   */
+  getRepositoriesForUserResult(options?: {
+    cursor?: string;
+    connectionId?: string;
+  }): Promise<IntegrationResult<ProviderHierarchyResult<ProviderRepository> | undefined>>;
+  protected getProviderRepositoriesForUser?(session: ProviderAuthenticationSession, options?: {
+    cursor?: string;
+  }): Promise<ProviderHierarchyResult<ProviderRepository> | undefined>;
+  mergePullRequest(pr: PullRequest, options?: {
+    mergeMethod?: PullRequestMergeMethod;
+  }, cancellation?: AbortSignal): Promise<boolean>;
+  protected abstract mergeProviderPullRequest(session: ProviderAuthenticationSession, pr: PullRequest, options?: {
+    mergeMethod?: PullRequestMergeMethod;
+  }, cancellation?: AbortSignal): Promise<boolean>;
+  getPullRequestForBranch(repo: T, branch: string, options?: {
+    avatarSize?: number;
+    expiryOverride?: boolean | number;
+    include?: IssueOrPullRequestState[];
+    /** Rethrow a failed lookup instead of folding it into `undefined`, for callers that must tell
+     *  "no pull request" apart from "couldn't ask". */
+    throwOnError?: boolean;
+  }): Promise<PullRequest | undefined>;
+  protected abstract getProviderPullRequestForBranch(session: ProviderAuthenticationSession, repo: T, branch: string, options?: {
+    avatarSize?: number;
+    include?: IssueOrPullRequestState[];
+  }): Promise<PullRequest | undefined>;
+  getPullRequestForCommit(repo: T, rev: string, options?: {
+    expiryOverride?: boolean | number;
+    throwOnError?: boolean;
+  }): Promise<PullRequest | undefined>;
+  protected abstract getProviderPullRequestForCommit(session: ProviderAuthenticationSession, repo: T, rev: string): Promise<PullRequest | undefined>;
+  /**
+   * Memoized identity lookups backing filter resolution. Keyed by the session's token fingerprint plus the
+   * scope of the lookup (base URL, and the Azure organization for the per-instance variant), so a different
+   * account, host, or org never reuses an entry and a rotated token simply misses.
+   *
+   * Not cleared when the token changes: one integration instance serves every connection of its provider
+   * (multi-account), so clearing on a fingerprint change would make two accounts reading in alternation
+   * evict each other and defeat the memo. Entries are bounded by tokens x hosts x orgs seen — a handful for
+   * the life of the integration.
+   */
+  private readonly _filterAccounts;
+  /**
+   * Resolves the account a repo-scoped read turns `IssueFilter`/`PullRequestFilter` into a provider
+   * login/id with, memoized per token+scope.
+   *
+   * Every FILTERED read needs this, and `ProvidersApi.getCurrentUser` is a bare round trip — unlike
+   * {@link IntegrationBase.getCurrentAccount}, which the host caches. So a consumer that fans ONE page out
+   * into several filtered reads paid one identity request PER read, all resolving the same account: a
+   * per-user-facet fan-out (author + assignee + review-requested) doubled its request count, and paid it
+   * again on every page turn.
+   *
+   * The promise is memoized rather than the value, so concurrent facets share one in-flight request instead
+   * of racing. A rejection is evicted so the next read retries rather than caching a failure — matching how
+   * `getCurrentAccount` invalidates on error.
+   */
+  private getFilterAccount;
+  getMyIssuesForRepos(reposOrRepoIds: ProviderReposInput, options?: MyIssuesForReposOptions, connectionId?: string): Promise<PagedResult<ProviderIssue> | undefined>;
+  /**
+   * Result-returning core of {@link getMyIssuesForRepos}. Resolves the session for `connectionId`
+   * (or the primary connection when omitted, so multi-account reads use the right token) and recovers
+   * thrown errors and validation failures into `{ error }` so callers can surface them as warnings
+   * rather than swallowing them to `undefined`.
+   */
+  getMyIssuesForReposResult(reposOrRepoIds: ProviderReposInput, options?: MyIssuesForReposOptions, connectionId?: string): Promise<IntegrationResult<(PagedResult<ProviderIssue> & {
+    metadata?: CollectionMetadata;
+  }) | undefined>>;
+  /**
+   * Repo-scoped "my issues" read returning the normalized {@link IssueShape} the ProviderBackend facade
+   * consumes (`listIssuesPage({ repos })`, `broadenIssues`). Maps {@link getMyIssuesForReposResult} — the raw
+   * provider-apis path — to IssueShape.
+   *
+   * It's the seam rather than an inline map so a provider whose only issue client already yields normalized
+   * shapes, and isn't wired into the raw path, can override it and serve these reads without a
+   * `ProviderIssue` round-trip. No provider does today: the one candidate (Bitbucket Cloud's legacy
+   * `getUsersIssuesForRepo`) reports `supportsIssues: false`, so the facade never reaches this for it.
+   */
+  getMyIssuesForReposAsShapesResult(reposOrRepoIds: ProviderReposInput, options?: MyIssuesForReposOptions, connectionId?: string): Promise<IntegrationResult<(PagedResult<IssueShape> & {
+    metadata?: CollectionMetadata;
+  }) | undefined>>;
+  getMyPullRequestsForRepos(reposOrRepoIds: ProviderReposInput, options?: MyPullRequestsForReposOptions, connectionId?: string): Promise<ProviderApiPagedResult<ProviderPullRequest> | undefined>;
+  /**
+   * Result-returning core of {@link getMyPullRequestsForRepos}. Resolves the session for `connectionId`
+   * (or the primary connection when omitted, so multi-account reads use the right token) and recovers
+   * thrown errors and validation failures into `{ error }` so callers can surface them as warnings
+   * rather than swallowing them to `undefined`.
+   */
+  getMyPullRequestsForReposResult(reposOrRepoIds: ProviderReposInput, options?: MyPullRequestsForReposOptions, connectionId?: string): Promise<IntegrationResult<ProviderApiPagedResult<ProviderPullRequest> | undefined>>;
+  /** Account-wide (or repo-scoped) search for the current user's pull requests. */
+  searchMyPullRequests(repos?: T | T[], cancellation?: AbortSignal, options?: SearchMyPullRequestsOptions & {
+    connectionId?: string;
+  }): Promise<IntegrationResult<PullRequest[] | undefined>>;
+  /**
+   * Account-wide, user-scoped counterpart of {@link getMyPullRequestsForReposResult} that returns the raw
+   * `ProviderPullRequest` shape (not the normalized model). Unlike the repo-scoped core, this needs no
+   * `repos` — it reads the current user's pull requests across the account, so the ProviderBackend sweep
+   * can drive its Kanban "done" column even when no repositories are supplied (where the repo-scoped core
+   * rejects an empty `repos` input). Recovers thrown errors into `{ error }` so callers surface warnings.
+   */
+  getMyPullRequestsForUserResult(options?: {
+    state?: PullRequestStateFilter[];
+    cursor?: string;
+    includeReviewRequested?: boolean;
+    /** Exact OR union of account-wide relationships to include. */
     filters?: PullRequestFilter[];
+    /** Request only the stable list fields, omitting optional provider enrichments. */
+    summary?: boolean;
+  }, connectionId?: string): Promise<IntegrationResult<ProviderApiPagedResult<ProviderPullRequest> | undefined>>;
+  /**
+   * Reads the current user's pull requests across the whole account using each provider's native "my PRs"
+   * query, returning the raw provider shape. Without `filters`, the exact user scopes depend on provider-native
+   * behavior and options like `includeReviewRequested`. With `filters`, each member is an exact account-wide OR
+   * relationship validated by the facade before this provider hook is called. Optional: providers that can't
+   * express an account-wide user query leave it undefined and the surface falls back to repo-scoped.
+   *
+   * These native user queries are cursor-based, so `cursor` (not a page number) drives continuation; there
+   * is no jump-to-page-N and no per-call page size on this path.
+   *
+   * `includeReviewRequested` opts into the review-requested slice for providers whose account-wide read
+   * only returns authored PRs natively and must fan out per-repo to add reviewer PRs (Bitbucket). It's off
+   * by default so a sweep pays gkcli-parity cost (authored only) unless the caller deliberately opts in;
+   * providers whose native query already covers review-requested PRs ignore it.
+   */
+  protected getProviderMyPullRequestsForUser?(session: ProviderAuthenticationSession, options?: {
+    state?: PullRequestStateFilter[];
+    cursor?: string;
+    includeReviewRequested?: boolean;
+    filters?: PullRequestFilter[];
+    summary?: boolean;
+  }): Promise<ProviderApiPagedResult<ProviderPullRequest> | undefined>;
+  /**
+   * Parses a Repo/Project paging cursor into its `cursors` bundle. Guards against valid JSON whose
+   * `cursors` is a truthy non-array (e.g. `{ "cursors": "..." }`), which would otherwise bypass the
+   * `?? []` fallback at call sites and flow into `.map()` downstream, throwing instead of degrading to
+   * the first page.
+   */
+  private parseCursorInfo;
+  protected abstract searchProviderMyPullRequests(session: ProviderAuthenticationSession, repos?: T[], cancellation?: AbortSignal, options?: SearchMyPullRequestsOptions): Promise<PullRequest[] | undefined>;
+  /**
+   * Result-returning wrapper for the filtered pull-request search. Errors become the soft
+   * `{ error }` branch so the public facade can preserve an empty account and a failed request as distinct
+   * outcomes.
+   */
+  searchPullRequestsPageResult(options: {
+    repos?: ProviderRepoInput[];
+    org?: string;
+    criteria?: PullRequestSearchCriteria;
     cursor?: string;
-    customUrl?: string;
-    page?: number;
     pageSize?: number;
-    /** PR states to include; when omitted the provider returns its default (open only). */
-    state?: PullRequestStateFilter | PullRequestStateFilter[];
-    /** Requests the lightweight row shape without per-row build status or commit count. */
+    /** See {@link IntegrationManager.searchPullRequestsPage}. */
     summary?: boolean;
-};
-export declare abstract class GitHostIntegration<ID extends IntegrationIds = IntegrationIds, T extends ResourceDescriptor = ResourceDescriptor> extends IntegrationBase<ID> {
-    readonly type: IntegrationType;
-    getAccountForEmail(repo: T, email: string, options?: {
-        avatarSize?: number;
-    }): Promise<Account | undefined>;
-    protected abstract getProviderAccountForEmail(session: ProviderAuthenticationSession, repo: T, email: string, options?: {
-        avatarSize?: number;
-    }): Promise<Account | undefined>;
-    /**
-     * Returns the SSH signing keys (full OpenSSH-format `<type> <key> [comment]` strings) registered by the accounts
-     * matching the given emails on this integration, for building an `allowed_signers` file. Keyed by lowercased email;
-     * emails with no match (and unsupported integrations) are absent. Batching the lookups is left to the integration.
-     */
-    getSshSigningKeysForEmails(repo: T, emails: string[]): Promise<Map<string, string[]>>;
-    /** Override in integrations that expose users' SSH signing keys. Defaults to none. */
-    protected getProviderSshSigningKeysForEmails(_session: ProviderAuthenticationSession, _repo: T, _emails: string[]): Promise<Map<string, string[]>>;
-    getAccountForCommit(repo: T, rev: string, options?: {
-        avatarSize?: number;
-    }): Promise<Account | UnidentifiedAuthor | undefined>;
-    protected abstract getProviderAccountForCommit(session: ProviderAuthenticationSession, repo: T, rev: string, options?: {
-        avatarSize?: number;
-    }): Promise<Account | UnidentifiedAuthor | undefined>;
-    getDefaultBranch(repo: T, options?: {
-        cancellation?: AbortSignal;
-        expiryOverride?: boolean | number;
-    }): Promise<DefaultBranch | undefined>;
-    getRepoInfo?(repo: {
-        owner: string;
-        name: string;
-        project?: string;
-        connectionId?: string;
-    }): Promise<ProviderRepository | undefined>;
-    /** Stack membership for every stacked pull request in the repository, keyed by pull request number.
-     *  Only hosts with a stacks concept implement this (currently GitHub). */
-    getStacksByPullRequestNumber?(owner: string, repo: string, cancellation?: AbortSignal): Promise<Map<number, PullRequestStackInfo> | undefined>;
-    protected abstract getProviderDefaultBranch({ accessToken }: ProviderAuthenticationSession, repo: T, cancellation?: AbortSignal): Promise<DefaultBranch | undefined>;
-    getRepositoryMetadata(repo: T, options?: {
-        cancellation?: AbortSignal;
-        expiryOverride?: boolean | number;
-    }): Promise<RepositoryMetadata | undefined>;
-    protected abstract getProviderRepositoryMetadata(session: ProviderAuthenticationSession, repo: T, cancellation?: AbortSignal): Promise<RepositoryMetadata | undefined>;
-    /**
-     * Whether this git host implements generic org discovery. False for providers that register no
-     * {@link getProviderOrganizationsForUser} hook (e.g. Bitbucket Data Center) — the facade uses this to
-     * report `unsupported` instead of a silent empty list, which is indistinguishable from "has no orgs".
-     */
-    get supportsOrganizationDiscovery(): boolean;
-    /** Whether this git host implements generic repository discovery ({@link getProviderRepositoriesForOrg}). */
-    get supportsRepositoryDiscovery(): boolean;
-    /**
-     * Whether this git host has a project tier between org and repo ({@link getProviderProjectsForOrg}). Only
-     * Azure DevOps does; the facade uses this to skip the read entirely rather than call a core that returns
-     * `undefined` for a session-less reason and be misread as a broken connection.
-     */
-    get supportsProjectDiscovery(): boolean;
-    /**
-     * Whether this git host implements the account-wide user-affiliated repository read
-     * ({@link getProviderRepositoriesForUser}) — the org-less `gk provider repos <provider>` equivalent.
-     */
-    get supportsUserRepositoryDiscovery(): boolean;
-    /**
-     * Whether this git host exposes issues on the ProviderBackend surface. Most git hosts do; a host with no
-     * usable issue tracker overrides this to false — Bitbucket Cloud (deprecated in favor of dedicated issue
-     * integrations like Jira) and Bitbucket Data Center (never had one) — so the facade reports issues as
-     * unsupported instead of serving a partial/deprecated source or failing inside a provider client that
-     * registers no issue function at all.
-     *
-     * Keep this in sync with {@link ProviderMetadata.supportedIssueFilters}: a provider that declares no issue
-     * filters and no issue read is answering the same capability question twice, and the two must agree.
-     */
-    get supportsIssues(): boolean;
-    /**
-     * Lists the organizations (orgs/workspaces/groups) the current user belongs to on this host.
-     * `truncated === true` means the defensive page-drain backstop stopped before the upstream listing was
-     * exhausted.
-     *
-     * Resolves the session for `connectionId` (or the primary connection when omitted, honoring multi-account
-     * reads) and recovers a thrown error into `{ error }` so callers can surface it as a warning instead of
-     * swallowing it to `undefined`.
-     */
-    getOrganizationsForUserResult(connectionId?: string): Promise<IntegrationResult<ProviderHierarchyResult<ProviderOrganization> | undefined>>;
-    protected getProviderOrganizationsForUser?(session: ProviderAuthenticationSession): Promise<ProviderHierarchyResult<ProviderOrganization> | undefined>;
-    /**
-     * Result-returning list of the projects a git host exposes beneath its orgs, unified into the
-     * {@link ProviderOrganization} shape. Only Azure DevOps has a project tier between org and repo; other
-     * git hosts have none and leave {@link getProviderProjectsForOrg} undefined, so this returns `undefined`
-     * for them (the ProviderBackend facade then treats them as having no projects). With `org`, scopes to
-     * that org's projects; without, returns projects across every org the user can see.
-     */
-    getProjectsForOrgResult(org?: string, connectionId?: string): Promise<IntegrationResult<ProviderHierarchyResult<ProviderOrganization> | undefined>>;
-    protected getProviderProjectsForOrg?(session: ProviderAuthenticationSession, org?: string): Promise<ProviderHierarchyResult<ProviderOrganization> | undefined>;
-    /**
-     * Lists repositories under the given organization (org/workspace/group) one page at a time — follow
-     * `paging.cursor` to page, or drain with the integrations provider paging helper.
-     * `options.project` is only meaningful for Azure DevOps, whose repos are scoped by `org` + `project`;
-     * every other host ignores it. (Azure without a project can't page its cross-project merge, so it
-     * returns all matches in a single page.) `truncated === true` means the defensive page-drain
-     * backstop stopped before the upstream listing was exhausted.
-     *
-     * Resolves the session for `connectionId` (or the primary connection when omitted) and recovers a thrown
-     * error into `{ error }`, so a caller surfaces it as a warning instead of a silent `undefined`.
-     */
-    getRepositoriesForOrgResult(org: string, options?: {
-        project?: string;
-        cursor?: string;
-        connectionId?: string;
-    }): Promise<IntegrationResult<ProviderHierarchyResult<ProviderRepository> | undefined>>;
-    protected getProviderRepositoriesForOrg?(session: ProviderAuthenticationSession, org: string, options?: {
-        project?: string;
-        cursor?: string;
-    }): Promise<ProviderHierarchyResult<ProviderRepository> | undefined>;
-    /**
-     * Result-returning account-wide, user-affiliated repository read (the org-less
-     * `gk provider repos <provider>` equivalent): repositories the user owns, collaborates on, or can
-     * access through org membership — NOT every repo of every org. Optional: providers without a native
-     * user-affiliated listing (Bitbucket workspaces, Azure orgs, which require an org/workspace scope)
-     * leave the hook undefined and the facade reports the read as unsupported so callers fan out per org.
-     */
-    getRepositoriesForUserResult(options?: {
-        cursor?: string;
-        connectionId?: string;
-    }): Promise<IntegrationResult<ProviderHierarchyResult<ProviderRepository> | undefined>>;
-    protected getProviderRepositoriesForUser?(session: ProviderAuthenticationSession, options?: {
-        cursor?: string;
-    }): Promise<ProviderHierarchyResult<ProviderRepository> | undefined>;
-    mergePullRequest(pr: PullRequest, options?: {
-        mergeMethod?: PullRequestMergeMethod;
-    }, cancellation?: AbortSignal): Promise<boolean>;
-    protected abstract mergeProviderPullRequest(session: ProviderAuthenticationSession, pr: PullRequest, options?: {
-        mergeMethod?: PullRequestMergeMethod;
-    }, cancellation?: AbortSignal): Promise<boolean>;
-    getPullRequestForBranch(repo: T, branch: string, options?: {
-        avatarSize?: number;
-        expiryOverride?: boolean | number;
-        include?: PullRequestState[];
-    }): Promise<PullRequest | undefined>;
-    protected abstract getProviderPullRequestForBranch(session: ProviderAuthenticationSession, repo: T, branch: string, options?: {
-        avatarSize?: number;
-        include?: PullRequestState[];
-    }): Promise<PullRequest | undefined>;
-    getPullRequestForCommit(repo: T, rev: string, options?: {
-        expiryOverride?: boolean | number;
-    }): Promise<PullRequest | undefined>;
-    protected abstract getProviderPullRequestForCommit(session: ProviderAuthenticationSession, repo: T, rev: string): Promise<PullRequest | undefined>;
-    /**
-     * Memoized identity lookups backing filter resolution. Keyed by the session's token fingerprint plus the
-     * scope of the lookup (base URL, and the Azure organization for the per-instance variant), so a different
-     * account, host, or org never reuses an entry and a rotated token simply misses.
-     *
-     * Not cleared when the token changes: one integration instance serves every connection of its provider
-     * (multi-account), so clearing on a fingerprint change would make two accounts reading in alternation
-     * evict each other and defeat the memo. Entries are bounded by tokens x hosts x orgs seen — a handful for
-     * the life of the integration.
-     */
-    private readonly _filterAccounts;
-    /**
-     * Resolves the account a repo-scoped read turns `IssueFilter`/`PullRequestFilter` into a provider
-     * login/id with, memoized per token+scope.
-     *
-     * Every FILTERED read needs this, and `ProvidersApi.getCurrentUser` is a bare round trip — unlike
-     * {@link IntegrationBase.getCurrentAccount}, which the host caches. So a consumer that fans ONE page out
-     * into several filtered reads paid one identity request PER read, all resolving the same account: a
-     * per-user-facet fan-out (author + assignee + review-requested) doubled its request count, and paid it
-     * again on every page turn.
-     *
-     * The promise is memoized rather than the value, so concurrent facets share one in-flight request instead
-     * of racing. A rejection is evicted so the next read retries rather than caching a failure — matching how
-     * `getCurrentAccount` invalidates on error.
-     */
-    private getFilterAccount;
-    getMyIssuesForRepos(reposOrRepoIds: ProviderReposInput, options?: MyIssuesForReposOptions, connectionId?: string): Promise<PagedResult<ProviderIssue> | undefined>;
-    /**
-     * Result-returning core of {@link getMyIssuesForRepos}. Resolves the session for `connectionId`
-     * (or the primary connection when omitted, so multi-account reads use the right token) and recovers
-     * thrown errors and validation failures into `{ error }` so callers can surface them as warnings
-     * rather than swallowing them to `undefined`.
-     */
-    getMyIssuesForReposResult(reposOrRepoIds: ProviderReposInput, options?: MyIssuesForReposOptions, connectionId?: string): Promise<IntegrationResult<(PagedResult<ProviderIssue> & {
-        metadata?: CollectionMetadata;
-    }) | undefined>>;
-    /**
-     * Repo-scoped "my issues" read returning the normalized {@link IssueShape} the ProviderBackend facade
-     * consumes (`listIssuesPage({ repos })`, `broadenIssues`). Maps {@link getMyIssuesForReposResult} — the raw
-     * provider-apis path — to IssueShape.
-     *
-     * It's the seam rather than an inline map so a provider whose only issue client already yields normalized
-     * shapes, and isn't wired into the raw path, can override it and serve these reads without a
-     * `ProviderIssue` round-trip. No provider does today: the one candidate (Bitbucket Cloud's legacy
-     * `getUsersIssuesForRepo`) reports `supportsIssues: false`, so the facade never reaches this for it.
-     */
-    getMyIssuesForReposAsShapesResult(reposOrRepoIds: ProviderReposInput, options?: MyIssuesForReposOptions, connectionId?: string): Promise<IntegrationResult<(PagedResult<IssueShape> & {
-        metadata?: CollectionMetadata;
-    }) | undefined>>;
-    getMyPullRequestsForRepos(reposOrRepoIds: ProviderReposInput, options?: MyPullRequestsForReposOptions, connectionId?: string): Promise<ProviderApiPagedResult<ProviderPullRequest> | undefined>;
-    /**
-     * Result-returning core of {@link getMyPullRequestsForRepos}. Resolves the session for `connectionId`
-     * (or the primary connection when omitted, so multi-account reads use the right token) and recovers
-     * thrown errors and validation failures into `{ error }` so callers can surface them as warnings
-     * rather than swallowing them to `undefined`.
-     */
-    getMyPullRequestsForReposResult(reposOrRepoIds: ProviderReposInput, options?: MyPullRequestsForReposOptions, connectionId?: string): Promise<IntegrationResult<ProviderApiPagedResult<ProviderPullRequest> | undefined>>;
-    /** Account-wide (or repo-scoped) search for the current user's pull requests. */
-    searchMyPullRequests(repos?: T | T[], cancellation?: AbortSignal, options?: SearchMyPullRequestsOptions & {
-        connectionId?: string;
-    }): Promise<IntegrationResult<PullRequest[] | undefined>>;
-    /**
-     * Account-wide, user-scoped counterpart of {@link getMyPullRequestsForReposResult} that returns the raw
-     * `ProviderPullRequest` shape (not the normalized model). Unlike the repo-scoped core, this needs no
-     * `repos` — it reads the current user's pull requests across the account, so the ProviderBackend sweep
-     * can drive its Kanban "done" column even when no repositories are supplied (where the repo-scoped core
-     * rejects an empty `repos` input). Recovers thrown errors into `{ error }` so callers surface warnings.
-     */
-    getMyPullRequestsForUserResult(options?: {
-        state?: PullRequestStateFilter[];
-        cursor?: string;
-        includeReviewRequested?: boolean;
-        /** Exact OR union of account-wide relationships to include. */
-        filters?: PullRequestFilter[];
-        /** Request only the stable list fields, omitting optional provider enrichments. */
-        summary?: boolean;
-    }, connectionId?: string): Promise<IntegrationResult<ProviderApiPagedResult<ProviderPullRequest> | undefined>>;
-    /**
-     * Reads the current user's pull requests across the whole account using each provider's native "my PRs"
-     * query, returning the raw provider shape. Without `filters`, the exact user scopes depend on provider-native
-     * behavior and options like `includeReviewRequested`. With `filters`, each member is an exact account-wide OR
-     * relationship validated by the facade before this provider hook is called. Optional: providers that can't
-     * express an account-wide user query leave it undefined and the surface falls back to repo-scoped.
-     *
-     * These native user queries are cursor-based, so `cursor` (not a page number) drives continuation; there
-     * is no jump-to-page-N and no per-call page size on this path.
-     *
-     * `includeReviewRequested` opts into the review-requested slice for providers whose account-wide read
-     * only returns authored PRs natively and must fan out per-repo to add reviewer PRs (Bitbucket). It's off
-     * by default so a sweep pays gkcli-parity cost (authored only) unless the caller deliberately opts in;
-     * providers whose native query already covers review-requested PRs ignore it.
-     */
-    protected getProviderMyPullRequestsForUser?(session: ProviderAuthenticationSession, options?: {
-        state?: PullRequestStateFilter[];
-        cursor?: string;
-        includeReviewRequested?: boolean;
-        filters?: PullRequestFilter[];
-        summary?: boolean;
-    }): Promise<ProviderApiPagedResult<ProviderPullRequest> | undefined>;
-    /**
-     * Parses a Repo/Project paging cursor into its `cursors` bundle. Guards against valid JSON whose
-     * `cursors` is a truthy non-array (e.g. `{ "cursors": "..." }`), which would otherwise bypass the
-     * `?? []` fallback at call sites and flow into `.map()` downstream, throwing instead of degrading to
-     * the first page.
-     */
-    private parseCursorInfo;
-    protected abstract searchProviderMyPullRequests(session: ProviderAuthenticationSession, repos?: T[], cancellation?: AbortSignal, options?: SearchMyPullRequestsOptions): Promise<PullRequest[] | undefined>;
-    /**
-     * Result-returning wrapper for the filtered pull-request search. Errors become the soft
-     * `{ error }` branch so the public facade can preserve an empty account and a failed request as distinct
-     * outcomes.
-     */
-    searchPullRequestsPageResult(options: {
-        repos?: ProviderRepoInput[];
-        org?: string;
-        criteria?: PullRequestSearchCriteria;
-        cursor?: string;
-        pageSize?: number;
-        /** See {@link IntegrationManager.searchPullRequestsPage}. */
-        summary?: boolean;
-    }, cancellation?: AbortSignal, connectionId?: string): Promise<IntegrationResult<ProviderPullRequestSearchPage | undefined>>;
-    /** Must agree with `ProviderMetadata.supportedPullRequestSearch`. */
-    protected searchProviderPullRequestsPage?(session: ProviderAuthenticationSession, options: {
-        repos?: ProviderRepoInput[];
-        org?: string;
-        criteria?: PullRequestSearchCriteria;
-        cursor?: string;
-        pageSize?: number;
-        /** See the caller's option of the same name on {@link searchPullRequestsPage}. */
-        summary?: boolean;
-    }, cancellation?: AbortSignal): Promise<ProviderPullRequestSearchPage | undefined>;
-    /** Free-text search across pull requests, optionally narrowed to `repos`. */
-    searchPullRequests(searchQuery: string, repos?: T | T[], cancellation?: AbortSignal, options?: SearchPullRequestsOptions & {
-        connectionId?: string;
-    }): Promise<PullRequest[] | undefined>;
-    protected searchProviderPullRequests?(session: ProviderAuthenticationSession, searchQuery: string, repos?: T[], cancellation?: AbortSignal, options?: SearchPullRequestsOptions): Promise<PullRequest[] | undefined>;
-    /**
-     * Result-returning wrapper for the FILTERED issue search — issues matching structured criteria over a
-     * repository/org scope, with no forced relationship to the current user. Recovers thrown errors into
-     * `{ error }` so the facade surfaces a warning instead of a silent empty page.
-     *
-     * Distinct from every other issue read on this class: {@link searchMyIssuesWithTruncationResult} is bound to
-     * the current user by construction, and {@link getMyIssuesForReposAsShapesResult} goes through the SDK's
-     * repo-scoped read (whose over-limit recovery walk can cost up to 128 requests). This one is one request per
-     * page and carries no relationship it wasn't asked for.
-     */
-    searchIssuesPageResult(options: {
-        /**
-         * Repositories to search, as namespace/name descriptors. NOT repository ids: a search query names
-         * repositories by path, so an id-based input can't be expressed and the facade rejects it before here.
-         */
-        repos?: ProviderRepoInput[];
-        org?: string;
-        criteria?: IssueSearchCriteria;
-        cursor?: string;
-        pageSize?: number;
-    }, cancellation?: AbortSignal, connectionId?: string): Promise<IntegrationResult<ProviderIssueSearchPage | undefined>>;
-    /**
-     * OPTIONAL, like {@link searchProviderPullRequests}: a provider that can't express the criteria server-side
-     * doesn't implement it, and the facade refuses the read (warning + `fetchFailed`) rather than serving a list
-     * that was never narrowed. Whether a provider implements this must agree with what
-     * `ProviderMetadata.supportedIssueSearch` declares.
-     */
-    protected searchProviderIssuesPage?(session: ProviderAuthenticationSession, options: {
-        repos?: ProviderRepoInput[];
-        org?: string;
-        criteria?: IssueSearchCriteria;
-        cursor?: string;
-        pageSize?: number;
-    }, cancellation?: AbortSignal): Promise<ProviderIssueSearchPage | undefined>;
-    /**
-     * Result-returning wrapper for the count-only probe: how many issues MATCH each scope, transferring no issues
-     * at all. Recovers thrown errors into `{ error }` like the reads around it.
-     *
-     * Counts come back POSITIONALLY — one per input scope, in order — because a caller's key must never reach the
-     * provider query. `undefined` in a slot means the provider didn't report a count for it, never zero matches.
-     */
-    countIssuesResult(scopes: readonly {
-        repos?: ProviderRepoInput[];
-        org?: string;
-        criteria?: IssueSearchCriteria;
-    }[], cancellation?: AbortSignal, connectionId?: string): Promise<IntegrationResult<(number | undefined)[] | undefined>>;
-    /**
-     * OPTIONAL: only a provider that can answer "how many match" WITHOUT fetching the matches implements this.
-     * GitHub's search reports `issueCount` on a zero-node selection; GitLab's REST exposes a total on some
-     * endpoints but not for a search-shaped query, and Azure has no equivalent. A provider that can't answer
-     * doesn't implement it and the facade refuses the probe, so a consumer hides its count rather than being shown
-     * a fabricated one.
-     */
-    protected countProviderIssues?(session: ProviderAuthenticationSession, scopes: readonly {
-        repos?: ProviderRepoInput[];
-        org?: string;
-        criteria?: IssueSearchCriteria;
-    }[], cancellation?: AbortSignal): Promise<(number | undefined)[] | undefined>;
-    /**
-     * Result-returning wrapper for the BATCH issue read: resolves several `(owner, repo, number)` coordinates in
-     * one request. Recovers thrown errors into `{ error }` like the reads around it.
-     *
-     * Distinct from every search on this class, and deliberately so. A search answers "what matches"; this answers
-     * "does this exact issue exist", which is the question a caller correlating a branch name to an issue is
-     * actually asking. It has no result ceiling, no ordering and no cursor, and — the property that matters most —
-     * an absent slot is a PROVEN ABSENCE rather than "not found within a page budget", so a caller can cache a
-     * miss instead of re-walking for it forever.
-     *
-     * Results come back POSITIONALLY — one per input coordinate, in order — for the same reason
-     * {@link countIssuesResult} does: a caller's key must never reach the provider query. `undefined` in a slot
-     * means the issue does not exist or is not visible to this token, never that the read failed.
-     */
-    getIssuesBatchResult(coordinates: readonly {
-        owner: string;
-        repo: string;
-        number: number;
-    }[], cancellation?: AbortSignal, connectionId?: string): Promise<IntegrationResult<(IssueShape | undefined)[] | undefined>>;
+  }, cancellation?: AbortSignal, connectionId?: string): Promise<IntegrationResult<ProviderPullRequestSearchPage | undefined>>;
+  /** Must agree with `ProviderMetadata.supportedPullRequestSearch`. */
+  protected searchProviderPullRequestsPage?(session: ProviderAuthenticationSession, options: {
+    repos?: ProviderRepoInput[];
+    org?: string;
+    criteria?: PullRequestSearchCriteria;
+    cursor?: string;
+    pageSize?: number;
+    /** See the caller's option of the same name on {@link searchPullRequestsPage}. */
+    summary?: boolean;
+  }, cancellation?: AbortSignal): Promise<ProviderPullRequestSearchPage | undefined>;
+  /** Free-text search across pull requests, optionally narrowed to `repos`. */
+  searchPullRequests(searchQuery: string, repos?: T | T[], cancellation?: AbortSignal, options?: SearchPullRequestsOptions & {
+    connectionId?: string;
+  }): Promise<PullRequest[] | undefined>;
+  protected searchProviderPullRequests?(session: ProviderAuthenticationSession, searchQuery: string, repos?: T[], cancellation?: AbortSignal, options?: SearchPullRequestsOptions): Promise<PullRequest[] | undefined>;
+  /**
+   * Result-returning wrapper for the FILTERED issue search — issues matching structured criteria over a
+   * repository/org scope, with no forced relationship to the current user. Recovers thrown errors into
+   * `{ error }` so the facade surfaces a warning instead of a silent empty page.
+   *
+   * Distinct from every other issue read on this class: {@link searchMyIssuesWithTruncationResult} is bound to
+   * the current user by construction, and {@link getMyIssuesForReposAsShapesResult} goes through the SDK's
+   * repo-scoped read (whose over-limit recovery walk can cost up to 128 requests). This one is one request per
+   * page and carries no relationship it wasn't asked for.
+   */
+  searchIssuesPageResult(options: {
     /**
-     * OPTIONAL: only a provider that can resolve SEVERAL issues by coordinate in one request implements this.
-     * GitHub aliases its point read into one document; the SDK exposes only a singular `getIssue` for every other
-     * provider, and there is no plural variant to build on. A provider that can't answer doesn't implement it and
-     * the facade refuses the read, so a caller keeps its own per-issue path rather than being handed a batch that
-     * silently degraded into N requests.
+     * Repositories to search, as namespace/name descriptors. NOT repository ids: a search query names
+     * repositories by path, so an id-based input can't be expressed and the facade rejects it before here.
      */
-    protected getProviderIssuesBatch?(session: ProviderAuthenticationSession, coordinates: readonly {
-        owner: string;
-        repo: string;
-        number: number;
-    }[], cancellation?: AbortSignal): Promise<(IssueShape | undefined)[] | undefined>;
-    /** The PR twin of {@link countIssuesResult}: counts each scope's pull requests, transferring none. */
-    countPullRequestsResult(scopes: readonly {
-        repos?: ProviderRepoInput[];
-        org?: string;
-        criteria?: PullRequestSearchCriteria;
-    }[], cancellation?: AbortSignal, connectionId?: string): Promise<IntegrationResult<(number | undefined)[] | undefined>>;
-    /** OPTIONAL, like {@link countProviderIssues}: only a provider that can count without fetching implements it. */
-    protected countProviderPullRequests?(session: ProviderAuthenticationSession, scopes: readonly {
-        repos?: ProviderRepoInput[];
-        org?: string;
-        criteria?: PullRequestSearchCriteria;
-    }[], cancellation?: AbortSignal): Promise<(number | undefined)[] | undefined>;
-    getPullRequestIdentityFromMaybeUrl(search: string): PullRequestUrlIdentity | undefined;
-    protected getProviderPullRequestIdentityFromMaybeUrl?(search: string): PullRequestUrlIdentity | undefined;
+    repos?: ProviderRepoInput[];
+    org?: string;
+    criteria?: IssueSearchCriteria;
+    cursor?: string;
+    pageSize?: number;
+  }, cancellation?: AbortSignal, connectionId?: string): Promise<IntegrationResult<ProviderIssueSearchPage | undefined>>;
+  /**
+   * OPTIONAL, like {@link searchProviderPullRequests}: a provider that can't express the criteria server-side
+   * doesn't implement it, and the facade refuses the read (warning + `fetchFailed`) rather than serving a list
+   * that was never narrowed. Whether a provider implements this must agree with what
+   * `ProviderMetadata.supportedIssueSearch` declares.
+   */
+  protected searchProviderIssuesPage?(session: ProviderAuthenticationSession, options: {
+    repos?: ProviderRepoInput[];
+    org?: string;
+    criteria?: IssueSearchCriteria;
+    cursor?: string;
+    pageSize?: number;
+  }, cancellation?: AbortSignal): Promise<ProviderIssueSearchPage | undefined>;
+  /**
+   * Result-returning wrapper for the count-only probe: how many issues MATCH each scope, transferring no issues
+   * at all. Recovers thrown errors into `{ error }` like the reads around it.
+   *
+   * Counts come back POSITIONALLY — one per input scope, in order — because a caller's key must never reach the
+   * provider query. `undefined` in a slot means the provider didn't report a count for it, never zero matches.
+   */
+  countIssuesResult(scopes: readonly {
+    repos?: ProviderRepoInput[];
+    org?: string;
+    criteria?: IssueSearchCriteria;
+  }[], cancellation?: AbortSignal, connectionId?: string): Promise<IntegrationResult<(number | undefined)[] | undefined>>;
+  /**
+   * OPTIONAL: only a provider that can answer "how many match" WITHOUT fetching the matches implements this.
+   * GitHub's search reports `issueCount` on a zero-node selection; GitLab's REST exposes a total on some
+   * endpoints but not for a search-shaped query, and Azure has no equivalent. A provider that can't answer
+   * doesn't implement it and the facade refuses the probe, so a consumer hides its count rather than being shown
+   * a fabricated one.
+   */
+  protected countProviderIssues?(session: ProviderAuthenticationSession, scopes: readonly {
+    repos?: ProviderRepoInput[];
+    org?: string;
+    criteria?: IssueSearchCriteria;
+  }[], cancellation?: AbortSignal): Promise<(number | undefined)[] | undefined>;
+  /**
+   * Result-returning wrapper for the BATCH issue read: resolves several `(owner, repo, number)` coordinates in
+   * one request. Recovers thrown errors into `{ error }` like the reads around it.
+   *
+   * Distinct from every search on this class, and deliberately so. A search answers "what matches"; this answers
+   * "does this exact issue exist", which is the question a caller correlating a branch name to an issue is
+   * actually asking. It has no result ceiling, no ordering and no cursor, and — the property that matters most —
+   * an absent slot is a PROVEN ABSENCE rather than "not found within a page budget", so a caller can cache a
+   * miss instead of re-walking for it forever.
+   *
+   * Results come back POSITIONALLY — one per input coordinate, in order — for the same reason
+   * {@link countIssuesResult} does: a caller's key must never reach the provider query. `undefined` in a slot
+   * means the issue does not exist or is not visible to this token, never that the read failed.
+   */
+  getIssuesBatchResult(coordinates: readonly {
+    owner: string;
+    repo: string;
+    number: number;
+  }[], cancellation?: AbortSignal, connectionId?: string): Promise<IntegrationResult<(IssueShape | undefined)[] | undefined>>;
+  /**
+   * OPTIONAL: only a provider that can resolve SEVERAL issues by coordinate in one request implements this.
+   * GitHub aliases its point read into one document; the SDK exposes only a singular `getIssue` for every other
+   * provider, and there is no plural variant to build on. A provider that can't answer doesn't implement it and
+   * the facade refuses the read, so a caller keeps its own per-issue path rather than being handed a batch that
+   * silently degraded into N requests.
+   */
+  protected getProviderIssuesBatch?(session: ProviderAuthenticationSession, coordinates: readonly {
+    owner: string;
+    repo: string;
+    number: number;
+  }[], cancellation?: AbortSignal): Promise<(IssueShape | undefined)[] | undefined>;
+  /** The PR twin of {@link countIssuesResult}: counts each scope's pull requests, transferring none. */
+  countPullRequestsResult(scopes: readonly {
+    repos?: ProviderRepoInput[];
+    org?: string;
+    criteria?: PullRequestSearchCriteria;
+  }[], cancellation?: AbortSignal, connectionId?: string): Promise<IntegrationResult<(number | undefined)[] | undefined>>;
+  /** OPTIONAL, like {@link countProviderIssues}: only a provider that can count without fetching implements it. */
+  protected countProviderPullRequests?(session: ProviderAuthenticationSession, scopes: readonly {
+    repos?: ProviderRepoInput[];
+    org?: string;
+    criteria?: PullRequestSearchCriteria;
+  }[], cancellation?: AbortSignal): Promise<(number | undefined)[] | undefined>;
+  getPullRequestIdentityFromMaybeUrl(search: string): PullRequestUrlIdentity | undefined;
+  protected getProviderPullRequestIdentityFromMaybeUrl?(search: string): PullRequestUrlIdentity | undefined;
 }
-export {};
+//#endregion
 //# sourceMappingURL=gitHostIntegration.d.ts.map