import { FactoryStorageDomain } from '@mastra/core/storage';
import type { CollectionSchema } from '@mastra/core/storage';
export declare class SourceControlConnectionNotFoundError extends Error {
    constructor();
}
export declare const SOURCE_CONTROL_SCHEMAS: CollectionSchema[];
export type SourceControlProviderMetadata = Record<string, unknown>;
export interface SourceControlInstallation {
    id: string;
    integrationId: string;
    orgId: string;
    connectedByUserId: string;
    externalId: string;
    accountName: string | null;
    accountType: string | null;
    providerMetadata: SourceControlProviderMetadata;
    createdAt: Date;
}
export interface UpsertSourceControlInstallationInput {
    orgId: string;
    connectedByUserId: string;
    externalId: string;
    accountName?: string | null;
    accountType?: string | null;
    providerMetadata?: SourceControlProviderMetadata;
}
export interface SourceControlRepository {
    id: string;
    installationId: string;
    externalId: string;
    slug: string;
    defaultBranch: string;
    providerMetadata: SourceControlProviderMetadata;
    createdAt: Date;
    updatedAt: Date;
}
export interface UpsertSourceControlRepositoryInput {
    installationId: string;
    externalId: string;
    slug: string;
    defaultBranch: string;
    providerMetadata?: SourceControlProviderMetadata;
}
export interface ProjectSourceControlConnection {
    id: string;
    factoryProjectId: string;
    integrationId: string;
    installationId: string;
    createdByUserId: string;
    createdAt: Date;
}
export interface CreateProjectSourceControlConnectionInput {
    orgId: string;
    factoryProjectId: string;
    installationId: string;
    createdByUserId: string;
}
export interface ProjectRepository {
    id: string;
    connectionId: string;
    repositoryId: string;
    createdByUserId: string;
    branch: string | null;
    sandboxProvider: string;
    sandboxWorkdir: string;
    setupCommand: string | null;
    teardownCommand: string | null;
    createdAt: Date;
    updatedAt: Date;
}
export interface ExternalRepositoryProjectTarget {
    orgId: string;
    factoryProjectId: string;
    projectRepository: ProjectRepository;
}
/** External id pair identifying a repository linked to a factory project. */
export interface ConfiguredExternalRepositoryKey {
    installationExternalId: string;
    repositoryExternalId: string;
}
export interface LinkProjectRepositoryInput {
    orgId: string;
    connectionId: string;
    repositoryId: string;
    createdByUserId: string;
    branch?: string | null;
    sandboxProvider: string;
    sandboxWorkdir: string;
    setupCommand?: string | null;
    teardownCommand?: string | null;
}
export interface UpdateProjectRepositoryInput {
    branch?: string | null;
    sandboxProvider?: string;
    sandboxWorkdir?: string;
    setupCommand?: string | null;
    teardownCommand?: string | null;
}
/**
 * Who can open a session: 'org' sessions are visible to every member of the
 * owning organization, 'private' sessions only to their owner. Stored at
 * creation; rows created before the column existed read as 'org'.
 */
