import type { Client } from "@libsql/client";
import { type GhExecutor } from "../util/gh-discover.js";
import type { MeshGhClient } from "../util/gh-mesh.js";
import { type AdoptCloneFn } from "./mesh-adopt-cluster.js";
import { type SubscribeCloneFn } from "./subscribe.js";
export interface DiscoverArgs {
    owner?: string | undefined;
    registryDb?: Client | undefined;
    ghExecutor?: GhExecutor | undefined;
}
export interface ClusterMemberRepo {
    owner: string;
    name: string;
    cloneUrl: string;
    sshUrl: string;
    isPrivate: boolean;
}
export interface ClusterMember {
    vaultName: string;
    vaultRidHex: string;
    isMain: boolean;
    repo: ClusterMemberRepo;
}
export interface Cluster {
    meshName: string;
    isUnclustered: boolean;
    owner: string | null;
    members: ClusterMember[];
    mainVaultRegistered: boolean;
    mainAlreadyOnGh: boolean;
    pushPermitted: boolean | null;
}
export interface DiscoverResult {
    walkOwner: string;
    totalReposWalked: number;
    totalLytVaultsFound: number;
    clusters: Cluster[];
    durationMs: number;
}
export declare class DiscoverGhUnavailableError extends Error {
    readonly errorCode = "gh-unavailable";
    constructor(reason: string);
}
export declare const UNCLUSTERED_MESH_NAME = "__unclustered__";
export declare function discoverFlow(opts?: DiscoverArgs): Promise<DiscoverResult>;
export declare function collectDiscoverWalkOwners(db: Client, primaryOwner: string): Promise<string[]>;
export type ClusterDecision = "adopt" | "external" | "skip";
export type ClusterOutcomeStatus = "adopted" | "external" | "skipped" | "unauthorized" | "already-registered" | "error";
export interface ClusterOutcome {
    clusterName: string;
    decision: ClusterDecision;
    status: ClusterOutcomeStatus;
    membersProcessed: number;
    message?: string;
}
export interface OrchestrateClustersArgs {
    clusters: readonly Cluster[];
    decisions: ReadonlyMap<string, ClusterDecision>;
    owner: string;
    primaryMeshName: string;
    registryDb?: Client | undefined;
    ghExecutor?: GhExecutor | undefined;
    meshGhClient?: MeshGhClient | undefined;
    adoptCloneFn?: AdoptCloneFn | undefined;
    subscribeCloneFn?: SubscribeCloneFn | undefined;
    noPush?: boolean | undefined;
}
export interface OrchestrateClustersResult {
    outcomes: ClusterOutcome[];
    durationMs: number;
}
export declare function computeAutoDecisions(clusters: readonly Cluster[]): Map<string, ClusterDecision>;
export declare function shouldOfferBatchFastPath(clusters: readonly Cluster[]): boolean;
export declare function orchestrateClusters(args: OrchestrateClustersArgs): Promise<OrchestrateClustersResult>;
//# sourceMappingURL=discover.d.ts.map