import { DatabaseConfig, ExecutionsConfig } from '@n8n/config';
import type { CreateExecutionPayload, ExecutionDataStorageLocation, ExecutionDeletionCriteria, FindManyOptions, FindOptionsWhere, IExecutionBase, IExecutionFlattedDb, IExecutionResponse, UpdateExecutionConditions } from '@n8n/db';
import { ExecutionEntity, ExecutionRepository } from '@n8n/db';
import { BinaryDataService, ErrorReporter, StorageConfig } from 'n8n-core';
import { DbStore } from './execution-data/db-store';
import { FsStore } from './execution-data/fs-store';
import type { ExecutionRef } from './execution-data/types';
import { EventService } from '../events/event.service';
type DeletionTarget = ExecutionRef & {
    storedAt: ExecutionDataStorageLocation;
};
export declare class ExecutionPersistence {
    private readonly executionRepository;
    private readonly binaryDataService;
    private readonly fsStore;
    private readonly dbStore;
    private readonly storageConfig;
    private readonly executionsConfig;
    private readonly databaseConfig;
    private readonly errorReporter;
    private readonly eventService;
    constructor(executionRepository: ExecutionRepository, binaryDataService: BinaryDataService, fsStore: FsStore, dbStore: DbStore, storageConfig: StorageConfig, executionsConfig: ExecutionsConfig, databaseConfig: DatabaseConfig, errorReporter: ErrorReporter, eventService: EventService);
    create(payload: CreateExecutionPayload): Promise<string>;
    updateExistingExecution(executionId: string, execution: Partial<IExecutionResponse>, conditions?: UpdateExecutionConditions): 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>;
    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[]>;
    findWithUnflattenedData(executionId: string, accessibleWorkflowIds: string[]): Promise<IExecutionResponse | undefined>;
    findIfSharedUnflatten(executionId: string, sharedWorkflowIds: string[]): Promise<IExecutionResponse | undefined>;
    getExecutionInWorkflowsForPublicApi(id: string, workflowIds: string[], includeData?: boolean): Promise<IExecutionBase | undefined>;
    deleteInFlightExecution(target: DeletionTarget): Promise<void>;
    hardDelete(target: DeletionTarget | DeletionTarget[]): Promise<void>;
    hardDeleteBy(criteria: ExecutionDeletionCriteria): Promise<void>;
    private updateEntityOnly;
    private applyDataUpdate;
    private pickUpdatableEntityColumns;
    private buildEntityWhereCondition;
    private trackRead;
    private trackWrite;
    private getStoreFor;
    private toWorkflowSnapshot;
    private assembleExecution;
    private parseExecutionData;
    private serializeAnnotation;
    private isDuplicateExecutionError;
}
export {};