export type SourceControlSessionVisibility = 'org' | 'private';
export interface SourceControlSession {
    id: string;
    sessionId: string;
    projectRepositoryId: string;
    orgId: string;
    userId: string;
    branch: string;
    title: string | null;
    visibility: SourceControlSessionVisibility;
    baseBranch: string;
    sandboxId: string | null;
    sandboxWorkdir: string | null;
    materializedAt: Date | null;
    /** When the first user message reached the session's agent. Write-once. */
    firstMessageAt: Date | null;
    /** When the agent's first successful sandbox exec finished. Write-once. */
    firstMeaningfulExecAt: Date | null;
    createdAt: Date;
    updatedAt: Date;
}
export interface CreateSourceControlSessionInput {
    sessionId: string;
    projectRepositoryId: string;
    orgId: string;
    userId: string;
    branch: string;
    title?: string | null;
    /** Defaults to 'org' when omitted, matching how NULL rows are read. */
    visibility?: SourceControlSessionVisibility;
    baseBranch: string;
}
export interface SourceControlStorageHandle {
    readonly integrationId: string;
    readonly installations: {
        list(args: {
            orgId: string;
        }): Promise<SourceControlInstallation[]>;
        get(args: {
            orgId: string;
            id: string;
        }): Promise<SourceControlInstallation | null>;
        findByExternalId(args: {
            orgId: string;
            externalId: string;
        }): Promise<SourceControlInstallation | null>;
        upsert(args: UpsertSourceControlInstallationInput): Promise<SourceControlInstallation>;
        delete(args: {
            orgId: string;
            id: string;
        }): Promise<boolean>;
    };
    readonly repositories: {
        list(args: {
            orgId: string;
            installationId: string;
        }): Promise<SourceControlRepository[]>;
        get(args: {
            orgId: string;
            id: string;
        }): Promise<SourceControlRepository | null>;
        findByExternalId(args: {
            orgId: string;
            externalId: string;
        }): Promise<SourceControlRepository | null>;
        findBySlug(args: {
            orgId: string;
            installationId: string;
            slug: string;
        }): Promise<SourceControlRepository | null>;
        upsert(args: {
            orgId: string;
            input: UpsertSourceControlRepositoryInput;
        }): Promise<SourceControlRepository>;
        /**
         * Migrate a repository and its dependent connections to a new installation.
         * Used when a GitHub App is reinstalled with a new installation ID on the same account.
         * Returns the repository under the new installation (either migrated or existing).
         */
        migrateInstallation(args: {
            orgId: string;
            id: string;
            newInstallationId: string;
        }): Promise<SourceControlRepository>;
    };
    readonly connections: {
        list(args: {
            orgId: string;
            factoryProjectId: string;
        }): Promise<ProjectSourceControlConnection[]>;
        get(args: {
            orgId: string;
            id: string;
        }): Promise<ProjectSourceControlConnection | null>;
        create(args: CreateProjectSourceControlConnectionInput): Promise<ProjectSourceControlConnection>;
        delete(args: {
            orgId: string;
            id: string;
        }): Promise<boolean>;
    };
    readonly projectRepositories: {
        list(args: {
            orgId: string;
            connectionId: string;
        }): Promise<ProjectRepository[]>;
        listByExternalRepository(args: {
            installationExternalId: string;
            repositoryExternalId: string;
        }): Promise<ExternalRepositoryProjectTarget[]>;
        /**
         * Distinct external (installation, repository) id pairs linked to any
         * factory project. Lets sweeps scope work to configured repositories
         * without probing every repository an installation can see.
         */
        listConfiguredExternalKeys(): Promise<ConfiguredExternalRepositoryKey[]>;
        get(args: {
            orgId: string;
            id: string;
        }): Promise<ProjectRepository | null>;
        link(args: LinkProjectRepositoryInput): Promise<ProjectRepository>;
        update(args: {
            orgId: string;
            id: string;
            input: UpdateProjectRepositoryInput;
        }): Promise<ProjectRepository | null>;
        unlink(args: {
            orgId: string;
            id: string;
        }): Promise<boolean>;
    };
    readonly sessions: {
        /**
         * Viewer-aware listing: every org-visible session for the repository
         * (regardless of owner) plus the viewer's own private sessions.
         */
        list(args: {
            projectRepositoryId: string;
            viewerUserId: string;
        }): Promise<SourceControlSession[]>;
        /**
         * System-level listing of every session for the repository regardless of
         * visibility. For internal flows only (session retirement, repository
         * teardown); never expose directly to a viewer.
         */
        listByProjectRepository(args: {
            projectRepositoryId: string;
        }): Promise<SourceControlSession[]>;
        getBySessionId(sessionId: string): Promise<SourceControlSession | null>;
        /** Overwrite the session's display title. Keyed by the controller-facing `sessionId`. */
        rename(args: {
            sessionId: string;
            title: string;
        }): Promise<void>;
        getForBranch(args: {
            projectRepositoryId: string;
            userId: string;
            branch: string;
        }): Promise<SourceControlSession | null>;
        create(input: CreateSourceControlSessionInput): Promise<SourceControlSession>;
        setSandbox(args: {
            id: string;
            sandboxId: string | null;
            sandboxWorkdir: string;
        }): Promise<void>;
        /**
         * Record when the session's workspace was first materialized. Write-once:
         * the guarded update only lands while the column is still NULL, so resumes
         * (Railway idle-reap, checkpoint restore, sandbox recreate) do not overwrite
         * the initial-materialize baseline that `materialize_s = materialized_at -
         * created_at` depends on.
         */
        markMaterialized(args: {
            id: string;
        }): Promise<void>;
        /**
         * Record when the session's agent received its first user message.
         * Write-once: the guarded update only lands while the column is still
         * NULL, so retries and process restarts are no-ops. Keyed by the
         * controller-facing `sessionId` (not the row id) because the caller —
         * the session observer — only knows the controller resourceId.
         */
        markFirstMessage(args: {
            sessionId: string;
        }): Promise<void>;
        /**
         * Record when the session's agent completed its first successful sandbox
         * exec (TTFME anchor). Same write-once contract as `markFirstMessage`:
         * guarded on the column being NULL, keyed by the controller-facing
         * `sessionId`.
         */
        markFirstMeaningfulExec(args: {
            sessionId: string;
        }): Promise<void>;
        delete(id: string): Promise<void>;
    };
}
export declare class SourceControlStorage extends FactoryStorageDomain {
    constructor();
    init(): Promise<void>;
    dangerouslyClearAll(): Promise<void>;
    forIntegration(integrationId: string): SourceControlStorageHandle;
}
//# sourceMappingURL=base.d.ts.map