n8n 1.56.2 → 1.58.0

package/dist/interfaces.d.ts

@@ -0,0 +1,489 @@
+import type { Application } from 'express';
+import type { ExecutionError, ICredentialDataDecryptedObject, ICredentialsDecrypted, ICredentialsEncrypted, IDataObject, IDeferredPromise, IExecuteResponsePromiseData, IPinData, IRun, IRunData, IRunExecutionData, ITaskData, ITelemetryTrackProperties, IWorkflowBase, CredentialLoadingDetails, Workflow, WorkflowExecuteMode, ExecutionStatus, ExecutionSummary, FeatureFlags, INodeProperties, IUserSettings, StartNodeData } from 'n8n-workflow';
+import type { ActiveWorkflowManager } from './active-workflow-manager';
+import type { WorkflowExecute } from 'n8n-core';
+import type PCancelable from 'p-cancelable';
+import type { AnnotationTagEntity } from './databases/entities/annotation-tag-entity';
+import type { AuthProviderType } from './databases/entities/auth-identity';
+import type { SharedCredentials } from './databases/entities/shared-credentials';
+import type { TagEntity } from './databases/entities/tag-entity';
+import type { AssignableRole, GlobalRole, User } from './databases/entities/user';
+import type { CredentialsRepository } from './databases/repositories/credentials.repository';
+import type { SettingsRepository } from './databases/repositories/settings.repository';
+import type { UserRepository } from './databases/repositories/user.repository';
+import type { WorkflowRepository } from './databases/repositories/workflow.repository';
+import type { ExternalHooks } from './external-hooks';
+import type { LICENSE_FEATURES, LICENSE_QUOTAS } from './constants';
+import type { WorkflowWithSharingsAndCredentials } from './workflows/workflows.types';
+import type { RunningJobSummary } from './scaling/scaling.types';
+import type { Scope } from '@n8n/permissions';
+export interface ICredentialsTypeData {
+    [key: string]: CredentialLoadingDetails;
+}
+export interface ICredentialsOverwrite {
+    [key: string]: ICredentialDataDecryptedObject;
+}
+export interface ITagBase {
+    id: string;
+    name: string;
+}
+export interface ITagToImport extends ITagBase {
+    createdAt?: string;
+    updatedAt?: string;
+}
+export type UsageCount = {
+    usageCount: number;
+};
+export type ITagDb = Pick<TagEntity, 'id' | 'name' | 'createdAt' | 'updatedAt'>;
+export type ITagWithCountDb = ITagDb & UsageCount;
+export type IAnnotationTagDb = Pick<AnnotationTagEntity, 'id' | 'name' | 'createdAt' | 'updatedAt'>;
+export type IAnnotationTagWithCountDb = IAnnotationTagDb & UsageCount;
+export interface IWorkflowDb extends IWorkflowBase {
+    tags?: TagEntity[];
+}
+export interface IWorkflowToImport extends IWorkflowBase {
+    tags: ITagToImport[];
+}
+export interface IWorkflowResponse extends IWorkflowBase {
+    id: string;
+}
+export interface ICredentialsBase {
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ICredentialsDb extends ICredentialsBase, ICredentialsEncrypted {
+    id: string;
+    name: string;
+    shared?: SharedCredentials[];
+}
+export type ICredentialsDecryptedDb = ICredentialsBase & ICredentialsDecrypted;
+export type ICredentialsDecryptedResponse = ICredentialsDecryptedDb;
+export type SaveExecutionDataType = 'all' | 'none';
+export interface IExecutionBase {
+    id: string;
+    mode: WorkflowExecuteMode;
+    startedAt: Date;
+    stoppedAt?: Date;
+    workflowId: string;
+    finished: boolean;
+    retryOf?: string;
+    retrySuccessId?: string;
+    status: ExecutionStatus;
+    waitTill?: Date | null;
+}
+export interface IExecutionDb extends IExecutionBase {
+    data: IRunExecutionData;
+    workflowData: IWorkflowBase;
+}
+export type ExecutionPayload = Omit<IExecutionDb, 'id'>;
+export interface IExecutionPushResponse {
+    executionId?: string;
+    waitingForWebhook?: boolean;
+}
+export interface IExecutionResponse extends IExecutionBase {
+    id: string;
+    data: IRunExecutionData;
+    retryOf?: string;
+    retrySuccessId?: string;
+    workflowData: IWorkflowBase | WorkflowWithSharingsAndCredentials;
+    customData: Record<string, string>;
+    annotation: {
+        tags: ITagBase[];
+    };
+}
+export interface IExecutionFlatted extends IExecutionBase {
+    data: string;
+    workflowData: IWorkflowBase;
+}
+export interface IExecutionFlattedDb extends IExecutionBase {
+    id: string;
+    data: string;
+    workflowData: Omit<IWorkflowBase, 'pinData'>;
+    customData: Record<string, string>;
+}
+export interface IExecutionFlattedResponse extends IExecutionFlatted {
+    id: string;
+    retryOf?: string;
+}
+export interface IExecutionsListResponse {
+    count: number;
+    results: ExecutionSummary[];
+    estimated: boolean;
+}
+export interface ExecutionStopResult {
+    finished?: boolean;
+    mode: WorkflowExecuteMode;
+    startedAt: Date;
+    stoppedAt?: Date;
+    status: ExecutionStatus;
+}
+export interface IExecutionsCurrentSummary {
+    id: string;
+    retryOf?: string;
+    startedAt: Date;
+    mode: WorkflowExecuteMode;
+    workflowId: string;
+    status: ExecutionStatus;
+}
+export interface IExecutingWorkflowData {
+    executionData: IWorkflowExecutionDataProcess;
+    startedAt: Date;
+    postExecutePromises: Array<IDeferredPromise<IRun | undefined>>;
+    responsePromise?: IDeferredPromise<IExecuteResponsePromiseData>;
+    workflowExecution?: PCancelable<IRun>;
+    status: ExecutionStatus;
+}
+export interface IExternalHooks {
+    credentials?: {
+        create?: Array<{
+            (this: IExternalHooksFunctions, credentialsData: ICredentialsEncrypted): Promise<void>;
+        }>;
+        delete?: Array<{
+            (this: IExternalHooksFunctions, credentialId: string): Promise<void>;
+        }>;
+        update?: Array<{
+            (this: IExternalHooksFunctions, credentialsData: ICredentialsDb): Promise<void>;
+        }>;
+    };
+    workflow?: {
+        activate?: Array<{
+            (this: IExternalHooksFunctions, workflowData: IWorkflowDb): Promise<void>;
+        }>;
+        create?: Array<{
+            (this: IExternalHooksFunctions, workflowData: IWorkflowBase): Promise<void>;
+        }>;
+        delete?: Array<{
+            (this: IExternalHooksFunctions, workflowId: string): Promise<void>;
+        }>;
+        execute?: Array<{
+            (this: IExternalHooksFunctions, workflowData: IWorkflowDb, mode: WorkflowExecuteMode): Promise<void>;
+        }>;
+        update?: Array<{
+            (this: IExternalHooksFunctions, workflowData: IWorkflowDb): Promise<void>;
+        }>;
+    };
+}
+export interface IExternalHooksFileData {
+    [key: string]: {
+        [key: string]: Array<(...args: any[]) => Promise<void>>;
+    };
+}
+export interface IExternalHooksFunctions {
+    dbCollections: {
+        User: UserRepository;
+        Settings: SettingsRepository;
+        Credentials: CredentialsRepository;
+        Workflow: WorkflowRepository;
+    };
+}
+export interface IVersionNotificationSettings {
+    enabled: boolean;
+    endpoint: string;
+    infoUrl: string;
+}
+export interface IPersonalizationSurveyAnswers {
+    email: string | null;
+    codingSkill: string | null;
+    companyIndustry: string[];
+    companySize: string | null;
+    otherCompanyIndustry: string | null;
+    otherWorkArea: string | null;
+    workArea: string[] | string | null;
+}
+export interface IActiveDirectorySettings {
+    enabled: boolean;
+}
+export interface IPackageVersions {
+    cli: string;
+}
+export type IPushDataType = IPushData['type'];
+export type IPushData = PushDataExecutionFinished | PushDataExecutionStarted | PushDataExecuteAfter | PushDataExecuteBefore | PushDataConsoleMessage | PushDataReloadNodeType | PushDataRemoveNodeType | PushDataTestWebhook | PushDataNodeDescriptionUpdated | PushDataExecutionRecovered | PushDataWorkerStatusMessage | PushDataWorkflowActivated | PushDataWorkflowDeactivated | PushDataWorkflowFailedToActivate | PushDataActiveWorkflowUsersChanged;
+type PushDataActiveWorkflowUsersChanged = {
+    data: IActiveWorkflowUsersChanged;
+    type: 'activeWorkflowUsersChanged';
+};
+type PushDataWorkflowFailedToActivate = {
+    data: IWorkflowFailedToActivate;
+    type: 'workflowFailedToActivate';
+};
+type PushDataWorkflowActivated = {
+    data: IActiveWorkflowChanged;
+    type: 'workflowActivated';
+};
+type PushDataWorkflowDeactivated = {
+    data: IActiveWorkflowChanged;
+    type: 'workflowDeactivated';
+};
+export type PushDataExecutionRecovered = {
+    data: IPushDataExecutionRecovered;
+    type: 'executionRecovered';
+};
+export type PushDataExecutionFinished = {
+    data: IPushDataExecutionFinished;
+    type: 'executionFinished';
+};
+export type PushDataExecutionStarted = {
+    data: IPushDataExecutionStarted;
+    type: 'executionStarted';
+};
+export type PushDataExecuteAfter = {
+    data: IPushDataNodeExecuteAfter;
+    type: 'nodeExecuteAfter';
+};
+export type PushDataExecuteBefore = {
+    data: IPushDataNodeExecuteBefore;
+    type: 'nodeExecuteBefore';
+};
+export type PushDataConsoleMessage = {
+    data: IPushDataConsoleMessage;
+    type: 'sendConsoleMessage';
+};
+type PushDataWorkerStatusMessage = {
+    data: IPushDataWorkerStatusMessage;
+    type: 'sendWorkerStatusMessage';
+};
+type PushDataReloadNodeType = {
+    data: IPushDataReloadNodeType;
+    type: 'reloadNodeType';
+};
+export type PushDataRemoveNodeType = {
+    data: IPushDataRemoveNodeType;
+    type: 'removeNodeType';
+};
+export type PushDataTestWebhook = {
+    data: IPushDataTestWebhook;
+    type: 'testWebhookDeleted' | 'testWebhookReceived';
+};
+export type PushDataNodeDescriptionUpdated = {
+    data: undefined;
+    type: 'nodeDescriptionUpdated';
+};
+export type Iso8601DateTimeString = string;
+export interface IActiveWorkflowUser {
+    user: PublicUser;
+    lastSeen: Iso8601DateTimeString;
+}
+export interface IActiveWorkflowUsersChanged {
+    workflowId: Workflow['id'];
+    activeUsers: IActiveWorkflowUser[];
+}
+export interface IActiveWorkflowAdded {
+    workflowId: Workflow['id'];
+}
+interface IActiveWorkflowChanged {
+    workflowId: Workflow['id'];
+}
+interface IWorkflowFailedToActivate {
+    workflowId: Workflow['id'];
+    errorMessage: string;
+}
+export interface IPushDataExecutionRecovered {
+    executionId: string;
+}
+export interface IPushDataExecutionFinished {
+    data: IRun;
+    executionId: string;
+    retryOf?: string;
+}
+export interface IPushDataExecutionStarted {
+    executionId: string;
+    mode: WorkflowExecuteMode;
+    startedAt: Date;
+    retryOf?: string;
+    workflowId: string;
+    workflowName?: string;
+}
+export interface IPushDataNodeExecuteAfter {
+    data: ITaskData;
+    executionId: string;
+    nodeName: string;
+}
+export interface IPushDataNodeExecuteBefore {
+    executionId: string;
+    nodeName: string;
+}
+export interface IPushDataReloadNodeType {
+    name: string;
+    version: number;
+}
+export interface IPushDataRemoveNodeType {
+    name: string;
+    version: number;
+}
+export interface IPushDataTestWebhook {
+    executionId: string;
+    workflowId: string;
+}
+export interface IPushDataConsoleMessage {
+    source: string;
+    message: string;
+}
+export interface IPushDataWorkerStatusMessage {
+    workerId: string;
+    status: IPushDataWorkerStatusPayload;
+}
+export interface IPushDataWorkerStatusPayload {
+    workerId: string;
+    runningJobsSummary: RunningJobSummary[];
+    freeMem: number;
+    totalMem: number;
+    uptime: number;
+    loadAvg: number[];
+    cpus: string;
+    arch: string;
+    platform: NodeJS.Platform;
+    hostname: string;
+    interfaces: Array<{
+        family: 'IPv4' | 'IPv6';
+        address: string;
+        internal: boolean;
+    }>;
+    version: string;
+}
+export interface INodesTypeData {
+    [key: string]: {
+        className: string;
+        sourcePath: string;
+    };
+}
+export interface IWorkflowErrorData {
+    [key: string]: any;
+    execution?: {
+        id?: string;
+        url?: string;
+        retryOf?: string;
+        error: ExecutionError;
+        lastNodeExecuted: string;
+        mode: WorkflowExecuteMode;
+    };
+    trigger?: {
+        error: ExecutionError;
+        mode: WorkflowExecuteMode;
+    };
+    workflow: {
+        id?: string;
+        name: string;
+    };
+}
+export interface IWorkflowExecutionDataProcess {
+    destinationNode?: string;
+    restartExecutionId?: string;
+    executionMode: WorkflowExecuteMode;
+    executionData?: IRunExecutionData;
+    runData?: IRunData;
+    pinData?: IPinData;
+    retryOf?: string;
+    pushRef?: string;
+    startNodes?: StartNodeData[];
+    workflowData: IWorkflowBase;
+    userId?: string;
+    projectId?: string;
+}
+export interface IWorkflowExecuteProcess {
+    startedAt: Date;
+    workflow: Workflow;
+    workflowExecute: WorkflowExecute;
+}
+export interface IWorkflowStatisticsDataLoaded {
+    dataLoaded: boolean;
+}
+export declare namespace CommunityPackages {
+    type ParsedPackageName = {
+        packageName: string;
+        rawString: string;
+        scope?: string;
+        version?: string;
+    };
+    type AvailableUpdates = {
+        [packageName: string]: {
+            current: string;
+            wanted: string;
+            latest: string;
+            location: string;
+        };
+    };
+    type PackageStatusCheck = {
+        status: 'OK' | 'Banned';
+        reason?: string;
+    };
+}
+export interface IExecutionTrackProperties extends ITelemetryTrackProperties {
+    workflow_id: string;
+    success: boolean;
+    error_node_type?: string;
+    is_manual: boolean;
+}
+type ValuesOf<T> = T[keyof T];
+export type BooleanLicenseFeature = ValuesOf<typeof LICENSE_FEATURES>;
+export type NumericLicenseFeature = ValuesOf<typeof LICENSE_QUOTAS>;
+export interface ILicenseReadResponse {
+    usage: {
+        executions: {
+            limit: number;
+            value: number;
+            warningThreshold: number;
+        };
+    };
+    license: {
+        planId: string;
+        planName: string;
+    };
+}
+export interface ILicensePostResponse extends ILicenseReadResponse {
+    managementToken: string;
+}
+export interface PublicUser {
+    id: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    personalizationAnswers?: IPersonalizationSurveyAnswers | null;
+    password?: string;
+    passwordResetToken?: string;
+    createdAt: Date;
+    isPending: boolean;
+    role?: GlobalRole;
+    globalScopes?: Scope[];
+    signInType: AuthProviderType;
+    disabled: boolean;
+    settings?: IUserSettings | null;
+    inviteAcceptUrl?: string;
+    isOwner?: boolean;
+    featureFlags?: FeatureFlags;
+}
+export interface Invitation {
+    email: string;
+    role: AssignableRole;
+}
+export interface N8nApp {
+    app: Application;
+    restEndpoint: string;
+    externalHooks: ExternalHooks;
+    activeWorkflowManager: ActiveWorkflowManager;
+}
+export type UserSettings = Pick<User, 'id' | 'settings'>;
+export interface SecretsProviderSettings<T = IDataObject> {
+    connected: boolean;
+    connectedAt: Date | null;
+    settings: T;
+}
+export interface ExternalSecretsSettings {
+    [key: string]: SecretsProviderSettings;
+}
+export type SecretsProviderState = 'initializing' | 'connected' | 'error';
+export declare abstract class SecretsProvider {
+    displayName: string;
+    name: string;
+    properties: INodeProperties[];
+    state: SecretsProviderState;
+    abstract init(settings: SecretsProviderSettings): Promise<void>;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract update(): Promise<void>;
+    abstract test(): Promise<[boolean] | [boolean, string]>;
+    abstract getSecret(name: string): unknown;
+    abstract hasSecret(name: string): boolean;
+    abstract getSecretNames(): string[];
+}
+export type N8nInstanceType = 'main' | 'webhook' | 'worker';
+export {};

package/dist/interfaces.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretsProvider = void 0;
+class SecretsProvider {
+}
+exports.SecretsProvider = SecretsProvider;
+//# sourceMappingURL=interfaces.js.map

package/dist/interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":";;;AAynBA,MAAsB,eAAe;CAiBpC;AAjBD,0CAiBC"}

package/dist/ldap/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/ldap/constants.ts"],"names":[],"mappings":";;;AAEa,QAAA,iBAAiB,GAAG,eAAe,CAAC;AAEpC,QAAA,gBAAgB,GAAG,qBAAqB,CAAC;AAEzC,QAAA,kBAAkB,GAAG,uBAAuB,CAAC;AAE7C,QAAA,oBAAoB,GAAG,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;AAEnD,QAAA,0BAA0B,GAAe;IACrD,YAAY,EAAE,KAAK;IACnB,UAAU,EAAE,EAAE;IACd,aAAa,EAAE,EAAE;IACjB,sBAAsB,EAAE,KAAK;IAC7B,kBAAkB,EAAE,MAAM;IAC1B,cAAc,EAAE,GAAG;IACnB,MAAM,EAAE,EAAE;IACV,cAAc,EAAE,EAAE;IAClB,oBAAoB,EAAE,EAAE;IACxB,kBAAkB,EAAE,EAAE;IACtB,iBAAiB,EAAE,EAAE;IACrB,cAAc,EAAE,EAAE;IAClB,gBAAgB,EAAE,EAAE;IACpB,eAAe,EAAE,EAAE;IACnB,UAAU,EAAE,EAAE;IACd,sBAAsB,EAAE,KAAK;IAC7B,uBAAuB,EAAE,EAAE;IAC3B,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,EAAE;CACjB,CAAC;AAEW,QAAA,kBAAkB,GAAG;IACjC,OAAO,EAAE,8CAA8C;IACvD,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE;QACX,cAAc,EAAE;YACf,IAAI,EAAE,QAAQ;SACd;QACD,kBAAkB,EAAE;YACnB,IAAI,EAAE,QAAQ;SACd;QACD,iBAAiB,EAAE;YAClB,IAAI,EAAE,QAAQ;SACd;QACD,eAAe,EAAE;YAChB,IAAI,EAAE,QAAQ;SACd;QACD,gBAAgB,EAAE;YACjB,IAAI,EAAE,QAAQ;SACd;QACD,cAAc,EAAE;YACf,IAAI,EAAE,QAAQ;SACd;QACD,oBAAoB,EAAE;YACrB,IAAI,EAAE,QAAQ;SACd;QACD,MAAM,EAAE;YACP,IAAI,EAAE,QAAQ;SACd;QACD,aAAa,EAAE;YACd,IAAI,EAAE,QAAQ;SACd;QACD,kBAAkB,EAAE;YACnB,IAAI,EAAE,QAAQ;SACd;QACD,cAAc,EAAE;YACf,IAAI,EAAE,QAAQ;SACd;QACD,sBAAsB,EAAE;YACvB,IAAI,EAAE,SAAS;SACf;QACD,UAAU,EAAE;YACX,IAAI,EAAE,QAAQ;SACd;QACD,YAAY,EAAE;YACb,IAAI,EAAE,SAAS;SACf;QACD,UAAU,EAAE;YACX,IAAI,EAAE,QAAQ;SACd;QACD,sBAAsB,EAAE;YACvB,IAAI,EAAE,SAAS;SACf;QACD,uBAAuB,EAAE;YACxB,IAAI,EAAE,QAAQ;SACd;QACD,cAAc,EAAE;YACf,IAAI,EAAE,QAAQ;SACd;QACD,aAAa,EAAE;YACd,IAAI,EAAE,QAAQ;SACd;KACD;IACD,QAAQ,EAAE;QACT,cAAc;QACd,YAAY;QACZ,eAAe;QACf,wBAAwB;QACxB,oBAAoB;QACpB,gBAAgB;QAChB,QAAQ;QACR,gBAAgB;QAChB,sBAAsB;QACtB,oBAAoB;QACpB,mBAAmB;QACnB,gBAAgB;QAChB,kBAAkB;QAClB,iBAAiB;QACjB,YAAY;QACZ,wBAAwB;QACxB,yBAAyB;QACzB,gBAAgB;QAChB,eAAe;KACf;IACD,oBAAoB,EAAE,KAAK;CAC3B,CAAC;AAEW,QAAA,mCAAmC,GAA4B;IAC3E,cAAc;IACd,gBAAgB;IAChB,oBAAoB;IACpB,mBAAmB;IACnB,kBAAkB;IAClB,iBAAiB;IACjB,wBAAwB;IACxB,yBAAyB;IACzB,gBAAgB;IAChB,eAAe;IACf,YAAY;CACZ,CAAC"}

package/dist/ldap/helpers.ee.d.ts

@@ -0,0 +1,31 @@
+import type { Entry as LdapUser } from 'ldapts';
+import { User } from '../databases/entities/user';
+import { AuthIdentity } from '../databases/entities/auth-identity';
+import type { AuthProviderSyncHistory } from '../databases/entities/auth-provider-sync-history';
+import type { ConnectionSecurity, LdapConfig } from './types';
+export declare const isLdapEnabled: () => boolean;
+export declare const getLdapLoginLabel: () => string;
+export declare const isLdapLoginEnabled: () => boolean;
+export declare const validateLdapConfigurationSchema: (ldapConfig: LdapConfig) => {
+    valid: boolean;
+    message: string;
+};
+export declare const resolveEntryBinaryAttributes: (entry: LdapUser) => LdapUser;
+export declare const resolveBinaryAttributes: (entries: LdapUser[]) => void;
+export declare const createFilter: (filter: string, userFilter: string) => string;
+export declare const escapeFilter: (filter: string) => string;
+export declare const getAuthIdentityByLdapId: (idAttributeValue: string) => Promise<AuthIdentity | null>;
+export declare const getUserByEmail: (email: string) => Promise<User | null>;
+export declare const mapLdapAttributesToUser: (ldapUser: LdapUser, ldapConfig: LdapConfig) => [AuthIdentity["providerId"], Pick<User, "email" | "firstName" | "lastName">];
+export declare const getLdapIds: () => Promise<string[]>;
+export declare const getLdapUsers: () => Promise<User[]>;
+export declare const mapLdapUserToDbUser: (ldapUser: LdapUser, ldapConfig: LdapConfig, toCreate?: boolean) => [string, User];
+export declare const processUsers: (toCreateUsers: Array<[string, User]>, toUpdateUsers: Array<[string, User]>, toDisableUsers: string[]) => Promise<void>;
+export declare const saveLdapSynchronization: (data: Omit<AuthProviderSyncHistory, "id" | "providerType">) => Promise<void>;
+export declare const getLdapSynchronizations: (page: number, perPage: number) => Promise<AuthProviderSyncHistory[]>;
+export declare const formatUrl: (url: string, port: number, security: ConnectionSecurity) => string;
+export declare const getMappingAttributes: (ldapConfig: LdapConfig) => string[];
+export declare const createLdapAuthIdentity: (user: User, ldapId: string) => Promise<AuthIdentity>;
+export declare const createLdapUserOnLocalDb: (data: Partial<User>, ldapId: string) => Promise<User>;
+export declare const updateLdapUserOnLocalDb: (identity: AuthIdentity, data: Partial<User>) => Promise<void>;
+export declare const deleteAllLdapIdentities: () => Promise<import("@n8n/typeorm").DeleteResult>;