@gitkraken/core-gitlens 0.6.0 → 0.7.1

package/dist/plus/integrations/integrationService.d.ts

@@ -1,477 +1,516 @@
-import type { Account } from '../../git/models/author.js';
-import type { IssueSearchCriteria, IssueShape } from '../../git/models/issue.js';
-import type { PullRequest, PullRequestSearchCriteria, PullRequestShape, PullRequestStateFilter } from '../../git/models/pullRequest.js';
-import type { GitRemote } from '../../git/models/remote.js';
-import type { RemoteProviderId } from '../../git/models/remoteProvider.js';
-import type { Disposable } from '../../utils/disposable.js';
-import type { Event } from '../../utils/event.js';
-import type { ConfiguredIntegrationsChangeEvent } from './authentication/configuredIntegrationService.js';
-import { ConfiguredIntegrationService } from './authentication/configuredIntegrationService.js';
-import { IntegrationAuthenticationService } from './authentication/integrationAuthenticationService.js';
-import type { ConfiguredIntegrationDescriptor } from './authentication/models.js';
-import type { CloudGitSelfManagedHostIntegrationIds, IntegrationIds, SupportedCloudIntegrationIds } from './constants.js';
-import { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId, IssuesCloudHostIntegrationId } from './constants.js';
-import type { IntegrationServiceContext, IntegrationsRemoteConfig } from './context.js';
-import type { ClosedPullRequestSweepOptions, ListOrgsOptions, ListProjectsOptions, ProviderBroadenOrg, PullRequestSweepOptions } from './manager.js';
-import type { GitHostIntegration, SearchMyPullRequestsOptions } from './models/gitHostIntegration.js';
-import type { Integration, IntegrationBase, IntegrationById, IntegrationResult } from './models/integration.js';
-import type { IssuesIntegration } from './models/issuesIntegration.js';
-import type { ApiClients } from './providers/apiClients.js';
-import type { GitHubApi } from './providers/github/github.js';
-import type { IssueFilter, IssueSorting, ProviderOrganization, ProviderReposInput, ProviderRepositoryShape, PullRequestFilter } from './providers/models.js';
-import type { RepositoryResolutionContext } from './reads/context.js';
-import type { IssueCountResult, IssueCountScope, PullRequestCountResult, PullRequestCountScope } from './reads/counts.js';
-import type { SupportedFilters } from './reads/filters.js';
-import type { IssueBatchResult, IssueBatchTarget } from './reads/issueBatch.js';
-import type { TrackerIssueResult } from './reads/trackerIssue.js';
-import type { ConnectionStateChangeEvent, ProviderBroadenResult, ProviderPagedResult, ProviderResult, ProviderSweepResult, ProviderWarning, ResolveRepositoryResult } from './results.js';
-import type { Source } from './telemetry.js';
+import { Disposable } from "../../utils/disposable.js";
+import { Event } from "../../utils/event.js";
+import { RemoteProviderId } from "../../git/models/remoteProvider.js";
+import { GitRemote } from "../../git/models/remote.js";
+import { IssueSearchCriteria, IssueShape, IssueSorting } from "../../git/models/issue.js";
+import { PullRequest, PullRequestFilter, PullRequestSearchCriteria, PullRequestShape, PullRequestStateFilter } from "../../git/models/pullRequest.js";
+import { Account } from "../../git/models/author.js";
+import { GitHubApi } from "../git-github/api/github.js";
+import { ConfiguredIntegrationDescriptor } from "./authentication/models.js";
+import { CloudGitSelfManagedHostIntegrationIds, GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId, IntegrationIds, IssuesCloudHostIntegrationId, SupportedCloudIntegrationIds } from "./constants.js";
+import { Source } from "./telemetry.js";
+import { ConfiguredIntegrationService, ConfiguredIntegrationsChangeEvent } from "./authentication/configuredIntegrationService.js";
+import { IssueFilter } from "./providerFilters.js";
+import { GitHostIntegration, SearchMyPullRequestsOptions } from "./models/gitHostIntegration.js";
+import { IssuesIntegration } from "./models/issuesIntegration.js";
+import { Integration, IntegrationBase, IntegrationById, IntegrationResult } from "./models/integration.js";
+import { ConnectionStateChangeEvent, ProviderBroadenResult, ProviderOrganization, ProviderPagedResult, ProviderRepositoryShape, ProviderResult, ProviderSweepResult, ProviderWarning, ResolveRepositoryResult } from "./results.js";
+import { ProviderReposInput } from "./providers/models.js";
+import { RepositoryResolutionContext } from "./reads/context.js";
+import { IssueCountResult, IssueCountScope, PullRequestCountResult, PullRequestCountScope } from "./reads/counts.js";
+import { SupportedFilters } from "./reads/filters.js";
+import { IssueBatchResult, IssueBatchTarget } from "./reads/issueBatch.js";
+import { TrackerIssueResult } from "./reads/trackerIssue.js";
+import { ClosedPullRequestSweepOptions, ListOrgsOptions, ListProjectsOptions, ProviderBroadenOrg, PullRequestSweepOptions } from "./manager.js";
+import "./providers/github/github.js";
+import { ApiClients } from "./providers/apiClients.js";
+import { IntegrationAuthenticationService } from "./authentication/integrationAuthenticationService.js";
+import { IntegrationServiceContext, IntegrationsRemoteConfig } from "./context.js";
+//#region ../plus/integrations/src/integrationService.d.ts
 /** @internal Event emitted when an integration connection state changes  */
 export interface IntegrationConnectionChangeEvent extends ConnectionStateChangeEvent {
-    integration: IntegrationBase;
+  integration: IntegrationBase;
 }
 export declare class IntegrationService implements Disposable, RepositoryResolutionContext {
-    private readonly authenticationService;
-    private readonly configuredIntegrationService;
-    private readonly ctx;
-    get onDidChange(): Event<ConfiguredIntegrationsChangeEvent>;
-    private readonly _onDidChangeConnectionState;
-    get onDidChangeConnectionState(): Event<ConnectionStateChangeEvent>;
-    private readonly _connectedCache;
-    private readonly _disposable;
-    private _integrations;
-    private readonly _onDidChangeIntegrationConnection;
-    private readonly _apiDisposables;
-    private _apis;
-    /** The package-built, memoized per-provider API clients (was injected via the now-removed `ctx.apis`). */
-    get apis(): ApiClients;
-    /** The shared `GitHubApi` instance — also consumed by the host's GitHub git provider (one instance). */
-    get github(): Promise<GitHubApi | undefined>;
-    constructor(authenticationService: IntegrationAuthenticationService, configuredIntegrationService: ConfiguredIntegrationService, ctx: IntegrationServiceContext);
-    dispose(): void;
-    connectCloudIntegrations(connect?: {
-        integrationIds: SupportedCloudIntegrationIds[];
-        skipIfConnected?: boolean;
-        skipPreSync?: boolean;
-    }, source?: Source): Promise<boolean>;
+  private readonly authenticationService;
+  private readonly configuredIntegrationService;
+  private readonly ctx;
+  get onDidChange(): Event<ConfiguredIntegrationsChangeEvent>;
+  private readonly _onDidChangeConnectionState;
+  get onDidChangeConnectionState(): Event<ConnectionStateChangeEvent>;
+  private readonly _connectedCache;
+  private readonly _disposable;
+  private _integrations;
+  private readonly _onDidChangeIntegrationConnection;
+  private readonly _apiDisposables;
+  private _apis;
+  /** The package-built, memoized per-provider API clients (was injected via the now-removed `ctx.apis`). */
+  get apis(): ApiClients;
+  /** The shared `GitHubApi` instance — also consumed by the host's GitHub git provider (one instance). */
+  get github(): Promise<GitHubApi | undefined>;
+  constructor(authenticationService: IntegrationAuthenticationService, configuredIntegrationService: ConfiguredIntegrationService, ctx: IntegrationServiceContext);
+  dispose(): void;
+  connectCloudIntegrations(connect?: {
+    integrationIds: SupportedCloudIntegrationIds[];
+    skipIfConnected?: boolean;
+    skipPreSync?: boolean;
+  }, source?: Source): Promise<boolean>;
+  /**
+   * Starts the cloud connect flow without skipping an already-connected provider, allowing the host/GK Dev
+   * flow to add another account for that provider instead of treating the existing primary as sufficient.
+   * Returns whether a new connection was actually added (measured by a new cloud connection id appearing),
+   * since {@link connectCloudIntegrations} only reports provider-level success and can't detect a newly added
+   * secondary for an already-connected provider.
+   */
+  connectSecondary(id: SupportedCloudIntegrationIds, source?: Source): Promise<boolean>;
+  get(id: GitCloudHostIntegrationId): Promise<GitHostIntegration>;
+  get(id: IssuesCloudHostIntegrationId): Promise<IssuesIntegration>;
+  get(id: GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds, domain?: string): Promise<GitHostIntegration | undefined>;
+  get(id: GitSelfManagedHostIntegrationId, domain: string): Promise<GitHostIntegration | undefined>;
+  get<T extends IntegrationIds>(id: T, domain?: string): Promise<IntegrationById<T> | undefined>;
+  getConfigured(id?: IntegrationIds, options?: {
+    cloud?: boolean;
+    domain?: string;
+  }): ConfiguredIntegrationDescriptor[];
+  /**
+   * The filters this provider's reads accept — part of the public {@link IntegrationManager} contract, so it
+   * stays a method here even though it needs no instance state; see {@link getSupportedFilters} for the
+   * capability table itself and why a consumer should intersect against it before reading.
+   */
+  getSupportedFilters(providerId: IntegrationIds): SupportedFilters;
+  /**
+   * Returns the connected integration for a `GitRemote`, if any.
+   * Internal counterpart to the host's `getRemoteIntegration(remote)` helper.
+   */
+  getByRemote(remote: GitRemote): Promise<GitHostIntegration | undefined>;
+  getMyIssues(integrationIds?: IntegrationIds[], options?: {
+    openRepositoriesOnly?: boolean;
+    cancellation?: AbortSignal;
+  }): Promise<IntegrationResult<IssueShape[] | undefined>>;
+  private getMyIssuesCore;
+  getMyIssuesForRemotes(remote: GitRemote): Promise<IntegrationResult<IssueShape[] | undefined>>;
+  getMyIssuesForRemotes(remotes: GitRemote[]): Promise<IntegrationResult<IssueShape[] | undefined>>;
+  getMyCurrentAccounts(integrationIds: (GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds)[], connectionId?: string): Promise<Map<GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds, Account>>;
+  getMyPullRequests(integrationIds?: (GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds)[], cancellation?: AbortSignal, options?: SearchMyPullRequestsOptions): Promise<IntegrationResult<PullRequest[] | undefined>>;
+  private getMyPullRequestsCore;
+  getMyPullRequestsForRemotes(remote: GitRemote): Promise<IntegrationResult<PullRequest[] | undefined>>;
+  getMyPullRequestsForRemotes(remotes: GitRemote[]): Promise<IntegrationResult<PullRequest[] | undefined>>;
+  /**
+   * Warnings for an early-returning read where the integration couldn't be resolved. When a specific
+   * `connectionId` or self-managed `domain` was requested, a missing integration means that target is
+   * unavailable — surface a `no-connection` warning + `fetchFailed` so the caller can tell it apart from
+   * a truly empty account. Without an explicit target, it's simply not connected, which stays a silent
+   * empty result.
+   */
+  earlyReturnConnectionWarnings(id: IntegrationIds, connectionId: string | undefined, domain?: string): {
+    warnings: ProviderWarning[];
+    fetchFailed: boolean;
+  };
+  private isEmptyExplicitSelector;
+  domainForRead(integration: Integration, id: IntegrationIds, connectionId: string | undefined, domain?: string): string | undefined;
+  /**
+   * Resolves the right integration instance for a read. A configured connection domain takes precedence over
+   * an explicit fallback domain; the latter lets external/manual authentication providers address a
+   * self-managed host without persisting `ConfiguredIntegrationService` state.
+   */
+  getIntegrationForRead(id: IntegrationIds, connectionId: string | undefined, domain?: string): Promise<Integration | undefined>;
+  /**
+   * Resolves every integration instance an account-wide read must cover for `id`. A cloud id has one instance;
+   * a self-managed id has one per configured host, so the read fans out over all of them rather than `get(id)`
+   * silently picking whichever host was cached (or flagged primary) first, which dropped every other GitHub
+   * Enterprise server, GitLab instance, Bitbucket Data Center, Azure DevOps Server or Jira Data Center the user
+   * is connected to (#5873).
+   *
+   * Hosts come from every configured connection, local as well as cloud: that is the set `get(id)` already picked
+   * its primary from, and a locally configured host is as much the user's as a cloud-synced one. This is where it
+   * departs from {@link getSupportedCloudIntegrations}, which only walks cloud connections because it exists to
+   * sync them. The two share the per-host resolution and the fallback to whatever instance is already cached when
+   * no host is configured. A lookup that throws counts as "not available", like {@link getIntegrationForRead}.
+   */
+  getIntegrationsForAccountWideRead<T extends IntegrationIds>(id: T): Promise<IntegrationById<T>[]>;
+  isConnectedForAccountWideRead(id: IntegrationIds, options?: {
+    access?: boolean;
+  }): Promise<boolean>;
+  /**
+   * The open repositories to scope `integration`'s read to, out of the remotes open for its integration id.
+   *
+   * With a single host for the id (every cloud id, and a self-managed id with one configured host) every remote
+   * is that host's, as it was before the read fanned out, so a remote addressed through an SSH alias or a custom
+   * domain keeps its repositories scoped. With several hosts a remote belongs to the one configured host it
+   * names, compared the way {@link resolveRepository} compares them: exactly for a web remote, by hostname for an
+   * SSH/git one, whose parsed domain has lost any port. A remote naming no host, or several (two ports on one
+   * machine), is credited to none, like `resolveRepository`'s `host-mismatch`: asking one server about another
+   * server's `owner/name` reads a different repository, or nothing, under the right name.
+   */
+  private getOpenRemotesForHost;
+  resolveDomainForRead(id: IntegrationIds, connectionId: string | undefined, domain: string | undefined): string | undefined;
+  /** The primary configured host for a self-managed provider (first configured when none is flagged primary). */
+  private primaryConfiguredDomain;
+  /**
+   * Forces a real session refresh before a read when `forceSync` is set, so the read consumes a freshly
+   * exchanged token rather than a possibly-stale cached one. Both paths refresh, by different mechanisms: a
+   * per-connection (`connectionId`) read syncs that specific connection's session directly through the auth
+   * provider (the integration's primary-only sync path would never reach a secondary account), while a
+   * primary read syncs via the integration's own cloud-connection machinery.
+   * Best-effort — a failed sync is swallowed so the read still proceeds (and surfaces its own warning).
+   */
+  forceRefreshIfRequested(integration: Integration, forceSync: boolean | undefined, connectionId: string | undefined): Promise<void>;
+  /**
+   * Lists the orgs/workspaces/groups (and issue-tracker resources) visible to the user, unified into
+   * {@link ProviderOrganization}. Scoped to `providerId` when given, otherwise fanned out over every
+   * supported provider. `connectionId` only makes sense with a single `providerId`.
+   */
+  listOrgs(options?: ListOrgsOptions): Promise<ProviderResult<ProviderOrganization>>;
+  /**
+   * Lists the projects visible to the user, unified into the {@link ProviderOrganization}
+   * `{ providerId, id, name, org?, url }` shape. Covers issue-tracker providers (Jira/Linear, which expose
+   * projects under their resources) *and* git hosts that have a project tier (Azure DevOps, whose repos are
+   * org + project scoped). Scoped to `providerId` when given, else fanned out over both the supported issue
+   * trackers and Azure DevOps. Providers with no project tier (GitHub, GitLab, Bitbucket) contribute nothing.
+   */
+  listProjects(options?: ListProjectsOptions): Promise<ProviderResult<ProviderOrganization>>;
+  /**
+   * Lists repositories under an org for a git-host provider, one page at a time. Pass `page` (1-based)
+   * to advance; the returned `cursor` is only meaningful for cursor-only hosts.
+   */
+  listRepos(options: {
+    providerId: IntegrationIds;
     /**
-     * Starts the cloud connect flow without skipping an already-connected provider, allowing the host/GK Dev
-     * flow to add another account for that provider instead of treating the existing primary as sufficient.
-     * Returns whether a new connection was actually added (measured by a new cloud connection id appearing),
-     * since {@link connectCloudIntegrations} only reports provider-level success and can't detect a newly added
-     * secondary for an already-connected provider.
+     * Org/workspace/group to scope to. Omitted = the account-wide, user-affiliated walk (the org-less
+     * `gk provider repos <provider>` equivalent) for hosts with a native user-repos read (GitHub, GitLab);
+     * hosts without one (Bitbucket, Azure DevOps) report the org-less read as unsupported so the caller
+     * fans out per org instead.
      */
-    connectSecondary(id: SupportedCloudIntegrationIds, source?: Source): Promise<boolean>;
-    get(id: GitCloudHostIntegrationId): Promise<GitHostIntegration>;
-    get(id: IssuesCloudHostIntegrationId): Promise<IssuesIntegration>;
-    get(id: GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds, domain?: string): Promise<GitHostIntegration | undefined>;
-    get(id: GitSelfManagedHostIntegrationId, domain: string): Promise<GitHostIntegration | undefined>;
-    get<T extends IntegrationIds>(id: T, domain?: string): Promise<IntegrationById<T> | undefined>;
-    getConfigured(id?: IntegrationIds, options?: {
-        cloud?: boolean;
-        domain?: string;
-    }): ConfiguredIntegrationDescriptor[];
+    org?: string;
+    project?: string;
+    page?: number;
+    cursor?: string;
+    itemsPerPage?: number;
+    connectionId?: string;
     /**
-     * The filters this provider's reads accept — part of the public {@link IntegrationManager} contract, so it
-     * stays a method here even though it needs no instance state; see {@link getSupportedFilters} for the
-     * capability table itself and why a consumer should intersect against it before reading.
+     * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
+     * it must come from the trusted authentication configuration, not repository or remote data.
      */
-    getSupportedFilters(providerId: IntegrationIds): SupportedFilters;
+    domain?: string;
+  }): Promise<ProviderPagedResult<ProviderRepositoryShape>>;
+  /**
+   * Reads one page of the user's pull requests for the given git-host provider. With `repos`, reads those
+   * repos' PRs (translating `page` ↔ the provider's opaque cursor) and maps the raw provider PRs to
+   * {@link PullRequestShape}. With no `repos`, reads the current user's PRs account-wide — the
+   * repo-scoped core rejects an empty `repos` input for GitHub/Bitbucket/Azure, so route to the
+   * account-wide `searchMyPullRequests` core instead (which is already user-scoped and returns shapes).
+   */
+  listPullRequestsPage(options: {
+    providerId: IntegrationIds;
+    repos?: ProviderReposInput;
+    states?: PullRequestStateFilter[];
     /**
-     * Returns the connected integration for a `GitRemote`, if any.
-     * Internal counterpart to the host's `getRemoteIntegration(remote)` helper.
+     * PR relationship filters (e.g. `[Author, Assignee, ReviewRequested]`). On repo-scoped reads members
+     * combine as provider query constraints (normally an intersection); on account-wide reads they form an
+     * exact OR union. The whole set is validated against the selected path's capability.
      */
-    getByRemote(remote: GitRemote): Promise<GitHostIntegration | undefined>;
-    getMyIssues(integrationIds?: (GitCloudHostIntegrationId | IssuesCloudHostIntegrationId | GitSelfManagedHostIntegrationId)[], options?: {
-        openRepositoriesOnly?: boolean;
-        cancellation?: AbortSignal;
-    }): Promise<IntegrationResult<IssueShape[] | undefined>>;
-    private getMyIssuesCore;
-    getMyIssuesForRemotes(remote: GitRemote): Promise<IntegrationResult<IssueShape[] | undefined>>;
-    getMyIssuesForRemotes(remotes: GitRemote[]): Promise<IntegrationResult<IssueShape[] | undefined>>;
-    getMyCurrentAccounts(integrationIds: (GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds)[], connectionId?: string): Promise<Map<GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds, Account>>;
-    getMyPullRequests(integrationIds?: (GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds)[], cancellation?: AbortSignal, options?: SearchMyPullRequestsOptions): Promise<IntegrationResult<PullRequest[] | undefined>>;
-    private getMyPullRequestsCore;
-    getMyPullRequestsForRemotes(remote: GitRemote): Promise<IntegrationResult<PullRequest[] | undefined>>;
-    getMyPullRequestsForRemotes(remotes: GitRemote[]): Promise<IntegrationResult<PullRequest[] | undefined>>;
+    filters?: PullRequestFilter[];
     /**
-     * Warnings for an early-returning read where the integration couldn't be resolved. When a specific
-     * `connectionId` or self-managed `domain` was requested, a missing integration means that target is
-     * unavailable — surface a `no-connection` warning + `fetchFailed` so the caller can tell it apart from
-     * a truly empty account. Without an explicit target, it's simply not connected, which stays a silent
-     * empty result.
+     * Account-wide only: include review-requested PRs when the provider's native "my PRs" query omits them.
+     * This extends the provider-native result; it is not a narrowing filter.
      */
-    earlyReturnConnectionWarnings(id: IntegrationIds, connectionId: string | undefined, domain?: string): {
-        warnings: ProviderWarning[];
-        fetchFailed: boolean;
-    };
-    private isEmptyExplicitSelector;
-    domainForRead(integration: Integration, id: IntegrationIds, connectionId: string | undefined, domain?: string): string | undefined;
+    includeReviewRequested?: boolean;
+    page?: number;
+    cursor?: string;
+    itemsPerPage?: number;
+    forceSync?: boolean;
+    connectionId?: string;
     /**
-     * Resolves the right integration instance for a read. A configured connection domain takes precedence over
-     * an explicit fallback domain; the latter lets external/manual authentication providers address a
-     * self-managed host without persisting `ConfiguredIntegrationService` state.
+     * Explicit self-managed host domain when no configured connection supplies one. The value must come
+     * from the trusted authentication configuration, not repository or remote data.
      */
-    getIntegrationForRead(id: IntegrationIds, connectionId: string | undefined, domain?: string): Promise<Integration | undefined>;
-    resolveDomainForRead(id: IntegrationIds, connectionId: string | undefined, domain: string | undefined): string | undefined;
-    /** The primary configured host for a self-managed provider (first configured when none is flagged primary). */
-    private primaryConfiguredDomain;
-    /**
-     * Forces a real session refresh before a read when `forceSync` is set, so the read consumes a freshly
-     * exchanged token rather than a possibly-stale cached one. Both paths refresh, by different mechanisms: a
-     * per-connection (`connectionId`) read syncs that specific connection's session directly through the auth
-     * provider (the integration's primary-only sync path would never reach a secondary account), while a
-     * primary read syncs via the integration's own cloud-connection machinery.
-     * Best-effort — a failed sync is swallowed so the read still proceeds (and surfaces its own warning).
-     */
-    forceRefreshIfRequested(integration: Integration, forceSync: boolean | undefined, connectionId: string | undefined): Promise<void>;
-    /**
-     * Lists the orgs/workspaces/groups (and issue-tracker resources) visible to the user, unified into
-     * {@link ProviderOrganization}. Scoped to `providerId` when given, otherwise fanned out over every
-     * supported provider. `connectionId` only makes sense with a single `providerId`.
-     */
-    listOrgs(options?: ListOrgsOptions): Promise<ProviderResult<ProviderOrganization>>;
-    /**
-     * Lists the projects visible to the user, unified into the {@link ProviderOrganization}
-     * `{ providerId, id, name, org?, url }` shape. Covers issue-tracker providers (Jira/Linear, which expose
-     * projects under their resources) *and* git hosts that have a project tier (Azure DevOps, whose repos are
-     * org + project scoped). Scoped to `providerId` when given, else fanned out over both the supported issue
-     * trackers and Azure DevOps. Providers with no project tier (GitHub, GitLab, Bitbucket) contribute nothing.
-     */
-    listProjects(options?: ListProjectsOptions): Promise<ProviderResult<ProviderOrganization>>;
-    /**
-     * Lists repositories under an org for a git-host provider, one page at a time. Pass `page` (1-based)
-     * to advance; the returned `cursor` is only meaningful for cursor-only hosts.
-     */
-    listRepos(options: {
-        providerId: IntegrationIds;
-        /**
-         * Org/workspace/group to scope to. Omitted = the account-wide, user-affiliated walk (the org-less
-         * `gk provider repos <provider>` equivalent) for hosts with a native user-repos read (GitHub, GitLab);
-         * hosts without one (Bitbucket, Azure DevOps) report the org-less read as unsupported so the caller
-         * fans out per org instead.
-         */
-        org?: string;
-        project?: string;
-        page?: number;
-        cursor?: string;
-        itemsPerPage?: number;
-        connectionId?: string;
-        /**
-         * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
-         * it must come from the trusted authentication configuration, not repository or remote data.
-         */
-        domain?: string;
-    }): Promise<ProviderPagedResult<ProviderRepositoryShape>>;
-    /**
-     * Reads one page of the user's pull requests for the given git-host provider. With `repos`, reads those
-     * repos' PRs (translating `page` ↔ the provider's opaque cursor) and maps the raw provider PRs to
-     * {@link PullRequestShape}. With no `repos`, reads the current user's PRs account-wide — the
-     * repo-scoped core rejects an empty `repos` input for GitHub/Bitbucket/Azure, so route to the
-     * account-wide `searchMyPullRequests` core instead (which is already user-scoped and returns shapes).
-     */
-    listPullRequestsPage(options: {
-        providerId: IntegrationIds;
-        repos?: ProviderReposInput;
-        states?: PullRequestStateFilter[];
-        /**
-         * PR relationship filters (e.g. `[Author, Assignee, ReviewRequested]`). On repo-scoped reads members
-         * combine as provider query constraints (normally an intersection); on account-wide reads they form an
-         * exact OR union. The whole set is validated against the selected path's capability.
-         */
-        filters?: PullRequestFilter[];
-        /**
-         * Account-wide only: include review-requested PRs when the provider's native "my PRs" query omits them.
-         * This extends the provider-native result; it is not a narrowing filter.
-         */
-        includeReviewRequested?: boolean;
-        page?: number;
-        cursor?: string;
-        itemsPerPage?: number;
-        forceSync?: boolean;
-        connectionId?: string;
-        /**
-         * Explicit self-managed host domain when no configured connection supplies one. The value must come
-         * from the trusted authentication configuration, not repository or remote data.
-         */
-        domain?: string;
-        /** See {@link IntegrationManager.listPullRequestsPage}. */
-        summary?: boolean;
-    }): Promise<ProviderPagedResult<PullRequestShape>>;
+    domain?: string;
+    /** See {@link IntegrationManager.listPullRequestsPage}. */
+    summary?: boolean;
+  }): Promise<ProviderPagedResult<PullRequestShape>>;
+  /** See {@link IntegrationManager.searchPullRequestsPage}. */
+  searchPullRequestsPage(options: {
+    providerId: IntegrationIds;
+    repos?: ProviderReposInput;
+    org?: string;
+    criteria?: PullRequestSearchCriteria;
+    page?: number;
+    cursor?: string;
+    itemsPerPage?: number;
+    forceSync?: boolean;
+    connectionId?: string;
+    domain?: string;
     /** See {@link IntegrationManager.searchPullRequestsPage}. */
-    searchPullRequestsPage(options: {
-        providerId: IntegrationIds;
-        repos?: ProviderReposInput;
-        org?: string;
-        criteria?: PullRequestSearchCriteria;
-        page?: number;
-        cursor?: string;
-        itemsPerPage?: number;
-        forceSync?: boolean;
-        connectionId?: string;
-        domain?: string;
-        /** See {@link IntegrationManager.searchPullRequestsPage}. */
-        summary?: boolean;
-    }): Promise<ProviderPagedResult<PullRequestShape>>;
-    listIssuesPage(options: {
-        providerId: IntegrationIds;
-        repos?: ProviderReposInput;
-        /** Narrows the account-wide read to one org/account. Requires a host with a project layer (Azure). */
-        org?: string;
-        /** Narrows the account-wide read to one project. Requires a host with a project layer (Azure). */
-        project?: string;
-        /**
-         * Narrows to the requested relationship(s). On the account-wide path this replaces the provider's own
-         * definition of "my issues" (GitHub/GHE: authored ∪ assigned ∪ mentioned; Azure: assigned ∪ authored;
-         * GitLab: assigned-to-me), so `[Assignee]` yields `assignee:@me` everywhere it's expressible. A set the
-         * provider can't express server-side is refused whole (warning + `fetchFailed`), never widened — check
-         * {@link IntegrationService.getSupportedFilters} first to avoid that path.
-         */
-        filters?: IssueFilter[];
-        /** Broadens the read to every assignee. Contradicts `filters`; passing both is refused. */
-        includeAllAssignees?: boolean;
-        /**
-         * How to order the page, as `field:direction`. Omitted orders most-recently-updated-first wherever the
-         * provider can express it. Validated against `getSupportedFilters().issueSorts` on the repo-scoped path and
-         * `.issueSortsAccountWide` on the account-wide one, and refused rather than downgraded; a key no normalized
-         * issue carries is additionally refused for a page spanning several repositories/projects, which is a merge.
-         */
-        sort?: IssueSorting;
-        page?: number;
-        cursor?: string;
-        itemsPerPage?: number;
-        forceSync?: boolean;
-        connectionId?: string;
-        /**
-         * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
-         * it must come from the trusted authentication configuration, not repository or remote data.
-         */
-        domain?: string;
-    }): Promise<ProviderPagedResult<IssueShape>>;
-    /**
-     * Issues matching structured criteria over a repository/org scope, with no forced relationship to the current
-     * user — see {@link IntegrationManager.searchIssuesPage} for the contract (mandatory scope, guaranteed
-     * most-recently-updated-first ordering, and the result-ceiling omission that carries the total match count).
-     */
-    searchIssuesPage(options: {
-        providerId: IntegrationIds;
-        repos?: ProviderReposInput;
-        org?: string;
-        criteria?: IssueSearchCriteria;
-        page?: number;
-        cursor?: string;
-        itemsPerPage?: number;
-        forceSync?: boolean;
-        connectionId?: string;
-        /**
-         * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
-         * it must come from the trusted authentication configuration, not repository or remote data.
-         */
-        domain?: string;
-    }): Promise<ProviderPagedResult<IssueShape>>;
-    /**
-     * How many issues match each scope, without fetching any — see {@link IntegrationManager.countIssues} for the
-     * cost model, the per-scope isolation rules, and why `count: undefined` must not be rendered as zero.
-     */
-    countIssues(options: {
-        providerId: IntegrationIds;
-        scopes: readonly IssueCountScope[];
-        connectionId?: string;
-        /**
-         * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
-         * it must come from the trusted authentication configuration, not repository or remote data.
-         */
-        domain?: string;
-    }): Promise<ProviderResult<IssueCountResult>>;
-    getIssuesBatch(options: {
-        providerId: IntegrationIds;
-        targets: readonly IssueBatchTarget[];
-        connectionId?: string;
-        /**
-         * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
-         * it must come from the trusted authentication configuration, not repository or remote data.
-         */
-        domain?: string;
-    }): Promise<ProviderResult<IssueBatchResult>>;
-    getTrackerIssue(options: {
-        providerId: IntegrationIds;
-        resourceId: string;
-        resourceUrl?: string;
-        key: string;
-        connectionId?: string;
-    }): Promise<ProviderResult<TrackerIssueResult>>;
-    /**
-     * How many pull requests match each scope, without fetching any — the PR twin of {@link countIssues}. See
-     * {@link IntegrationManager.countPullRequests} for the cost model, the per-scope isolation rules, and why
-     * `count: undefined` must not be rendered as zero.
-     */
-    countPullRequests(options: {
-        providerId: IntegrationIds;
-        scopes: readonly PullRequestCountScope[];
-        connectionId?: string;
-        /**
-         * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
-         * it must come from the trusted authentication configuration, not repository or remote data.
-         */
-        domain?: string;
-    }): Promise<ProviderResult<PullRequestCountResult>>;
-    /**
-     * Reads the user's issues from an issue-tracker provider (Jira/Linear/Trello), whose issues live under
-     * resource → project (not repos), so they can't go through {@link listIssuesPage} (git-host, repo-scoped).
-     * Returns the normalized {@link IssueShape} these providers produce, aggregated across the projects of the
-     * given `org` (or every visible resource/project when omitted). `includeAllAssignees` drops the
-     * "assigned to me" scoping so unassigned issues are included. Best-effort: a per-step failure becomes a
-     * warning without failing the whole read.
-     *
-     * Paginated by project: these providers have no single cross-project issue cursor, so a page is a bounded
-     * window of projects (each drained by its own read). Pagination is opt-in — a caller that supplies none of
-     * `page`/`cursor`/`itemsPerPage` reads every matched project in one page (`hasMore: false`), preserving the
-     * "aggregate everything" contract for callers that don't page. When any of those is supplied, the read is
-     * windowed to `itemsPerPage` projects (default 20) advanced 1-based via `page`/`cursor`, with `hasMore`/
-     * `cursor` carrying the next window. Note: a project's own read has an internal page backstop (see the
-     * per-provider drains); if a single project exceeds it, its extra issues can't be paged from here, but that
-     * incompleteness IS surfaced as `page.truncated` (Jira/Linear report the backstop hit) rather than passed
-     * off as a complete read.
-     *
-     * Takes no `domain`, unlike the git-host reads: every issue-tracker provider is cloud-only
-     * ({@link IssuesCloudHostIntegrationId}), so there is no self-managed host to address.
-     */
-    listIssueTrackerIssuesPage(options: {
-        providerId: IntegrationIds;
-        org?: string;
-        project?: string;
-        filters?: IssueFilter[];
-        includeAllAssignees?: boolean;
-        /**
-         * How to order the issues, as `field:direction`. Validated against `getSupportedFilters().issueSorts`, which
-         * is where a tracker reports; a key no normalized issue carries is refused for a multi-project page.
-         */
-        sort?: IssueSorting;
-        forceSync?: boolean;
-        page?: number;
-        cursor?: string;
-        itemsPerPage?: number;
-        connectionId?: string;
-    }): Promise<ProviderPagedResult<IssueShape>>;
+    summary?: boolean;
+  }): Promise<ProviderPagedResult<PullRequestShape>>;
+  listIssuesPage(options: {
+    providerId: IntegrationIds;
+    repos?: ProviderReposInput;
+    /** Narrows the account-wide read to one org/account. Requires a host with a project layer (Azure). */
+    org?: string;
+    /** Narrows the account-wide read to one project. Requires a host with a project layer (Azure). */
+    project?: string;
     /**
-     * Sweeps the user's pull requests across providers by draining every page (an "all-pages" read),
-     * returning the neutral sweep result with per-provider warnings. `truncated` is set when a provider
-     * hit `maxPages` with more still available; `fetchFailed` when a drain aborted on a read error.
-     * `targets` selects a connection/domain independently for each provider. The legacy `connectionId` is
-     * honored only when `providerIds` resolves to a single provider (otherwise ambiguous).
+     * Narrows to the requested relationship(s). On the account-wide path this replaces the provider's own
+     * definition of "my issues" (GitHub/GHE: authored ∪ assigned ∪ mentioned; Azure: assigned ∪ authored;
+     * GitLab: assigned-to-me), so `[Assignee]` yields `assignee:@me` everywhere it's expressible. A set the
+     * provider can't express server-side is refused whole (warning + `fetchFailed`), never widened — check
+     * {@link IntegrationService.getSupportedFilters} first to avoid that path.
      */
-    sweepPullRequests(options?: PullRequestSweepOptions): Promise<ProviderSweepResult<PullRequestShape>>;
+    filters?: IssueFilter[];
+    /** Broadens the read to every assignee. Contradicts `filters`; passing both is refused. */
+    includeAllAssignees?: boolean;
     /**
-     * Closed/merged counterpart of {@link sweepPullRequests}, feeding Kepler's Kanban "done" column. Applies
-     * the native cross-provider state filter (`Closed` + `Merged`) so it works beyond GitHub.
+     * How to order the page, as `field:direction`. Omitted orders most-recently-updated-first wherever the
+     * provider can express it. Validated against `getSupportedFilters().issueSorts` on the repo-scoped path and
+     * `.issueSortsAccountWide` on the account-wide one, and refused rather than downgraded; a key no normalized
+     * issue carries is additionally refused for a page spanning several repositories/projects, which is a merge.
      */
-    sweepClosedPullRequests(options?: ClosedPullRequestSweepOptions): Promise<ProviderSweepResult<PullRequestShape>>;
+    sort?: IssueSorting;
+    page?: number;
+    cursor?: string;
+    itemsPerPage?: number;
+    forceSync?: boolean;
+    connectionId?: string;
     /**
-     * Broadens the user's issues by fanning out over the supplied orgs: for each org it lists the org's
-     * repositories, then reads that org's issues. A per-org failure becomes a warning without failing the
-     * whole fan-out. `broadenedProviderIds` lists the distinct providers whose issue read resolved (even
-     * if every issue duplicated a baseline). `failedProviderIds` identifies providers with no usable org;
-     * `incompleteProviderIds` identifies providers with both a usable org and a failed/truncated sibling.
-     * `fanOutCount` is the number of org work items spawned.
-     * Each org may carry its own `connectionId` (and, for a self-managed host with no configured connection, its
-     * own `domain`) to target a specific account — the fan-out spans providers, so the target is scoped per org
-     * rather than globally.
+     * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
+     * it must come from the trusted authentication configuration, not repository or remote data.
      */
-    broadenIssues(options: {
-        orgs: ProviderBroadenOrg[];
-        page?: number;
-        cursor?: string;
-        forceSync?: boolean;
-    }): Promise<ProviderBroadenResult<IssueShape>>;
+    domain?: string;
+  }): Promise<ProviderPagedResult<IssueShape>>;
+  /**
+   * Issues matching structured criteria over a repository/org scope, with no forced relationship to the current
+   * user — see {@link IntegrationManager.searchIssuesPage} for the contract (mandatory scope, guaranteed
+   * most-recently-updated-first ordering, and the result-ceiling omission that carries the total match count).
+   */
+  searchIssuesPage(options: {
+    providerId: IntegrationIds;
+    repos?: ProviderReposInput;
+    org?: string;
+    criteria?: IssueSearchCriteria;
+    page?: number;
+    cursor?: string;
+    itemsPerPage?: number;
+    forceSync?: boolean;
+    connectionId?: string;
     /**
-     * Resolves a repository from a remote URL to its provider identity, using core-gitlens' remote matcher
-     * plus the provider's `getRepo` (the equivalent of `gk repo resolve`). Supports every provider whose
-     * client exposes `getRepo`. Per-request outcomes preserve the distinctions consumers need for their
-     * canonicalization policy.
+     * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
+     * it must come from the trusted authentication configuration, not repository or remote data.
      */
-    resolveRepository(options: {
-        providerId?: IntegrationIds;
-        remoteUrl: string;
-        host?: string;
-        connectionId?: string;
-        /**
-         * Explicit self-managed host domain used to select the integration instance. Used only when the requested
-         * connection has no configured domain; it must come from the trusted authentication configuration, not
-         * repository or remote data.
-         */
-        domain?: string;
-    }): Promise<ResolveRepositoryResult>;
-    /** {@link RepositoryResolutionContext} seam: the user's `remotes` configs, for the remote matcher. */
-    getRemoteConfigs(): readonly IntegrationsRemoteConfig[];
-    /** {@link RepositoryResolutionContext} seam: instance lookup by host, for the cloud-host resolution branch. */
-    getIntegrationForDomain(id: IntegrationIds, domain: string | undefined): Promise<Integration | undefined>;
-    private _ignoreSSLErrors;
-    ignoreSSLErrors(integration: GitHostIntegration | {
-        id: IntegrationIds;
-        domain?: string;
-    }): boolean | 'force';
-    manageCloudIntegrations(source: Source | undefined): Promise<void>;
-    reset(): Promise<void>;
-    supports(remoteProviderId: RemoteProviderId): boolean;
-    private onAuthenticationSessionsChanged;
-    private onIntegrationConnectionChanged;
-    private onSubscriptionChanged;
-    private onUserCheckedIn;
-    private _providersApi;
-    private getProvidersApi;
-    private getCached;
-    private getCacheKey;
-    private getSupportedCloudIntegrations;
-    private getCloudConnectionState;
-    private findCachedById;
-    private getCachedForDomain;
-    private getConfiguredCloudConnection;
-    private getConfiguredConnectionDomain;
-    private getCloudPrimaryConnectionIdsByDomain;
-    private syncCloudIntegrations;
+    domain?: string;
+  }): Promise<ProviderPagedResult<IssueShape>>;
+  /**
+   * How many issues match each scope, without fetching any — see {@link IntegrationManager.countIssues} for the
+   * cost model, the per-scope isolation rules, and why `count: undefined` must not be rendered as zero.
+   */
+  countIssues(options: {
+    providerId: IntegrationIds;
+    scopes: readonly IssueCountScope[];
+    connectionId?: string;
     /**
-     * Whether the user has locally disconnected this provider/host. Mirrors the integration model's
-     * `connected:${key}` workspace flag (key = id for cloud, `${id}:${domain}` for self-managed), which is
-     * set to `false` on a local disconnect and cleared on (re)connect.
+     * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
+     * it must come from the trusted authentication configuration, not repository or remote data.
      */
-    private isLocallyDisconnected;
+    domain?: string;
+  }): Promise<ProviderResult<IssueCountResult>>;
+  getIssuesBatch(options: {
+    providerId: IntegrationIds;
+    targets: readonly IssueBatchTarget[];
+    connectionId?: string;
     /**
-     * Reconciles the locally stored connections for a provider with what the backend reports, so that
-     * multiple accounts on the same provider coexist. Only engages when the backend provides
-     * per-connection ids; otherwise the single-connection flow above already handled the primary.
+     * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
+     * it must come from the trusted authentication configuration, not repository or remote data.
      */
-    private reconcileCloudConnections;
+    domain?: string;
+  }): Promise<ProviderResult<IssueBatchResult>>;
+  getTrackerIssue(options: {
+    providerId: IntegrationIds;
+    resourceId: string;
+    resourceUrl?: string;
+    key: string;
+    connectionId?: string;
     /**
-     * Switches the default connection for a provider to `connectionId` (its backend token id). Performs
-     * the server-side primary switch first, then mirrors it locally and refreshes any warm model. Throws
-     * if the backend switch fails so the caller can surface it (local state stays untouched).
+     * Explicit self-managed host domain. Unlike the paged reads this one does not fall back to the primary
+     * connection for a self-managed tracker; see {@link IntegrationManager.getTrackerIssue}.
      */
-    setPrimaryConnection(id: IntegrationIds, connectionId: string): Promise<void>;
+    domain?: string;
+  }): Promise<ProviderResult<TrackerIssueResult>>;
+  /**
+   * How many pull requests match each scope, without fetching any — the PR twin of {@link countIssues}. See
+   * {@link IntegrationManager.countPullRequests} for the cost model, the per-scope isolation rules, and why
+   * `count: undefined` must not be rendered as zero.
+   */
+  countPullRequests(options: {
+    providerId: IntegrationIds;
+    scopes: readonly PullRequestCountScope[];
+    connectionId?: string;
     /**
-     * Removes a single connection for a provider by its backend token id. The backend removes the
-     * connection (auto-promoting a secondary to primary when the removed one was primary); we then mirror
-     * that locally and refresh any warm model. Unlike {@link IntegrationBase.disconnect}, this targets one
-     * account. This always talks to the cloud backend, so the local mirror is cloud-scoped and preserves any
-     * local PAT that happens to share the same id.
-     * Throws if the backend delete fails so the caller can surface it (local state stays untouched).
+     * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
+     * it must come from the trusted authentication configuration, not repository or remote data.
      */
-    deleteConnection(id: IntegrationIds, connectionId: string): Promise<void>;
+    domain?: string;
+  }): Promise<ProviderResult<PullRequestCountResult>>;
+  /**
+   * Reads the user's issues from an issue-tracker provider (Jira/Linear/Trello), whose issues live under
+   * resource → project (not repos), so they can't go through {@link listIssuesPage} (git-host, repo-scoped).
+   * Returns the normalized {@link IssueShape} these providers produce, aggregated across the projects of the
+   * given `org` (or every visible resource/project when omitted). `includeAllAssignees` drops the
+   * "assigned to me" scoping so unassigned issues are included. Best-effort: a per-step failure becomes a
+   * warning without failing the whole read.
+   *
+   * Paginated by project: these providers have no single cross-project issue cursor, so a page is a bounded
+   * window of projects (each drained by its own read). Pagination is opt-in — a caller that supplies none of
+   * `page`/`cursor`/`itemsPerPage` reads every matched project in one page (`hasMore: false`), preserving the
+   * "aggregate everything" contract for callers that don't page. When any of those is supplied, the read is
+   * windowed to `itemsPerPage` projects (default 20) advanced 1-based via `page`/`cursor`, with `hasMore`/
+   * `cursor` carrying the next window. Note: a project's own read has an internal page backstop (see the
+   * per-provider drains); if a single project exceeds it, its extra issues can't be paged from here, but that
+   * incompleteness IS surfaced as `page.truncated` (Jira/Linear report the backstop hit) rather than passed
+   * off as a complete read.
+   *
+   * `connectionId`/`domain` select which connection to read, as on the git-host reads. Both matter for a
+   * self-managed tracker ({@link IssuesSelfManagedHostIntegrationId}), where one provider id spans a
+   * connection per configured host; omitting them reads the primary. A cloud tracker has a single canonical
+   * host, so neither changes what it reads.
+   */
+  listIssueTrackerIssuesPage(options: {
+    providerId: IntegrationIds;
+    org?: string;
+    project?: string;
+    filters?: IssueFilter[];
+    includeAllAssignees?: boolean;
     /**
-     * Resolves a human-readable account handle (e.g. the GitHub login) for a connection by asking the
-     * provider API with that connection's token. The token backend doesn't expose it. Routes through the
-     * integration model so the correct provider API base URL (incl. self-managed domains) and auth type
-     * are used. Best-effort: returns undefined on any failure so callers degrade gracefully.
+     * How to order the issues, as `field:direction`. Validated against `getSupportedFilters().issueSorts`, which
+     * is where a tracker reports; a key no normalized issue carries is refused for a multi-project page.
      */
-    private resolveAccountName;
+    sort?: IssueSorting;
+    forceSync?: boolean;
+    page?: number;
+    cursor?: string;
+    itemsPerPage?: number;
+    connectionId?: string;
+    domain?: string;
+  }): Promise<ProviderPagedResult<IssueShape>>;
+  /**
+   * Sweeps the user's pull requests across providers by draining every page (an "all-pages" read),
+   * returning the neutral sweep result with per-provider warnings. `truncated` is set when a provider
+   * hit `maxPages` with more still available; `fetchFailed` when a drain aborted on a read error.
+   * `targets` selects a connection/domain independently for each provider. The legacy `connectionId` is
+   * honored only when `providerIds` resolves to a single provider (otherwise ambiguous).
+   */
+  sweepPullRequests(options?: PullRequestSweepOptions): Promise<ProviderSweepResult<PullRequestShape>>;
+  /**
+   * Closed/merged counterpart of {@link sweepPullRequests}, feeding Kepler's Kanban "done" column. Applies
+   * the native cross-provider state filter (`Closed` + `Merged`) so it works beyond GitHub.
+   */
+  sweepClosedPullRequests(options?: ClosedPullRequestSweepOptions): Promise<ProviderSweepResult<PullRequestShape>>;
+  /**
+   * Broadens the user's issues by fanning out over the supplied orgs: for each org it lists the org's
+   * repositories, then reads that org's issues. A per-org failure becomes a warning without failing the
+   * whole fan-out. `broadenedProviderIds` lists the distinct providers whose issue read resolved (even
+   * if every issue duplicated a baseline). `failedProviderIds` identifies providers with no usable org;
+   * `incompleteProviderIds` identifies providers with both a usable org and a failed/truncated sibling.
+   * `fanOutCount` is the number of org work items spawned.
+   * Each org may carry its own `connectionId` (and, for a self-managed host with no configured connection, its
+   * own `domain`) to target a specific account — the fan-out spans providers, so the target is scoped per org
+   * rather than globally.
+   */
+  broadenIssues(options: {
+    orgs: ProviderBroadenOrg[];
+    page?: number;
+    cursor?: string;
+    forceSync?: boolean;
+  }): Promise<ProviderBroadenResult<IssueShape>>;
+  /**
+   * Resolves a repository from a remote URL to its provider identity, using core-gitlens' remote matcher
+   * plus the provider's `getRepo` (the equivalent of `gk repo resolve`). Supports every provider whose
+   * client exposes `getRepo`. Per-request outcomes preserve the distinctions consumers need for their
+   * canonicalization policy.
+   */
+  resolveRepository(options: {
+    providerId?: IntegrationIds;
+    remoteUrl: string;
+    host?: string;
+    connectionId?: string;
     /**
-     * Forces a refresh of connected cloud integrations from the backend (equivalent to a "--sync" list),
-     * reconciling local state (multi-account connections, primary flags, account names) so a subsequent
-     * {@link getConfigured} reflects the latest server-side connections. Intended for consumers that need
-     * an up-to-date connection list on demand. Rejects when the authoritative backend connection list cannot
-     * be read, so callers never mistake stale local state for a successful refresh.
+     * Explicit self-managed host domain used to select the integration instance. Used only when the requested
+     * connection has no configured domain; it must come from the trusted authentication configuration, not
+     * repository or remote data.
      */
-    refreshConnections(): Promise<void>;
+    domain?: string;
+  }): Promise<ResolveRepositoryResult>;
+  /** {@link RepositoryResolutionContext} seam: the user's `remotes` configs, for the remote matcher. */
+  getRemoteConfigs(): readonly IntegrationsRemoteConfig[];
+  /** {@link RepositoryResolutionContext} seam: instance lookup by host, for the cloud-host resolution branch. */
+  getIntegrationForDomain(id: IntegrationIds, domain: string | undefined): Promise<Integration | undefined>;
+  private _ignoreSSLErrors;
+  ignoreSSLErrors(integration: GitHostIntegration | {
+    id: IntegrationIds;
+    domain?: string;
+  }): boolean | 'force';
+  manageCloudIntegrations(source: Source | undefined): Promise<void>;
+  reset(): Promise<void>;
+  supports(remoteProviderId: RemoteProviderId): boolean;
+  private onAuthenticationSessionsChanged;
+  private onIntegrationConnectionChanged;
+  private onSubscriptionChanged;
+  private onUserCheckedIn;
+  private _providersApi;
+  private getProvidersApi;
+  private getCached;
+  private getCacheKey;
+  private getSupportedCloudIntegrations;
+  private getCloudConnectionState;
+  private findCachedById;
+  private getCachedForDomain;
+  private getConfiguredCloudConnection;
+  private getConfiguredConnectionDomain;
+  private getCloudPrimaryConnectionIdsByDomain;
+  private syncCloudIntegrations;
+  /**
+   * Whether the user has locally disconnected this provider/host. Mirrors the integration model's
+   * `connected:${key}` workspace flag (key = id for cloud, `${id}:${domain}` for self-managed), which is
+   * set to `false` on a local disconnect and cleared on (re)connect.
+   */
+  private isLocallyDisconnected;
+  /**
+   * Reconciles the locally stored connections for a provider with what the backend reports, so that
+   * multiple accounts on the same provider coexist. Only engages when the backend provides
+   * per-connection ids; otherwise the single-connection flow above already handled the primary.
+   */
+  private reconcileCloudConnections;
+  /**
+   * Switches the default connection for a provider to `connectionId` (its backend token id). Performs
+   * the server-side primary switch first, then mirrors it locally and refreshes any warm model. Throws
+   * if the backend switch fails so the caller can surface it (local state stays untouched).
+   */
+  setPrimaryConnection(id: IntegrationIds, connectionId: string): Promise<void>;
+  /**
+   * Removes a single connection for a provider by its backend token id. The backend removes the
+   * connection (auto-promoting a secondary to primary when the removed one was primary); we then mirror
+   * that locally and refresh any warm model. Unlike {@link IntegrationBase.disconnect}, this targets one
+   * account. This always talks to the cloud backend, so the local mirror is cloud-scoped and preserves any
+   * local PAT that happens to share the same id.
+   * Throws if the backend delete fails so the caller can surface it (local state stays untouched).
+   */
+  deleteConnection(id: IntegrationIds, connectionId: string): Promise<void>;
+  /**
+   * Resolves a human-readable account handle (e.g. the GitHub login) for a connection by asking the
+   * provider API with that connection's token. The token backend doesn't expose it. Routes through the
+   * integration model so the correct provider API base URL (incl. self-managed domains) and auth type
+   * are used. Best-effort: returns undefined on any failure so callers degrade gracefully.
+   */
+  private resolveAccountName;
+  /**
+   * Forces a refresh of connected cloud integrations from the backend (equivalent to a "--sync" list),
+   * reconciling local state (multi-account connections, primary flags, account names) so a subsequent
+   * {@link getConfigured} reflects the latest server-side connections. Intended for consumers that need
+   * an up-to-date connection list on demand. Rejects when the authoritative backend connection list cannot
+   * be read, so callers never mistake stale local state for a successful refresh.
+   */
+  refreshConnections(): Promise<void>;
 }
 /** Internal factory used by the GitLens host and integration tests that need the full service surface. */
 export declare function createIntegrationService(ctx: IntegrationServiceContext): IntegrationService;
+//#endregion
 //# sourceMappingURL=integrationService.d.ts.map