import { GlobalConfig } from '@n8n/config';
import type { Scope } from '@n8n/permissions';
import { DataSource } from '@n8n/typeorm';
import type { SelectQueryBuilder, UpdateResult, FindOptionsWhere, FindOptionsRelations, EntityManager } from '@n8n/typeorm';
import type { QueryDeepPartialEntity } from '@n8n/typeorm/query-builder/QueryPartialEntity';
import type { ActivityProjectScope } from './activity-event.repository';
import { BaseRepository } from './base-repository';
import { FolderRepository } from './folder.repository';
import { SharedWorkflowRepository } from './shared-workflow.repository';
import { WorkflowHistoryRepository } from './workflow-history.repository';
import { WorkflowEntity, User } from '../entities';
import type { ListQueryDb, FolderWithWorkflowAndSubFolderCount, ListQuery } from '../entities/types-db';
import { type OperationContext, TransactionRunner } from '../services/transaction';
export type WorkflowIdsQuery = {
    query: string;
    parameters: Record<string, unknown>;
};
type WorkflowListQueryOptions = ListQuery.Options & {
    workflowIdsIn?: WorkflowIdsQuery | null;
};
type ResourceType = 'folder' | 'workflow';
type UpsertableWorkflowContent = QueryDeepPartialEntity<WorkflowEntity> & Pick<WorkflowEntity, 'nodes'> & {
    id?: string;
};
export type WorkflowFolderUnionFull = (ListQueryDb.Workflow.Plain | ListQueryDb.Workflow.WithSharing | FolderWithWorkflowAndSubFolderCount) & {
    resource: ResourceType;
};
type WorkflowListResult = {
    workflows: ListQueryDb.Workflow.Plain[] | ListQueryDb.Workflow.WithSharing[];
    count: number;
};
export declare function agentToolReferenceWhere(projectId: string, workflowIds: string[], legacyWorkflowNames: string[]): Array<FindOptionsWhere<WorkflowEntity>>;
export declare class WorkflowRepository extends BaseRepository<WorkflowEntity> {
    private readonly globalConfig;
    private readonly folderRepository;
    private readonly sharedWorkflowRepository;
    private readonly workflowHistoryRepository;
    constructor(dataSource: DataSource, globalConfig: GlobalConfig, folderRepository: FolderRepository, sharedWorkflowRepository: SharedWorkflowRepository, workflowHistoryRepository: WorkflowHistoryRepository, transactionRunner: TransactionRunner);
    findRecentForProjects(projectIds: ActivityProjectScope, limit: number, options?: {
        mcpVisibleOnly?: boolean;
    }): Promise<{
        total: number;
        workflows: Array<{
            id: string;
            name: string;
            active: boolean;
        }>;
    }>;
    findMcpAvailabilityByIds(workflowIds: string[]): Promise<Map<string, boolean>>;
    get(where: FindOptionsWhere<WorkflowEntity>, options?: {
        relations: string[] | FindOptionsRelations<WorkflowEntity>;
    }, ctx?: OperationContext): Promise<WorkflowEntity | null>;
    findArchivedState(workflowId: string, ctx?: OperationContext): Promise<{
        isArchived: boolean;
    } | null>;
    getAllActiveIds(): Promise<string[]>;
    getActiveIds({ maxResults }?: {
        maxResults?: number;
    }): Promise<string[]>;
    getActiveCount(): Promise<number>;
    getWorkflowInfo({ activeOnly, }: {
        activeOnly: boolean;
    }): Promise<Array<{
        id: string;
        name: string;
    }>>;
    getPublishedCount(): Promise<number>;
    getPublishedPersonalWorkflowsCount(): Promise<number>;
    hasAnyWorkflowsWithErrorWorkflow(): Promise<boolean>;
    updateContent(id: string, content: QueryDeepPartialEntity<WorkflowEntity>, ctx: OperationContext): Promise<void>;
    createWorkflowWithOwner(workflow: WorkflowEntity, projectId: string, ctx?: OperationContext): Promise<WorkflowEntity>;
    createContent(workflow: WorkflowEntity, ctx: OperationContext): Promise<WorkflowEntity>;
    upsertImportedContent(content: UpsertableWorkflowContent, ctx: OperationContext): Promise<string>;
    findByCredentialResolverId(resolverId: string): Promise<Array<Pick<WorkflowEntity, 'id' | 'name'>>>;
    findActiveByCredentialResolverId(resolverId: string): Promise<string[]>;
    private addCredentialResolverFilter;
    clearCredentialResolverId(resolverId: string, trx?: EntityManager): Promise<void>;
    removeFromCallerAllowlists(workflowIds: string[], ctx: OperationContext): Promise<void>;
    removeMissingFromCallerAllowlists(ctx: OperationContext): Promise<void>;
    private purgeCallerAllowlists;
    private callerIdEntries;
    private callerIdsWithout;
    private findCallerAllowlistCandidates;
    private lockCallerAllowlists;
    private writeCallerIds;
    findById(workflowId: string): Promise<WorkflowEntity | null>;
    findByIdInContext(workflowId: string, ctx: OperationContext): Promise<WorkflowEntity | null>;
    findForContentUpdate(workflowId: string, ctx: OperationContext): Promise<WorkflowEntity | null>;
    findByIds(workflowIds: string[], { fields }?: {
        fields?: string[];
    }): Promise<WorkflowEntity[]>;
    findManyByAgentToolReferences(projectId: string, workflowIds: string[], legacyWorkflowNames: string[]): Promise<WorkflowEntity[]>;
    findOneByAgentToolReference(projectId: string, reference: {
        workflowId?: string;
        workflowName: string;
    }, options?: {
        withActiveVersion?: boolean;
    }): Promise<WorkflowEntity | null>;
    getIdsAfter(afterId: string | undefined, take: number): Promise<string[]>;
    findExistingIds(workflowIds: string[], ctx?: OperationContext): Promise<string[]>;
    findPreExistingWorkflows(workflowIds: string[]): Promise<WorkflowEntity[]>;
    getActiveTriggerCount(): Promise<number>;
    updateWorkflowTriggerCount(id: string, triggerCount: number): Promise<UpdateResult>;
    getWorkflowsWithEvaluationCount(): Promise<number>;
    private buildBaseUnionQuery;
    getWorkflowsAndFoldersUnion(workflowIds: string[], options?: WorkflowListQueryOptions, accessibleProjectIds?: string[]): Promise<{
        id: string;
        name: string;
        resource: ResourceType;
        createdAt: Date;
        updatedAt: Date;
    }[]>;
    private buildUnionQuery;
    private applySortingToUnionQuery;
    private applyPaginationToUnionQuery;
    private removeNameLowerFromResults;
    getWorkflowsAndFoldersCount(workflowIds: string[], options?: WorkflowListQueryOptions, accessibleProjectIds?: string[]): Promise<number>;
    getWorkflowsAndFoldersWithCount(workflowIds: string[], options?: WorkflowListQueryOptions, accessibleProjectIds?: string[]): Promise<readonly [WorkflowFolderUnionFull[], number]>;
    getWorkflowsAndFoldersWithCountWithSharingSubquery(user: User, sharingOptions: {
        scopes?: Scope[];
        projectRoles?: string[];
        workflowRoles?: string[];
        isPersonalProject?: boolean;
        personalProjectOwnerId?: string;
        onlySharedWithMe?: boolean;
    }, options?: WorkflowListQueryOptions): Promise<readonly [WorkflowFolderUnionFull[], number]>;
    private getWorkflowsAndFoldersUnionWithSharingSubquery;
    private getWorkflowsAndFoldersCountWithSharingSubquery;
    private buildBaseUnionQueryWithSharingSubquery;
    getAllWorkflowIdsInHierarchy(folderId: string, projectId: string): Promise<string[]>;
    private getFolderIds;
    private getWorkflowsIds;
    private fetchExtraData;
    private enrichDataWithExtras;
    getMany(workflowIds: string[], options?: WorkflowListQueryOptions): Promise<WorkflowListResult['workflows']>;
    getManyAndCount(sharedWorkflowIds: string[], options?: WorkflowListQueryOptions): Promise<WorkflowListResult>;
    getManyAndCountWithSharingSubquery(user: User, sharingOptions: {
        scopes?: Scope[];
        projectRoles?: string[];
        workflowRoles?: string[];
        isPersonalProject?: boolean;
        personalProjectOwnerId?: string;
        onlySharedWithMe?: boolean;
    }, options?: WorkflowListQueryOptions): Promise<WorkflowListResult>;
    private getManyQueryWithSharingSubquery;
    findCallableSubworkflows(user: User, sharingOptions: {
        scopes: Scope[];
        projectRoles: string[];
        workflowRoles: string[];
    }, parentWorkflowId: string, options: {
        query?: string;
        triggerNodeTypes: string[];
        skip: number;
        take: number;
    }): Promise<{
        workflows: WorkflowEntity[];
        count: number;
    }>;
    private buildCallablePolicySubquery;
    private settingsTextValue;
    private buildSharedWorkflowIdsSubquery;
    getManyQuery(workflowIds: string[], options?: WorkflowListQueryOptions): SelectQueryBuilder<WorkflowEntity>;
    private createBaseQuery;
    private applyFilters;
    private applyIdsFilter;
    private applyAvailableInMCPFilter;
    private applyTriggerNodeTypesFilter;
    private parseSearchWords;
    private getFieldConcatExpression;
    private buildSearchConditions;
    private applyNameFilter;
    private applyParentFolderFilter;
    private applyActiveFilter;
    private applyIsArchivedFilter;
    private applyTagsFilter;
    private applyProjectFilter;
    private applyNodeTypesFilter;
    private buildWorkflowIdsByNodeTypesSubQuery;
    private applyWorkflowIdsInFilter;
    private applyOwnedByRelation;
    private applySelect;
    private applyRelations;
    private applyActiveVersionRelation;
    private applyTagsRelation;
    private applySorting;
    private applySortingByColumn;
    private applyPagination;
    findStartingWith(workflowName: string): Promise<Array<{
        name: string;
    }>>;
    findIn(workflowIds: string[]): Promise<WorkflowEntity[]>;
    findWebhookBasedActiveWorkflows(): Promise<{
        id: string;
        name: string;
    }[]>;
    updateActiveState(workflowId: string, newState: boolean): Promise<UpdateResult>;
    publishVersion(workflowId: string, versionId?: string): Promise<UpdateResult>;
    unpublishAll(): Promise<UpdateResult>;
    findByActiveState(activeState: boolean): Promise<WorkflowEntity[]>;
    moveAllToFolder(fromFolderId: string, toFolderId: string, tx: EntityManager): Promise<void>;
    moveToFolder(workflowIds: string[], toFolderId: string): Promise<void>;
    findWorkflowsWithNodeType(nodeTypes: string[], includeNodes?: boolean): Promise<(Pick<WorkflowEntity, "active" | "activeVersionId" | "id" | "name"> & Partial<Pick<WorkflowEntity, "nodes">>)[]>;
    findWorkflowsNeedingIndexing(batchSize?: number): Promise<WorkflowEntity[]>;
    findWorkflowsNeedingPublishedVersionIndexing(batchSize?: number): Promise<WorkflowEntity[]>;
    isActive(workflowId: string): Promise<boolean>;
}
export {};