import type { UpdateTestRunStatsRequest, CompleteTestRunRequest, RunnerResponse, PageResponse, CreatePageStateRequest, PageStateResponse, ActionableItemResponse, PersonaResponse, UseCaseResponse, InputValueResponse, FormResponse, TestInteractionResponse, CreateTestRunRequest, TestRunResponse, CreateTestInteractionRunRequest, TestInteractionRunResponse, CompleteTestInteractionRunRequest, CreateTestSurfaceRunRequest, CompleteTestSurfaceRunRequest, TestSurfaceRunResponse, CreateTestSurfaceBundleRunRequest, CompleteTestSurfaceBundleRunRequest, TestSurfaceBundleRunResponse, TestSurfaceBundleResponse, TestSurfaceBundleSurfaceLinkResponse, TestSurfaceBundleInteractionLinkResponse, TestSurfaceBundleScenarioLinkResponse, TestScenarioResponse, CreateReportEmailRequest, HtmlElementResponse, ScaffoldResponse, FindOrCreateScaffoldRequest, PageHashes, DecomposedPageHashes, ActionableItem, TestInteraction, LegacyTestInteraction, FormInfo, CreateElementIdentityRequest, UpdateElementIdentityRequest, ElementIdentityResponse, PageStatePatternResponse, UiPattern, CreateTestActionRequest, TestActionResponse, CreateTestRunFindingRequest, EnsureTestRunFindingRequest, TestRunFindingResponse, ExpertiseResponse, CreateExpertiseRequest, ExpertiseRuleResponse, CreateExpertiseRuleRequest, TestSurface, TestSurfaceResponse, BatchTestInteractionRunsResponse, BatchTestInteractionItem, BatchTestInteractionResult, ScanBeginRequest, ScanNextRequest, ScanNextResponse, ScanEndRequest, ScanEndResponse, UserData } from "@sudobility/testomniac_types";
type StatusUpdatePayload = {
    status_update?: string;
};
type CompleteRunPayload = CompleteTestRunRequest & StatusUpdatePayload;
export declare class ApiClient {
    private baseUrl;
    private apiKey;
    private surfacesCache;
    private interactionsCache;
    private static SURFACES_CACHE_TTL_MS;
    private static INTERACTIONS_CACHE_TTL_MS;
    constructor(baseUrl: string, apiKey: string);
    invalidateSurfacesCache(): void;
    private request;
    private get;
    private post;
    private put;
    private patch;
    getPendingTestRun(): Promise<TestRunResponse | null>;
    getTestRun(testRunId: number): Promise<TestRunResponse | null>;
    getUserData(testEnvironmentId: number): Promise<UserData | null>;
    updateTestRunStats(testRunId: number, stats: UpdateTestRunStatsRequest & StatusUpdatePayload): Promise<void>;
    completeTestRun(testRunId: number, payload: CompleteRunPayload): Promise<void>;
    createTestRun(request: CreateTestRunRequest): Promise<TestRunResponse>;
    createTestInteractionRun(request: CreateTestInteractionRunRequest): Promise<TestInteractionRunResponse>;
    completeTestInteractionRun(testInteractionRunId: number, payload: CompleteTestInteractionRunRequest & StatusUpdatePayload): Promise<void>;
    completeTestInteractionRunBatch(ids: number[], payload: {
        status?: string;
        errorMessage?: string;
        status_update?: string;
    }): Promise<void>;
    clearSupersededFindings(testInteractionRunId: number): Promise<void>;
    getRunner(id: number): Promise<RunnerResponse | null>;
    getPage(id: number): Promise<PageResponse | null>;
    findOrCreatePage(runnerId: number, relativePath: string, testEnvironmentId?: number): Promise<PageResponse>;
    markRequiresLogin(pageId: number): Promise<void>;
    markIsLoginPage(pageId: number): Promise<void>;
    getEntityCredential(credentialId: number): Promise<{
        id: number;
        entityId: string;
        authProvider: string;
        loginUrl: string | null;
        email: string | null;
        username: string | null;
        password: string | null;
        twoFactorCode: string | null;
    }>;
    uploadScreenshot(imageBytes: Uint8Array, filename: string): Promise<{
        path: string;
        thumbnailPath: string;
    }>;
    getPagesByRunner(runnerId: number): Promise<PageResponse[]>;
    createDiscoveredPages(request: {
        testEnvironmentId: number;
        pages: Array<{
            relativePath: string;
            sourcePagePath?: string;
            sourceLabel?: string;
            isPublic?: boolean;
        }>;
    }): Promise<Array<{
        id: number;
        testEnvironmentId: number;
        relativePath: string;
        sourcePagePath: string | null;
        sourceLabel: string | null;
        isPublic: boolean;
        createdAt: string | null;
        updatedAt: string | null;
    }>>;
    getDiscoveredPages(testEnvironmentId: number): Promise<Array<{
        id: number;
        testEnvironmentId: number;
        relativePath: string;
        sourcePagePath: string | null;
        sourceLabel: string | null;
        isPublic: boolean;
        createdAt: string | null;
        updatedAt: string | null;
    }>>;
    createPageVisit(request: {
        testRunId: number;
        testEnvironmentId: number;
        relativePath: string;
        status: string;
        redirectPath?: string;
        requiresLogin?: boolean;
        errorMessage?: string;
    }): Promise<{
        id: number;
        testRunId: number;
        testEnvironmentId: number;
        relativePath: string;
        status: string;
        redirectPath: string | null;
        requiresLogin: boolean | null;
        errorMessage: string | null;
        createdAt: string | null;
    }>;
    getPageVisits(testRunId: number): Promise<Array<{
        id: number;
        testRunId: number;
        testEnvironmentId: number;
        relativePath: string;
        status: string;
        redirectPath: string | null;
        requiresLogin: boolean | null;
        errorMessage: string | null;
        createdAt: string | null;
    }>>;
    getPageState(id: number): Promise<PageStateResponse | null>;
    getPageStates(pageId: number): Promise<PageStateResponse[]>;
    getPageStatesBatch(pageIds: number[]): Promise<Record<string, PageStateResponse[]>>;
    createPageState(params: CreatePageStateRequest): Promise<PageStateResponse>;
    updatePageStateDecomposedHashes(pageStateId: number, decomposedHashes: DecomposedPageHashes): Promise<void>;
    findMatchingPageState(pageId: number, hashes: PageHashes, sizeClass: string): Promise<PageStateResponse | null>;
    insertActionableItems(htmlElementId: number, items: ActionableItem[]): Promise<ActionableItemResponse[]>;
    getItemsByPageState(pageStateId: number): Promise<ActionableItemResponse[]>;
    getItemsByHtmlElement(htmlElementId: number): Promise<ActionableItemResponse[]>;
    getActionableItem(id: number): Promise<ActionableItemResponse | null>;
    createPersona(productId: number, title: string, description: string): Promise<PersonaResponse>;
    getPersonasByProduct(productId: number): Promise<PersonaResponse[]>;
    createUseCase(personaId: number, title: string, description: string): Promise<UseCaseResponse>;
    getUseCasesByPersona(personaId: number): Promise<UseCaseResponse[]>;
    createInputValue(useCaseId: number, fieldSelector: string, fieldName: string, value: string): Promise<InputValueResponse>;
    getInputValuesByUseCase(useCaseId: number): Promise<InputValueResponse[]>;
    getTestScenario(id: number): Promise<TestScenarioResponse | null>;
    getTestScenarioSequencesByScenario(scenarioId: number): Promise<Array<{
        id: number;
        testScenarioId: number;
        testEnvironmentId: number;
    }>>;
    getTestScenarioSequence(id: number): Promise<{
        id: number;
        testScenarioId: number;
        testEnvironmentId: number;
    } | null>;
    getSequenceTestInteractions(sequenceId: number): Promise<Array<{
        id: number;
        testScenarioSequenceId: number;
        testInteractionId: number;
        stepOrder: number;
    }>>;
    /**
     * Full environment row. Needed for `base_url`: a sequence test run without a
     * scanUrl makes the executor resolve relative startingPaths against bare
     * "http://localhost" (no port).
     */
    getTestEnvironment(id: number): Promise<{
        id: number;
        baseUrl: string;
        productId: number;
    } | null>;
    getSequenceRun(id: number): Promise<{
        id: number;
        testScenarioSequenceId: number;
        status: string;
    } | null>;
    completeSequenceRun(id: number, payload: {
        status?: string;
    }): Promise<void>;
    insertForm(pageStateId: number, form: FormInfo, formType?: string): Promise<FormResponse>;
    getFormsByPageState(pageStateId: number): Promise<FormResponse[]>;
    insertTestInteraction(runnerId: number, testInteraction: TestInteraction | LegacyTestInteraction, testSurfaceId?: number, testEnvironmentId?: number): Promise<TestInteractionResponse>;
    /**
     * Fetch the runner's interactions. When `bundleRunId` is given, the API
     * returns only the scan's working set (interactions with runs in that bundle
     * run, closed under dependency chains, plus all navigation interactions) —
     * a few dozen rows instead of the runner's entire (often >10k) set.
     */
    getTestInteractionsByRunner(runnerId: number, bundleRunId?: number): Promise<TestInteractionResponse[]>;
    invalidateInteractionsCache(): void;
    /**
     * Load a single interaction by id (full row, incl. stepsJson). Used by the
     * executor instead of bulk-downloading the runner's entire interaction set
     * just to read one row. Returns null if the interaction does not exist.
     */
    getTestInteraction(testInteractionId: number): Promise<TestInteractionResponse | null>;
    createTestAction(params: CreateTestActionRequest): Promise<TestActionResponse>;
    getTestActionsByCase(testInteractionId: number): Promise<TestActionResponse[]>;
    getTestInteractionActions(testInteractionId: number): Promise<TestActionResponse[]>;
    createTestRunFinding(params: CreateTestRunFindingRequest): Promise<TestRunFindingResponse>;
    ensureTestRunFinding(params: EnsureTestRunFindingRequest): Promise<TestRunFindingResponse>;
    ensureTestRunFindingBatch(items: EnsureTestRunFindingRequest[]): Promise<TestRunFindingResponse[]>;
    getExpertises(): Promise<ExpertiseResponse[]>;
    getExpertiseRules(expertiseId: number): Promise<ExpertiseRuleResponse[]>;
    createExpertise(params: CreateExpertiseRequest): Promise<ExpertiseResponse>;
    createExpertiseRule(params: CreateExpertiseRuleRequest): Promise<ExpertiseRuleResponse>;
    insertTestSurface(runnerId: number, testSurface: TestSurface, testEnvironmentId?: number): Promise<TestSurfaceResponse>;
    getTestSurfacesByRunner(runnerId: number): Promise<TestSurfaceResponse[]>;
    getTestSurface(id: number): Promise<TestSurfaceResponse | null>;
    createReportEmail(params: CreateReportEmailRequest): Promise<void>;
    findOrCreateHtmlElement(html: string, hash: string): Promise<HtmlElementResponse>;
    findOrCreateScaffold(params: FindOrCreateScaffoldRequest): Promise<ScaffoldResponse>;
    findOrCreateScaffoldBatch(items: FindOrCreateScaffoldRequest[]): Promise<ScaffoldResponse[]>;
    getScaffolds(runnerId: number): Promise<ScaffoldResponse[]>;
    updateScaffoldScreenshot(scaffoldId: number, screenshotPath: string): Promise<ScaffoldResponse>;
    linkPageStateScaffolds(pageStateId: number, scaffoldIds: number[]): Promise<void>;
    findMatchingPageStateDecomposed(pageId: number, decomposedHashes: DecomposedPageHashes, sizeClass: string): Promise<PageStateResponse | null>;
    findMatchingPageStateByContentBody(pageId: number, fixedBodyHash: string, sizeClass: string): Promise<PageStateResponse | null>;
    insertPageStatePatterns(pageStateId: number, patterns: UiPattern[]): Promise<PageStatePatternResponse[]>;
    getPageStatePatterns(pageStateId: number): Promise<PageStatePatternResponse[]>;
    findOrCreateElementIdentity(params: CreateElementIdentityRequest): Promise<ElementIdentityResponse>;
    getElementIdentitiesByRunner(runnerId: number): Promise<ElementIdentityResponse[]>;
    updateElementIdentity(id: number, params: UpdateElementIdentityRequest): Promise<void>;
    ensureTestSurfaceBundle(runnerId: number, title: string, uid?: string): Promise<TestSurfaceBundleResponse>;
    ensureTestSurface(runnerId: number, testSurface: TestSurface, testEnvironmentId?: number): Promise<TestSurfaceResponse>;
    ensureTestSurfaceWithRun(params: {
        runnerId: number;
        testEnvironmentId?: number;
        testSurface: TestSurface;
        testSurfaceBundleId: number;
        testSurfaceBundleRunId: number;
    }): Promise<{
        surface: TestSurfaceResponse;
        surfaceRun: TestSurfaceRunResponse;
    }>;
    ensureTestInteraction(runnerId: number, testSurfaceId: number, testInteraction: TestInteraction, testEnvironmentId?: number, existingTestInteractionId?: number): Promise<TestInteractionResponse>;
    ensureTestInteractionBatch(items: BatchTestInteractionItem[]): Promise<BatchTestInteractionResult[]>;
    retireTestInteractions(testInteractionIds: number[]): Promise<void>;
    reconcileTestInteractions(params: {
        testSurfaceId: number;
        desiredKeys: string[];
        dependencyTestInteractionId?: number;
    }): Promise<{
        retiredIds: number[];
    }>;
    ensureBundleSurfaceLink(testSurfaceBundleId: number, testSurfaceId: number): Promise<TestSurfaceBundleSurfaceLinkResponse>;
    ensureBundleInteractionLink(testSurfaceBundleId: number, testInteractionId: number): Promise<TestSurfaceBundleInteractionLinkResponse>;
    ensureBundleScenarioLink(testSurfaceBundleId: number, testScenarioId: number): Promise<TestSurfaceBundleScenarioLinkResponse>;
    claimTestRun(testRunId: number, runnerInstanceId: string, runnerInstanceName: string): Promise<boolean>;
    createTestSurfaceRun(request: CreateTestSurfaceRunRequest): Promise<TestSurfaceRunResponse>;
    completeTestSurfaceRun(id: number, payload: CompleteTestSurfaceRunRequest): Promise<void>;
    completeTestSurfaceRunBatch(ids: number[], payload: {
        status?: string;
    }): Promise<void>;
    createTestSurfaceBundleRun(request: CreateTestSurfaceBundleRunRequest): Promise<TestSurfaceBundleRunResponse>;
    getTestSurfaceBundleRun(id: number): Promise<TestSurfaceBundleRunResponse | null>;
    completeTestSurfaceBundleRun(id: number, payload: CompleteTestSurfaceBundleRunRequest): Promise<void>;
    getTestInteractionsByTestSurface(testSurfaceId: number, includeInactive?: boolean): Promise<TestInteractionResponse[]>;
    getTestSurfacesByBundle(bundleId: number): Promise<TestSurfaceResponse[]>;
    getTestInteractionsByBundle(bundleId: number): Promise<TestInteractionResponse[]>;
    getTestScenariosByBundle(bundleId: number): Promise<TestScenarioResponse[]>;
    getOpenTestInteractionRuns(testSurfaceRunId: number, includeBlocked?: boolean): Promise<TestInteractionRunResponse[]>;
    getOpenTestInteractionRunsBatch(testSurfaceRunIds: number[]): Promise<BatchTestInteractionRunsResponse>;
    getOpenTestSurfaceRuns(bundleRunId: number): Promise<TestSurfaceRunResponse[]>;
    getRunnerState(bundleRunId: number): Promise<{
        openSurfaceRuns: TestSurfaceRunResponse[];
        pendingInteractionRuns: BatchTestInteractionRunsResponse;
    }>;
    scanBegin(params: ScanBeginRequest): Promise<ScanNextResponse>;
    scanNext(params: ScanNextRequest): Promise<ScanNextResponse>;
    scanEnd(params: ScanEndRequest): Promise<ScanEndResponse>;
}
export declare function getApiClient(baseUrl?: string, apiKey?: string): ApiClient;
export {};
//# sourceMappingURL=client.d.ts.map