import { PrismaService } from "../../../../core/database/prisma/prisma.service";
import { NotificationService } from "../../../../core/messaging/notification/notification.service";
import { TemporalLoggerService } from "../../../../core/observability/logging/services/temporal-logger.service";
import { BusinessTypeRegistry, DataChanges } from '../../business-type-registry.service';
export interface ProcessModel {
    nodes: ProcessNode[];
    edges: ProcessEdge[];
}
export interface ProcessNode {
    id: string;
    type: NodeType;
    name: string;
    position?: {
        x: number;
        y: number;
    };
    size?: {
        width: number;
        height: number;
    };
    assignees?: string[];
    approvalMode?: 'COUNTERSIGN' | 'OR_SIGN' | 'SEQUENTIAL';
    candidateUsers?: string[];
    candidateGroups?: string[];
    allowAddSign?: boolean;
    allowReturn?: boolean;
    allowForward?: boolean;
    editableFields?: string[];
    config?: {
        approverType?: 'INITIATOR_MANAGER' | 'MANAGER_CHAIN' | 'FIXED_USER' | 'ROLE' | 'DEPARTMENT' | 'DEPT_MANAGER' | 'FORM_FIELD' | 'CUSTOM';
        approvers?: string[];
        managerLevel?: number;
        chainConfig?: {
            stopCondition?: 'deptHead' | 'topLevel' | 'manualStop';
            maxLevels?: number;
        };
        approverConfig?: {
            roles?: string[];
            formField?: string;
            departmentId?: string;
        };
        approvalMode?: 'AND' | 'OR';
        approverDetails?: Array<{
            id: string;
            name: string;
            avatar?: string;
        }>;
    };
    timeoutConfig?: {
        timeoutHours: number;
        reminderHours?: number;
        reminderCount?: number;
        timeoutAction?: 'REMIND' | 'ESCALATE' | 'AUTO_APPROVE' | 'AUTO_REJECT';
        escalateTo?: string;
    };
    delegationConfig?: DelegationConfig;
    validators?: NodeValidator[];
    beforeEnterHooks?: NodeHook[];
    afterCompleteHooks?: NodeHook[];
    conditions?: GatewayCondition[];
    defaultTarget?: string;
    serviceType?: string;
    serviceConfig?: Record<string, any>;
}
export interface ProcessEdge {
    id: string;
    source: string;
    target: string;
    label?: string;
    condition?: string;
}
export interface NodeHook {
    id: string;
    type: HookType;
    config: Record<string, any>;
    condition?: string;
    errorStrategy?: 'CONTINUE' | 'FAIL_PROCESS';
    retryConfig?: {
        maxAttempts: number;
        initialIntervalMs: number;
    };
}
export interface NodeValidator {
    id: string;
    type: ValidatorType;
    config: Record<string, any>;
    message?: string;
}
export interface DelegationConfig {
    enabled: boolean;
    trigger: DelegationTrigger;
    delegateTo: string;
    notifyDelegatee: boolean;
    notifyOriginalAssignee: boolean;
}
export interface GatewayCondition {
    target: string;
    expression: string;
}
export type NodeType = 'START' | 'END' | 'USER_TASK' | 'SERVICE_TASK' | 'GATEWAY' | 'EXCLUSIVE_GATEWAY' | 'PARALLEL_GATEWAY' | 'INCLUSIVE_GATEWAY';
export type HookType = 'SEND_EMAIL' | 'SEND_DINGTALK' | 'SEND_FEISHU' | 'SEND_WEBHOOK' | 'CREATE_TASK' | 'UPDATE_RECORD' | 'CALL_API' | 'SET_VARIABLE' | 'LOG' | 'CUSTOM';
export type ValidatorType = 'FIELD_REQUIRED' | 'FIELD_MODIFIED' | 'FIELD_VALUE' | 'FIELD_PATTERN' | 'CONDITION' | 'ATTACHMENT_REQUIRED' | 'ATTACHMENT_COUNT' | 'COMMENT_REQUIRED' | 'COMMENT_MIN_LENGTH' | 'CUSTOM';
export type DelegationTrigger = 'USER_ON_LEAVE' | 'USER_INACTIVE' | 'USER_UNAVAILABLE' | 'TIME_RANGE' | 'HOLIDAY' | 'WORKING_HOURS' | 'TASK_TIMEOUT' | 'CUSTOM';
export interface ProcessSettings {
    callbackUrl?: string;
    maxNodeExecutions?: number;
    maxTotalNodeExecutions?: number;
    maxReturnCount?: number;
    enableAutoApprove?: boolean;
    autoApproveMode?: 'none' | 'sameApprover' | 'initiator' | 'both';
}
export interface UserInfo {
    id: string;
    name: string;
    avatar?: string;
    department?: string;
    position?: string;
    managerId?: string;
    departmentHeadId?: string;
}
export declare class ApprovalActivities {
    private readonly prisma;
    private readonly notificationService;
    private readonly temporalLogger;
    private businessTypeRegistry?;
    constructor(prisma: PrismaService, notificationService: NotificationService, temporalLogger: TemporalLoggerService);
    setBusinessTypeRegistry(registry: BusinessTypeRegistry): void;
    createNodeInstance(params: {
        instanceId: string;
        nodeId: string;
        nodeName: string;
        nodeType: string;
        assignees?: string[];
        approvalMode?: string;
    }): Promise<string>;
    completeNodeInstance(params: {
        nodeInstanceId: string;
        result?: any;
    }): Promise<void>;
    skipNodeInstance(params: {
        nodeInstanceId: string;
        reason: string;
    }): Promise<void>;
    suspendInstanceForUnresolvedApprovers(params: {
        instanceId: string;
        nodeInstanceId: string;
        nodeName: string;
        initiatorId: string;
    }): Promise<void>;
    resumeInstanceFromSuspension(params: {
        instanceId: string;
    }): Promise<void>;
    failNodeInstance(params: {
        nodeInstanceId: string;
        error: string;
    }): Promise<void>;
    updateProcessStatus(params: {
        instanceId: string;
        status: string;
        endReason?: string;
    }): Promise<void>;
    failProcess(params: {
        instanceId: string;
        error: string;
    }): Promise<void>;
    onProcessCompleted(params: {
        instanceId: string;
        status: string;
        callbackUrl?: string;
    }): Promise<void>;
    createApprovalTask(params: {
        instanceId: string;
        nodeInstanceId: string;
        name: string;
        assignee?: string;
        candidateUsers?: string[];
        candidateGroups?: string[];
        priority?: number;
        dueDate?: Date;
        formData?: any;
    }): Promise<string>;
    createAutoApprovedTask(params: {
        instanceId: string;
        nodeInstanceId: string;
        name: string;
        assignee: string;
        reason: string;
    }): Promise<string>;
    completeTask(params: {
        taskId: string;
        action: string;
        operatorId: string;
        comment?: string;
        formData?: any;
    }): Promise<void>;
    cancelTask(params: {
        taskId: string;
        reason?: string;
    }): Promise<void>;
    getTask(taskId: string): Promise<any>;
    escalateTask(params: {
        taskId: string;
        escalateTo: string;
        reason: string;
    }): Promise<void>;
    forwardTask(params: {
        taskId: string;
        fromUserId: string;
        toUserId: string;
        comment?: string;
    }): Promise<void>;
    resolveApprovers(params: {
        expression: string;
        instanceId: string;
        variables: Record<string, any>;
    }): Promise<string[]>;
    resolveManagerChain(params: {
        userId: string;
        expression: string;
        variables: Record<string, any>;
    }): Promise<string[]>;
    sendReminder(params: {
        taskId: string;
        userId: string;
        message?: string;
    }): Promise<void>;
    sendNotification(params: {
        userId: string;
        type: string;
        title: string;
        content: string;
        data?: any;
    }): Promise<void>;
    scheduleReminder(params: {
        taskId: string;
        instanceId: string;
        scheduledAt: Date;
        reminderType: string;
        channels: string[];
    }): Promise<void>;
    callbackFormEngine(params: {
        instanceId: string;
        status: string;
        businessType: string;
        businessId: string;
    }): Promise<void>;
    callbackBusinessSystem(params: {
        instanceId: string;
        callbackUrl: string;
        status: string;
        data?: any;
    }): Promise<void>;
    addToRetryQueue(params: {
        instanceId: string;
        callbackType: string;
        callbackUrl?: string;
        payload: any;
        error: string;
    }): Promise<void>;
    createActionLog(params: {
        taskId: string;
        instanceId: string;
        action: string;
        operatorId: string;
        comment?: string;
        targetUserId?: string;
        targetNodeId?: string;
        addSignUsers?: string[];
        formDataChanges?: any;
        attachments?: any;
    }): Promise<string>;
    executeHook(params: {
        hook: NodeHook;
        context: {
            instanceId: string;
            nodeId: string;
            variables: Record<string, any>;
        };
    }): Promise<void>;
    executeHooks(params: {
        hooks: NodeHook[];
        context: {
            instanceId: string;
            nodeId: string;
            variables: Record<string, any>;
        };
    }): Promise<void>;
    private sendEmailHook;
    private sendWebhookHook;
    private createTaskHook;
    private updateRecordHook;
    private callApiHook;
    private setVariableHook;
    validateNode(params: {
        validators: NodeValidator[];
        context: {
            taskId: string;
            operatorId: string;
            action: string;
            comment?: string;
            formData?: any;
            attachments?: any[];
        };
    }): Promise<{
        valid: boolean;
        errors: string[];
    }>;
    private executeValidator;
    checkDelegation(params: {
        userId: string;
        processKey?: string;
    }): Promise<{
        shouldDelegate: boolean;
        delegateTo?: string;
        reason?: string;
    }>;
    resolveDelegateUser(params: {
        delegateTo: string;
        instanceId: string;
        variables: Record<string, any>;
    }): Promise<string | null>;
    executeDelegation(params: {
        taskId: string;
        originalAssignee: string;
        delegateTo: string;
        reason: string;
        delegationType: string;
    }): Promise<void>;
    getUserDelegationSetting(userId: string): Promise<any>;
    logWorkflowStateChange(params: {
        workflowId: string;
        workflowType: string;
        workflowRunId?: string;
        currentState: string;
        previousState?: string;
        trigger?: string;
        businessKey?: string;
        initiatorId?: string;
        error?: {
            type: string;
            message: string;
        };
    }): Promise<void>;
    syncBusinessDataChanges(params: {
        instanceId: string;
        changes: DataChanges;
        operatorId: string;
    }): Promise<void>;
    getBusinessDataForCondition(params: {
        instanceId: string;
    }): Promise<Record<string, any>>;
    private evaluateCondition;
}
export declare function initializeActivities(prisma: PrismaService, notificationService: NotificationService, temporalLogger: TemporalLoggerService, businessTypeRegistry?: BusinessTypeRegistry): void;
export declare function getActivitiesInstance(): ApprovalActivities | undefined;
export declare const createNodeInstance: (params: Parameters<ApprovalActivities["createNodeInstance"]>[0]) => Promise<string>;
export declare const completeNodeInstance: (params: Parameters<ApprovalActivities["completeNodeInstance"]>[0]) => Promise<void>;
export declare const skipNodeInstance: (params: Parameters<ApprovalActivities["skipNodeInstance"]>[0]) => Promise<void>;
export declare const suspendInstanceForUnresolvedApprovers: (params: Parameters<ApprovalActivities["suspendInstanceForUnresolvedApprovers"]>[0]) => Promise<void>;
export declare const resumeInstanceFromSuspension: (params: Parameters<ApprovalActivities["resumeInstanceFromSuspension"]>[0]) => Promise<void>;
export declare const failNodeInstance: (params: Parameters<ApprovalActivities["failNodeInstance"]>[0]) => Promise<void>;
export declare const updateProcessStatus: (params: Parameters<ApprovalActivities["updateProcessStatus"]>[0]) => Promise<void>;
export declare const failProcess: (params: Parameters<ApprovalActivities["failProcess"]>[0]) => Promise<void>;
export declare const onProcessCompleted: (params: Parameters<ApprovalActivities["onProcessCompleted"]>[0]) => Promise<void>;
export declare const createApprovalTask: (params: Parameters<ApprovalActivities["createApprovalTask"]>[0]) => Promise<string>;
export declare const createAutoApprovedTask: (params: Parameters<ApprovalActivities["createAutoApprovedTask"]>[0]) => Promise<string>;
export declare const completeTask: (params: Parameters<ApprovalActivities["completeTask"]>[0]) => Promise<void>;
export declare const cancelTask: (params: Parameters<ApprovalActivities["cancelTask"]>[0]) => Promise<void>;
export declare const getTask: (taskId: string) => Promise<any>;
export declare const escalateTask: (params: Parameters<ApprovalActivities["escalateTask"]>[0]) => Promise<void>;
export declare const forwardTask: (params: Parameters<ApprovalActivities["forwardTask"]>[0]) => Promise<void>;
export declare const resolveApprovers: (params: Parameters<ApprovalActivities["resolveApprovers"]>[0]) => Promise<string[]>;
export declare const resolveManagerChain: (params: Parameters<ApprovalActivities["resolveManagerChain"]>[0]) => Promise<string[]>;
export declare const sendReminder: (params: Parameters<ApprovalActivities["sendReminder"]>[0]) => Promise<void>;
export declare const sendNotification: (params: Parameters<ApprovalActivities["sendNotification"]>[0]) => Promise<void>;
export declare const scheduleReminder: (params: Parameters<ApprovalActivities["scheduleReminder"]>[0]) => Promise<void>;
export declare const callbackFormEngine: (params: Parameters<ApprovalActivities["callbackFormEngine"]>[0]) => Promise<void>;
export declare const callbackBusinessSystem: (params: Parameters<ApprovalActivities["callbackBusinessSystem"]>[0]) => Promise<void>;
export declare const addToRetryQueue: (params: Parameters<ApprovalActivities["addToRetryQueue"]>[0]) => Promise<void>;
export declare const createActionLog: (params: Parameters<ApprovalActivities["createActionLog"]>[0]) => Promise<string>;
export declare const executeHook: (params: Parameters<ApprovalActivities["executeHook"]>[0]) => Promise<void>;
export declare const executeHooks: (params: Parameters<ApprovalActivities["executeHooks"]>[0]) => Promise<void>;
export declare const validateNode: (params: Parameters<ApprovalActivities["validateNode"]>[0]) => Promise<{
    valid: boolean;
    errors: string[];
}>;
export declare const checkDelegation: (params: Parameters<ApprovalActivities["checkDelegation"]>[0]) => Promise<{
    shouldDelegate: boolean;
    delegateTo?: string;
    reason?: string;
}>;
export declare const resolveDelegateUser: (params: Parameters<ApprovalActivities["resolveDelegateUser"]>[0]) => Promise<string | null>;
export declare const executeDelegation: (params: Parameters<ApprovalActivities["executeDelegation"]>[0]) => Promise<void>;
export declare const getUserDelegationSetting: (userId: string) => Promise<any>;
export declare const logWorkflowStateChange: (params: Parameters<ApprovalActivities["logWorkflowStateChange"]>[0]) => Promise<void>;
export declare const syncBusinessDataChanges: (params: Parameters<ApprovalActivities["syncBusinessDataChanges"]>[0]) => Promise<void>;
export declare const getBusinessDataForCondition: (params: Parameters<ApprovalActivities["getBusinessDataForCondition"]>[0]) => Promise<Record<string, any>>;