import { Logger } from '@n8n/backend-common';
import { GlobalConfig } from '@n8n/config';
import type { FindManyOptions, FindOperator, FindOptionsWhere } from '@n8n/typeorm';
import { DataSource } from '@n8n/typeorm';
import { BinaryDataService, ErrorReporter } from 'n8n-core';
import type { ExecutionStatus, ExecutionSummary, IWorkflowSettings, WorkflowExecuteMode } from 'n8n-workflow';
import { ExecutionDataStorageLocation, ExecutionEntity } from '../entities';
import type { ActivityProjectScope } from './activity-event.repository';
import { BaseRepository } from './base-repository';
import { SharedWorkflowRepository } from './shared-workflow.repository';
import type { ExecutionSummaries, IExecutionBase, IExecutionFlattedDb, IExecutionResponse } from '../entities/types-db';
import { TransactionRunner } from '../services/transaction';
export type CrashedExecution = {
    id: string;
    workflowId: string;
    workflowName?: string;
    mode: WorkflowExecuteMode;
    startedAt: Date | null;
    stoppedAt: Date;
    tracingContext?: {
        traceparent: string;
        tracestate?: string;
        identity?: Record<string, string>;
    };
    workflowVersionId?: string;
    retryOf?: string;
    workflowCustomTelemetryTags?: IWorkflowSettings['customTelemetryTags'];
    project?: {
        id: string;
        customTelemetryTags: Array<{
            key: string;
            value: string;
        }>;
    };
};
export interface UpdateExecutionConditions {
    requireStatus?: ExecutionStatus;
    requireNotFinished?: boolean;
    requireNotCanceled?: boolean;
}
export interface IGetExecutionsQueryFilter {
    id?: FindOperator<string> | string;
    finished?: boolean;
    mode?: string;
    retryOf?: string;
    retrySuccessId?: string;
    status?: ExecutionStatus[];
    workflowId?: string;
    waitTill?: FindOperator<any> | boolean;
    metadata?: Array<{
        key: string;
        value: string;
        exactMatch?: boolean;
    }>;
    startedAfter?: string;
    startedBefore?: string;
}
export type ExecutionDeletionCriteria = {
    filters: IGetExecutionsQueryFilter | undefined;
    accessibleWorkflowIds: string[];
    deleteConditions: {
        deleteBefore?: Date;
        ids?: string[];
    };
};
export declare class ExecutionRepository extends BaseRepository<ExecutionEntity> {
    private readonly globalConfig;
    private readonly logger;
    private readonly errorReporter;
    private readonly binaryDataService;
    private readonly sharedWorkflowRepository;
    readonly hardDeletionBatchSize = 100;
    constructor(dataSource: DataSource, globalConfig: GlobalConfig, logger: Logger, errorReporter: ErrorReporter, binaryDataService: BinaryDataService, sharedWorkflowRepository: SharedWorkflowRepository, transactionRunner: TransactionRunner);
    findMultipleExecutions(queryParams: FindManyOptions<ExecutionEntity>, options?: {
        unflattenData: true;
        includeData?: true;
    }): Promise<IExecutionResponse[]>;
    findMultipleExecutions(queryParams: FindManyOptions<ExecutionEntity>, options?: {
        unflattenData?: false | undefined;
        includeData?: true;
    }): Promise<IExecutionFlattedDb[]>;
    findMultipleExecutions(queryParams: FindManyOptions<ExecutionEntity>, options?: {
        unflattenData?: boolean;
        includeData?: boolean;
    }): Promise<IExecutionBase[]>;
    reportInvalidExecutions(executions: ExecutionEntity[]): void;
    private serializeAnnotation;
    existsForAccessibleWorkflows(executionId: string, accessibleWorkflowIds: string[]): Promise<boolean>;
    findSingleExecution(id: string, options?: {
        includeData: true;
        includeAnnotation?: boolean;
        unflattenData: true;
        where?: FindOptionsWhere<ExecutionEntity>;
    }): Promise<IExecutionResponse | undefined>;
    findSingleExecution(id: string, options?: {
        includeData: true;
        includeAnnotation?: boolean;
        unflattenData?: false | undefined;
        where?: FindOptionsWhere<ExecutionEntity>;
    }): Promise<IExecutionFlattedDb | undefined>;
    findSingleExecution(id: string, options?: {
        includeData?: boolean;
        includeAnnotation?: boolean;
        unflattenData?: boolean;
        where?: FindOptionsWhere<ExecutionEntity>;
    }): Promise<IExecutionBase | undefined>;
    markAsCrashed(executionIds: string | string[], onBatchTransitioned?: (batch: CrashedExecution[]) => void): Promise<CrashedExecution[]>;
    markWorkflowExecutionsAsCrashed(workflowId: string): Promise<CrashedExecution[]>;
    private transitionToCrashed;
    private withOwnerProjects;
    setRunning(executionId: string): Promise<Date>;
    updateExistingExecution(executionId: string, execution: Partial<IExecutionResponse>, conditions?: UpdateExecutionConditions): Promise<boolean>;
    deleteExecutionsByFilter({ filters, accessibleWorkflowIds, deleteConditions, }: ExecutionDeletionCriteria): Promise<Array<{
        executionId: string;
        workflowId: string;
        storedAt: ExecutionDataStorageLocation;
    }>>;
    getIdsSince(date: Date): Promise<string[]>;
    softDeletePrunableExecutions(): Promise<import("@n8n/typeorm").UpdateResult>;
    findSoftDeletedExecutions(before?: string): Promise<{
        workflowId: string;
        executionId: string;
        storedAt: ExecutionDataStorageLocation;
    }[]>;
    deleteByIds(executionIds: string[]): Promise<import("@n8n/typeorm").DeleteResult>;
    getWaitingExecutions(): Promise<IExecutionResponse[]>;
    findParkedOnSubExecution(): Promise<string[]>;
    countInWorkflows(workflowIds: string[], options: {
        limit: number;
        lastId?: string;
        status?: ExecutionStatus;
        excludedExecutionsIds?: string[];
        startedAfter?: string;
        startedBefore?: string;
    }): Promise<number>;
    summariseRunsForProjects(query: {
        projectIds: ActivityProjectScope;
        stoppedAfter: Date;
        stoppedBefore: Date;
        workflowLimit: number;
        mcpVisibleOnly?: boolean;
    }): Promise<Array<{
        workflowId: string;
        workflowName: string;
        total: number;
        failed: number;
        lastStoppedAt: Date;
        lastFailedExecutionId: string | null;
    }>>;
    private getStatusCondition;
    private getIdCondition;
    getFindManyInWorkflowsCondition(workflowIds: string[], options?: {
        lastId?: string;
        status?: ExecutionStatus;
        excludedExecutionsIds?: string[];
        startedAfter?: string;
        startedBefore?: string;
    }): FindOptionsWhere<IExecutionFlattedDb>;
    findIfShared(executionId: string, sharedWorkflowIds: string[]): Promise<IExecutionFlattedDb | undefined>;
    findIfAccessible(executionId: string, accessibleWorkflowIds: string[]): Promise<IExecutionBase | undefined>;
    stopBeforeRun(execution: IExecutionResponse): Promise<IExecutionResponse>;
    cancelMany(executionIds: string[]): Promise<void>;
    cancelManyRunning(executionIds: string[]): Promise<void>;
    private summaryFields;
    private annotationFields;
    private reduceExecutionsWithAnnotations;
    findManyByRangeQuery(query: ExecutionSummaries.RangeQuery): Promise<ExecutionSummary[]>;
    private toSummary;
    fetchCount(query: ExecutionSummaries.CountQuery): Promise<number>;
    getLiveExecutionRowsOnPostgres(): Promise<number>;
    private toQueryBuilder;
    private toQueryBuilderWithAnnotations;
    getWorkflowIdsWithExecutionsSince(date: Date): Promise<string[]>;
    getDistinctVersionIds(workflowId: string): Promise<string[]>;
    findUnfinishedIds(): Promise<string[]>;
    findStatusesByIds(ids: string[]): Promise<Array<Pick<ExecutionEntity, 'id' | 'status'>>>;
    getAllIds(): Promise<string[]>;
    getInProgressExecutionIds(batchSize: number): Promise<string[]>;
    getConcurrentExecutionsCount(): Promise<number>;
    private handleExecutionRunData;
    findByStopExecutionsFilter(query: ExecutionSummaries.StopExecutionFilterQuery): Promise<Array<{
        id: string;
    }>>;
}