import type { Scope } from '@n8n/permissions';
import type { FindOptionsWhere } from '@n8n/typeorm';
import { DataSource } from '@n8n/typeorm';
import type { QueryDeepPartialEntity } from '@n8n/typeorm/query-builder/QueryPartialEntity';
import { UserError } from 'n8n-workflow';
import { CredentialsEntity, type User } from '../entities';
import { BaseRepository } from './base-repository';
import { CredentialDependencyRepository, type CredentialDependencyFilter } from './credential-dependency.repository';
import { InstanceCredentialAssignmentRepository } from './instance-credential-assignment.repository';
import type { ICredentialsDb, ListQuery } from '../entities/types-db';
import type { OperationContext } from '../services/transaction';
import { TransactionRunner } from '../services/transaction';
export declare class CredentialIdConflictError extends UserError {
    constructor();
}
type UpsertableCredentialContent = QueryDeepPartialEntity<CredentialsEntity> & Pick<CredentialsEntity, 'type'> & {
    id?: string;
};
export type CredentialSharingRelation = 'shared' | 'shared.project' | 'shared.project.projectRelations';
type CredentialsListQueryOptions = ListQuery.Options & {
    includeData?: boolean;
    includeGlobal?: boolean;
    user?: User;
    relations?: CredentialSharingRelation[];
};
export declare class CredentialsRepository extends BaseRepository<CredentialsEntity> {
    private readonly instanceCredentialAssignmentRepository;
    private readonly credentialDependencyRepository;
    constructor(dataSource: DataSource, instanceCredentialAssignmentRepository: InstanceCredentialAssignmentRepository, transactionRunner: TransactionRunner, credentialDependencyRepository: CredentialDependencyRepository);
    insertProjectCredentialWithOwner(credential: Pick<CredentialsEntity, 'id' | 'name' | 'type' | 'data' | 'isManaged' | 'isResolvable'> & Partial<Pick<CredentialsEntity, 'isGlobal'>>, projectId: string, externalSecretProviderIds: string[], ctx: OperationContext): Promise<CredentialsEntity>;
    findStartingWith(credentialName: string): Promise<CredentialsEntity[]>;
    findNonProjectCredentialsByIds(ids: string[]): Promise<CredentialsEntity[]>;
    findNamesByIds(ids: string[]): Promise<Array<Pick<CredentialsEntity, 'id' | 'name'>>>;
    findExistingIds(ids: string[]): Promise<string[]>;
    findGlobalProjectCredentialIds(ids: string[]): Promise<string[]>;
    findPromotionBindingAccess(ids: string[], projectIds: string[]): Promise<Array<Pick<CredentialsEntity, 'id' | 'type' | 'usageScope' | 'isGlobal'> & {
        projectIds: string[];
    }>>;
    hasResolvableCredential(ids: string[]): Promise<boolean>;
    findDanglingProjectCredentials(): Promise<CredentialsEntity[]>;
    findInstanceCredentialById(credentialId: string, ctx: OperationContext): Promise<CredentialsEntity | null>;
    createContent(credential: CredentialsEntity, ctx: OperationContext): Promise<CredentialsEntity>;
    updateContent(id: string, content: QueryDeepPartialEntity<CredentialsEntity>, ctx: OperationContext): Promise<void>;
    updateDataIfUnchanged(id: string, type: string, expectedData: string, data: string, ctx?: OperationContext): Promise<boolean>;
    upsertImportedContent(content: UpsertableCredentialContent, ctx: OperationContext): Promise<string>;
    saveInstanceCredential(credential: CredentialsEntity, ctx: OperationContext): Promise<CredentialsEntity>;
    updateInstanceCredential(credentialId: string, data: Pick<ICredentialsDb, 'id' | 'name' | 'type' | 'data'>, ctx: OperationContext): Promise<CredentialsEntity | null>;
    findProjectCredentialWithoutOwner(credentialId: string, ctx?: OperationContext): Promise<CredentialsEntity | null>;
    deleteInstanceCredentialIfUnassigned(credentialId: string, ctx?: OperationContext): Promise<{
        status: 'deleted';
    } | {
        status: 'notFound';
    } | {
        status: 'assigned';
        credentialUseIds: string[];
    }>;
    findManyAndCount(listQueryOptions?: CredentialsListQueryOptions, credentialIds?: string[]): Promise<[CredentialsEntity[], number]>;
    private onlyProjectCredentials;
    excludePendingAuthorization(where: FindOptionsWhere<CredentialsEntity>): FindOptionsWhere<CredentialsEntity>;
    deleteExpiredPendingAuthorizations(now: Date): Promise<number>;
    private toFindManyOptions;
    private handleSharedFilters;
    getManyByIds(ids: string[], { withSharings }?: {
        withSharings: boolean;
    }): Promise<CredentialsEntity[]>;
    findAllGlobalCredentials(options?: {
        includeData?: boolean;
    }): Promise<CredentialsEntity[]>;
    findAllPersonalCredentials(): Promise<CredentialsEntity[]>;
    findAllCredentialsForWorkflow(workflowId: string): Promise<CredentialsEntity[]>;
    findAllCredentialsForProject(projectId: string): Promise<CredentialsEntity[]>;
    findByNameAndTypeInProject(name: string, type: string, projectId: string): Promise<CredentialsEntity[]>;
    findByTypesInProject(types: string[], projectId: string): Promise<CredentialsEntity[]>;
    getManyAndCountWithSharingSubquery(user: User, sharingOptions: {
        scopes?: Scope[];
        projectRoles?: string[];
        credentialRoles?: string[];
        isPersonalProject?: boolean;
        personalProjectOwnerId?: string;
        onlySharedWithMe?: boolean;
    }, options?: CredentialsListQueryOptions & {
        filters?: {
            dependency?: CredentialDependencyFilter;
        };
    }): Promise<{
        credentials: CredentialsEntity[];
        count: number;
    }>;
    private getManyQueryWithSharingSubquery;
}
export {};