@fluxo-dev/api-client-base 26.1.1 → 26.1.2

package/index.cjs.js

@@ -4171,7 +4171,8 @@ class AuthService {
       userId,
       canChangePassword: info.canChangePassword,
       canHandle2FA: info.canHandle2FA,
-      canHandleAccessTokens: info.canHandleAccessTokens
+      canHandleAccessTokens: info.canHandleAccessTokens,
+      canDisable2FA: info.canDisable2FA
     }, {
       withCredentials: true
     }).then(() => {
@@ -5380,26 +5381,328 @@ class PrintingService {
   AddPrinter(printServerId, command) {
     return HttpClient$1.Instance().client.post(`print-server/${printServerId}/virtual-printers`, command);
   }
+  UpdatePrinter(printServerId, printerId, command) {
+    return HttpClient$1.Instance().client.put(`print-server/${printServerId}/virtual-printers/${printerId}`, command);
+  }
+  DeletePrinter(printServerId, printerId) {
+    return HttpClient$1.Instance().client.delete(`print-server/${printServerId}/virtual-printers/${printerId}`);
+  }
+  DeletePrintServer(printServerId) {
+    return HttpClient$1.Instance().client.delete(`print-server/${printServerId}`);
+  }
 }
 
-exports.WorkflowActionInputType = void 0;
-(function (WorkflowActionInputType) {
-  WorkflowActionInputType[WorkflowActionInputType["none"] = 0] = "none";
-  WorkflowActionInputType[WorkflowActionInputType["manual"] = 1] = "manual";
-  WorkflowActionInputType[WorkflowActionInputType["dynamic"] = 2] = "dynamic";
-  WorkflowActionInputType[WorkflowActionInputType["expression"] = 3] = "expression";
-})(exports.WorkflowActionInputType || (exports.WorkflowActionInputType = {}));
+exports.BlockConfigFieldType = void 0;
+(function (BlockConfigFieldType) {
+  BlockConfigFieldType[BlockConfigFieldType["Text"] = 0] = "Text";
+  BlockConfigFieldType[BlockConfigFieldType["TextArea"] = 1] = "TextArea";
+  BlockConfigFieldType[BlockConfigFieldType["Number"] = 2] = "Number";
+  BlockConfigFieldType[BlockConfigFieldType["Boolean"] = 3] = "Boolean";
+  BlockConfigFieldType[BlockConfigFieldType["Select"] = 4] = "Select";
+  BlockConfigFieldType[BlockConfigFieldType["Expression"] = 5] = "Expression";
+  BlockConfigFieldType[BlockConfigFieldType["Secret"] = 6] = "Secret";
+  BlockConfigFieldType[BlockConfigFieldType["KeyValue"] = 7] = "KeyValue";
+  BlockConfigFieldType[BlockConfigFieldType["ObjectMap"] = 8] = "ObjectMap";
+  BlockConfigFieldType[BlockConfigFieldType["Json"] = 9] = "Json";
+  BlockConfigFieldType[BlockConfigFieldType["JsonArray"] = 10] = "JsonArray";
+  BlockConfigFieldType[BlockConfigFieldType["ConnectionString"] = 11] = "ConnectionString";
+})(exports.BlockConfigFieldType || (exports.BlockConfigFieldType = {}));
+exports.DynamicPortType = void 0;
+(function (DynamicPortType) {
+  DynamicPortType[DynamicPortType["Count"] = 0] = "Count";
+  DynamicPortType[DynamicPortType["ArrayProperty"] = 1] = "ArrayProperty";
+})(exports.DynamicPortType || (exports.DynamicPortType = {}));
+exports.PipelineStatus = void 0;
+(function (PipelineStatus) {
+  PipelineStatus[PipelineStatus["Pending"] = 0] = "Pending";
+  PipelineStatus[PipelineStatus["Running"] = 1] = "Running";
+  PipelineStatus[PipelineStatus["Paused"] = 2] = "Paused";
+  PipelineStatus[PipelineStatus["Completed"] = 3] = "Completed";
+  PipelineStatus[PipelineStatus["Failed"] = 4] = "Failed";
+  PipelineStatus[PipelineStatus["Cancelled"] = 5] = "Cancelled";
+})(exports.PipelineStatus || (exports.PipelineStatus = {}));
+exports.NodeExecutionState = void 0;
+(function (NodeExecutionState) {
+  NodeExecutionState[NodeExecutionState["Pending"] = 0] = "Pending";
+  NodeExecutionState[NodeExecutionState["Running"] = 1] = "Running";
+  NodeExecutionState[NodeExecutionState["Completed"] = 2] = "Completed";
+  NodeExecutionState[NodeExecutionState["Failed"] = 3] = "Failed";
+  NodeExecutionState[NodeExecutionState["Cancelled"] = 4] = "Cancelled";
+})(exports.NodeExecutionState || (exports.NodeExecutionState = {}));
+
+// Enum helper per i nomi
+exports.NodeTypeEnum = void 0;
+(function (NodeTypeEnum) {
+  NodeTypeEnum[NodeTypeEnum["Action"] = 0] = "Action";
+  NodeTypeEnum[NodeTypeEnum["Parallel"] = 1] = "Parallel";
+  NodeTypeEnum[NodeTypeEnum["Join"] = 2] = "Join";
+  NodeTypeEnum[NodeTypeEnum["While"] = 3] = "While";
+  NodeTypeEnum[NodeTypeEnum["ForEach"] = 4] = "ForEach";
+  NodeTypeEnum[NodeTypeEnum["Schedule"] = 5] = "Schedule";
+  NodeTypeEnum[NodeTypeEnum["Delay"] = 6] = "Delay";
+  NodeTypeEnum[NodeTypeEnum["WaitForEvent"] = 7] = "WaitForEvent";
+  NodeTypeEnum[NodeTypeEnum["Decision"] = 8] = "Decision";
+  NodeTypeEnum[NodeTypeEnum["Start"] = 9] = "Start";
+  NodeTypeEnum[NodeTypeEnum["End"] = 10] = "End";
+})(exports.NodeTypeEnum || (exports.NodeTypeEnum = {}));
+exports.ActionInputTypeEnum = void 0;
+(function (ActionInputTypeEnum) {
+  ActionInputTypeEnum[ActionInputTypeEnum["Manual"] = 0] = "Manual";
+  ActionInputTypeEnum[ActionInputTypeEnum["Expression"] = 1] = "Expression";
+  ActionInputTypeEnum[ActionInputTypeEnum["StepOutput"] = 2] = "StepOutput";
+  ActionInputTypeEnum[ActionInputTypeEnum["Environment"] = 3] = "Environment"; // Variabile ambiente
+})(exports.ActionInputTypeEnum || (exports.ActionInputTypeEnum = {}));
+// ============================================================================
+// Workflow Execution Types
+// ============================================================================
+exports.WorkflowStatus = void 0;
+(function (WorkflowStatus) {
+  WorkflowStatus[WorkflowStatus["Runnable"] = 0] = "Runnable";
+  WorkflowStatus[WorkflowStatus["Suspended"] = 1] = "Suspended";
+  WorkflowStatus[WorkflowStatus["Complete"] = 2] = "Complete";
+  WorkflowStatus[WorkflowStatus["Terminated"] = 3] = "Terminated"; // Terminata (con o senza errori)
+})(exports.WorkflowStatus || (exports.WorkflowStatus = {}));
+exports.PointerStatus = void 0;
+(function (PointerStatus) {
+  PointerStatus[PointerStatus["Legacy"] = 0] = "Legacy";
+  PointerStatus[PointerStatus["Pending"] = 1] = "Pending";
+  PointerStatus[PointerStatus["Running"] = 2] = "Running";
+  PointerStatus[PointerStatus["Complete"] = 3] = "Complete";
+  PointerStatus[PointerStatus["Sleeping"] = 4] = "Sleeping";
+  PointerStatus[PointerStatus["WaitingForEvent"] = 5] = "WaitingForEvent";
+  PointerStatus[PointerStatus["Failed"] = 6] = "Failed";
+  PointerStatus[PointerStatus["Compensated"] = 7] = "Compensated";
+  PointerStatus[PointerStatus["Cancelled"] = 8] = "Cancelled";
+})(exports.PointerStatus || (exports.PointerStatus = {}));
 
 class WorkflowService {
+  // ============================================================================
+  // ETL Designer Metadata
+  // ============================================================================
+  getEtlBlocks() {
+    return HttpClient$1.Instance().client.get('etl/blocks');
+  }
+  getEtlBlocksGrouped() {
+    return HttpClient$1.Instance().client.get('etl/blocks-grouped');
+  }
+  getEtlBlock(type) {
+    return HttpClient$1.Instance().client.get(`etl/blocks/${type}`);
+  }
+  // ============================================================================
+  // Designer Metadata
+  // ============================================================================
+  /**
+   * Ottiene tutte le azioni disponibili organizzate per categoria
+   */
   getActionsDefinition() {
     return HttpClient$1.Instance().client.get('workflow/designer/actions');
   }
+  /**
+   * Ottiene tutti i trigger disponibili organizzati per categoria
+   */
   getTriggersDefinition() {
     return HttpClient$1.Instance().client.get('workflow/designer/triggers');
   }
+  // ============================================================================
+  // CRUD Operations
+  // ============================================================================
+  /**
+   * Crea un nuovo workflow
+   */
+  createWorkflow(request) {
+    return HttpClient$1.Instance().client.post('workflow/workflows', request);
+  }
+  /**
+   * Ottiene un workflow per ID database
+   */
+  getWorkflowById(id) {
+    return HttpClient$1.Instance().client.get(`workflow/workflows/${id}`);
+  }
+  /**
+   * Ottiene un workflow per WorkflowId
+   */
+  getWorkflowByWorkflowId(workflowId) {
+    return HttpClient$1.Instance().client.get(`workflow/workflows/by-workflow-id/${workflowId}`);
+  }
+  /**
+   * Ottiene tutti i workflow (summary)
+   */
+  listWorkflows() {
+    return HttpClient$1.Instance().client.get('workflow/workflows');
+  }
+  /**
+   * Aggiorna un workflow esistente
+   */
+  updateWorkflow(id, request) {
+    return HttpClient$1.Instance().client.put(`workflow/workflows/${id}`, request);
+  }
+  /**
+   * Elimina un workflow
+   */
+  deleteWorkflow(id) {
+    return HttpClient$1.Instance().client.delete(`workflow/workflows/${id}`);
+  }
+  /**
+   * Attiva un workflow
+   */
+  activateWorkflow(id, updatedBy) {
+    return HttpClient$1.Instance().client.post(`workflow/workflows/${id}/activate`, {
+      updatedBy
+    });
+  }
+  /**
+   * Disattiva un workflow
+   */
+  deactivateWorkflow(id, updatedBy) {
+    return HttpClient$1.Instance().client.post(`workflow/workflows/${id}/deactivate`, {
+      updatedBy
+    });
+  }
+  /**
+   * Avvia un workflow con un trigger specifico
+   * @param workflowId - ID del workflow da avviare
+   * @param triggerId - ID del trigger da utilizzare
+   * @param inputs - Inputs per il trigger (opzionale)
+   */
+  startWorkflow(workflowId, triggerId, inputs) {
+    const inputSchema = {
+      inputs: []
+    };
+    if (inputs) Object.keys(inputs).forEach(input => {
+      inputSchema.inputs.push({
+        key: `${triggerId}.${input}`,
+        value: inputs[input]
+      });
+    });
+    return HttpClient$1.Instance().client.post(`workflow/workflows-start/${workflowId}`, {
+      inputs: inputSchema.inputs
+    });
+  }
+  /**
+   * Clona un workflow
+   */
+  cloneWorkflow(id, request) {
+    return HttpClient$1.Instance().client.post(`workflow/workflows/${id}/clone`, request);
+  }
+  // ============================================================================
+  // Validation
+  // ============================================================================
+  /**
+   * Valida uno schema ReactFlow
+   */
+  validateWorkflow(schema) {
+    return HttpClient$1.Instance().client.post('workflow/designer/validate', schema);
+  }
+  // ============================================================================
+  // Conversion (opzionale, per test/debug)
+  // ============================================================================
+  /**
+   * Converte uno schema ReactFlow in WorkflowCore JSON
+   */
+  convertToWorkflowCore(schema) {
+    return HttpClient$1.Instance().client.post('workflow/designer/convert/to-workflowcore', schema);
+  }
+  /**
+   * Converte un WorkflowCore JSON in schema ReactFlow
+   */
+  convertToReactFlow(request) {
+    return HttpClient$1.Instance().client.post('workflow/designer/convert/to-reactflow', request);
+  }
+  // ============================================================================
+  // Legacy (manteniamo per compatibilità)
+  // ============================================================================
+  /**
+   * @deprecated Use validateWorkflow instead
+   */
   test(workflow) {
     return HttpClient$1.Instance().client.post('workflow/convert', workflow);
   }
+  // ============================================================================
+  // Workflow Executions
+  // ============================================================================
+  /**
+   * Ottiene tutte le esecuzioni di un workflow specifico
+   */
+  getWorkflowExecutions(workflowId) {
+    return HttpClient$1.Instance().client.get(`workflow/workflows/${workflowId}/executions`);
+  }
+  /**
+   * Ottiene i dettagli completi di un'esecuzione
+   */
+  getExecutionDetails(instanceId) {
+    return HttpClient$1.Instance().client.get(`workflow/workflows/executions/${instanceId}`);
+  }
+  /**
+   * Ottiene solo gli step di un'esecuzione
+   */
+  getExecutionSteps(instanceId) {
+    return HttpClient$1.Instance().client.get(`workflow/workflows/executions/${instanceId}/steps`);
+  }
+  /**
+   * Ottiene solo gli errori di un'esecuzione
+   */
+  getExecutionErrors(instanceId) {
+    return HttpClient$1.Instance().client.get(`workflow/workflows/executions/${instanceId}/errors`);
+  }
+  /**
+   * Termina un'esecuzione in corso
+   */
+  terminateExecution(instanceId) {
+    return HttpClient$1.Instance().client.post(`workflow/workflows/executions/${instanceId}/terminate`, {});
+  }
+  /**
+   * Sospende un'esecuzione in corso
+   */
+  suspendExecution(instanceId) {
+    return HttpClient$1.Instance().client.post(`workflow/workflows/executions/${instanceId}/suspend`, {});
+  }
+  /**
+   * Riprende un'esecuzione sospesa
+   */
+  resumeExecution(instanceId) {
+    return HttpClient$1.Instance().client.post(`workflow/workflows/executions/${instanceId}/resume`, {});
+  }
+  // ============================================================================
+  // ETL Pipelines
+  // ============================================================================
+  saveEtlPipeline(request) {
+    return HttpClient$1.Instance().client.post('etl/pipelines', request);
+  }
+  listEtlPipelines() {
+    return HttpClient$1.Instance().client.get('etl/pipelines');
+  }
+  getEtlPipeline(id) {
+    return HttpClient$1.Instance().client.get(`etl/pipelines/${id}`);
+  }
+  deleteEtlPipeline(id) {
+    return HttpClient$1.Instance().client.delete(`etl/pipelines/${id}`);
+  }
+  executeSavedEtlPipeline(pipelineId, request) {
+    return HttpClient$1.Instance().client.post(`etl/pipelines/${pipelineId}/execute`, request !== null && request !== void 0 ? request : {
+      pipelineId
+    });
+  }
+  getEtlPipelineExecutions(pipelineId) {
+    return HttpClient$1.Instance().client.get(`etl/pipelines/${pipelineId}/executions`);
+  }
+  getEtlExecutionDetails(executionId) {
+    return HttpClient$1.Instance().client.get(`etl/executions/${executionId}`);
+  }
+  getRunningEtlExecutions() {
+    return HttpClient$1.Instance().client.get('etl/executions/running');
+  }
+  stopEtlExecution(executionId) {
+    return HttpClient$1.Instance().client.post(`etl/executions/${executionId}/stop`, {});
+  }
+  validateEtlPipeline(request) {
+    return HttpClient$1.Instance().client.post('etl/validate', request);
+  }
+  executeEtlPipeline(request) {
+    return HttpClient$1.Instance().client.post('etl/execute', request);
+  }
+  dryRunEtlPipeline(request) {
+    return HttpClient$1.Instance().client.post('etl/dry-run', request);
+  }
 }
 
 class MailServerService {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluxo-dev/api-client-base",
-  "version": "26.1.1",
+  "version": "26.1.2",
   "type": "commonjs",
   "peerDependencies": {
     "react": "^18.3.1",
@@ -8,7 +8,7 @@
     "react-router-dom": "^6.11.2",
     "react-redux": "^8.0.5",
     "@reduxjs/toolkit": "^1.9.1",
-    "@fluxo-dev/state": "^26.1.1"
+    "@fluxo-dev/state": "^26.1.2"
   },
   "main": "./index.cjs.js",
   "types": "./index.cjs.d.ts"

package/src/lib/auth/auth-service.d.ts

@@ -14,6 +14,7 @@ export interface FluxoUserProfile {
     canChangePassword: boolean;
     canHandle2FA: boolean;
     canHandleAccessTokens: boolean;
+    canDisable2FA: boolean;
 }
 export declare class AuthService {
     private isRefreshingToken;

package/src/lib/configuration/configuration.service.d.ts

@@ -27,6 +27,7 @@ export type SystemSettings = {
     aclMode: FluxoACLMode;
     allowExternalUsers: boolean;
     twoFactorEnabled: boolean;
+    isWorkflowEnabled: boolean;
 };
 export declare enum FluxoACLMode {
     DomainRole = 1,

package/src/lib/printing/models/index.d.ts

@@ -2,6 +2,7 @@ export * from './printer-type';
 export * from './virtual-printer';
 export * from './print-server-type';
 export * from './add-printer-command';
+export * from './update-printer-command';
 export * from './printer-manufacturer';
 export * from './virtual-print-server';
 export * from './print-server-managed-type';

package/src/lib/printing/models/update-printer-command.d.ts

@@ -0,0 +1,4 @@
+export interface UpdatePrinterCommand {
+    name: string;
+    description: string;
+}

package/src/lib/printing/printing.service.d.ts

@@ -2,6 +2,7 @@ import { VirtualPrintServer } from "./models/virtual-print-server";
 import { AddPrinterCommand } from "./models/add-printer-command";
 import { CreatePrintServerCommand } from "./models/create-print-server-command";
 import { UpdatePrintServerCommand } from "./models/update-print-server-command";
+import { UpdatePrinterCommand } from "./models/update-printer-command";
 export declare class PrintingService {
     GetPrintServerList(): Promise<VirtualPrintServer[]>;
     GetPrintServer(printServerId: number): Promise<VirtualPrintServer>;
@@ -9,4 +10,7 @@ export declare class PrintingService {
     GetPrintServerPrinters(printServerId: number): Promise<string[]>;
     CreatePrintServer(command: CreatePrintServerCommand): Promise<import("axios").AxiosResponse<any, any>>;
     AddPrinter(printServerId: number, command: AddPrinterCommand): Promise<import("axios").AxiosResponse<any, any>>;
+    UpdatePrinter(printServerId: number, printerId: number, command: UpdatePrinterCommand): Promise<import("axios").AxiosResponse<any, any>>;
+    DeletePrinter(printServerId: number, printerId: number): Promise<import("axios").AxiosResponse<any, any>>;
+    DeletePrintServer(printServerId: number): Promise<import("axios").AxiosResponse<any, any>>;
 }

package/src/lib/reporting/models/print-report-command.d.ts

@@ -2,4 +2,5 @@ export interface PrintReportCommand {
     reportUrl: string;
     virtualServerId: number;
     virtualPrinterId: number;
+    copies: number;
 }

package/src/lib/security/user/user.d.ts

@@ -23,4 +23,5 @@ export interface SecurityPolicyInfo {
     canChangePassword: boolean;
     canHandle2FA: boolean;
     canHandleAccessTokens: boolean;
+    canDisable2FA: boolean;
 }

package/src/lib/workflow/models/etl.models.d.ts

@@ -0,0 +1,285 @@
+export interface BlockDescriptor {
+    type: string;
+    pattern: string;
+    description: string;
+    tier: number;
+    ui: BlockUiDescriptor;
+    inputs: BlockPortDescriptor[];
+    outputs: BlockPortDescriptor[];
+    configFields: BlockConfigField[];
+    dynamicInputs?: DynamicPortsDescriptor;
+    dynamicOutputs?: DynamicPortsDescriptor;
+}
+export interface BlockUiDescriptor {
+    label: string;
+    category: string;
+    icon: string;
+    color: string;
+    headerColor: string;
+}
+export interface BlockPortDescriptor {
+    id: string;
+    label: string;
+    color: string;
+    isAlwaysVisible: boolean;
+    dataType?: string;
+    conditionalVisibility?: PortVisibilityCondition[];
+}
+export interface PortVisibilityCondition {
+    configField: string;
+    value: string;
+}
+export interface BlockConfigField {
+    key: string;
+    label: string;
+    fieldType: BlockConfigFieldType;
+    required: boolean;
+    defaultValue?: any;
+    placeholder?: string;
+    description?: string;
+    options?: SelectOption[];
+    visibleWhen?: string;
+    validation?: FieldValidation;
+}
+export declare enum BlockConfigFieldType {
+    Text = 0,
+    TextArea = 1,
+    Number = 2,
+    Boolean = 3,
+    Select = 4,
+    Expression = 5,
+    Secret = 6,
+    KeyValue = 7,
+    ObjectMap = 8,
+    Json = 9,
+    JsonArray = 10,
+    ConnectionString = 11
+}
+export interface SelectOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+export interface FieldValidation {
+    min?: number;
+    max?: number;
+    pattern?: string;
+    message?: string;
+}
+export interface BlocksByCategory {
+    [category: string]: BlockDescriptor[];
+}
+export declare enum DynamicPortType {
+    Count = 0,
+    ArrayProperty = 1
+}
+export interface DynamicPortsDescriptor {
+    type: DynamicPortType;
+    sourceField: string;
+    portNamePattern: string;
+    labelPattern: string;
+    minCount?: number;
+    maxCount?: number;
+    channelProperty?: string;
+    defaultColor?: string;
+}
+export interface PipelineDefinition {
+    $schema?: string;
+    id?: string;
+    name: string;
+    description?: string;
+    version?: string;
+    settings?: PipelineSettings;
+    variables?: Record<string, unknown>;
+    nodes: NodeDefinition[];
+    edges: EdgeDefinition[];
+}
+export interface PipelineSettings {
+    maxDegreeOfParallelism?: number;
+    boundedCapacity?: number;
+    cancellationTimeoutSeconds?: number;
+}
+export interface NodeDefinition {
+    id: string;
+    type: string;
+    pattern?: string;
+    label?: string;
+    config: Record<string, unknown>;
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+export interface EdgeDefinition {
+    id?: string;
+    from: string;
+    to: string;
+    channel?: string;
+    sourceHandle?: string;
+    targetHandle?: string;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationError[];
+}
+export interface ValidationError {
+    code: string;
+    message: string;
+    nodeId?: string;
+    fieldKey?: string;
+    nodeIds?: string[];
+    severity: 'Error' | 'Warning';
+}
+export interface PipelineResult {
+    executionId: string;
+    status: PipelineStatus | number;
+    duration: string;
+    totalItemsProcessed: number;
+    totalItemsDeadLettered: number;
+    totalItemsSkipped: number;
+    startTime: string;
+    endTime: string;
+    blockMetrics: BlockMetrics[];
+    errorMessage?: string;
+}
+export declare enum PipelineStatus {
+    Pending = 0,
+    Running = 1,
+    Paused = 2,
+    Completed = 3,
+    Failed = 4,
+    Cancelled = 5
+}
+export declare enum NodeExecutionState {
+    Pending = 0,
+    Running = 1,
+    Completed = 2,
+    Failed = 3,
+    Cancelled = 4
+}
+export interface BlockMetrics {
+    nodeId: string;
+    nodeType: string;
+    itemsIn: number;
+    itemsOut: number;
+    itemsOutByChannel: Record<string, number>;
+    itemsDeadLettered: number;
+    itemsSkipped: number;
+    totalDuration: string;
+    throughput: number;
+    averageItemDuration: string;
+    minItemDuration: string;
+    maxItemDuration: string;
+    nodeState: NodeExecutionState | number | string;
+    hasFailed: boolean;
+    failureReason?: string;
+    previewItemsByChannel?: Record<string, PreviewItem[]>;
+}
+export interface PreviewItem {
+    [key: string]: any;
+    _truncated?: boolean;
+    _originalSize?: number;
+}
+export interface SavePipelineRequest {
+    id?: string;
+    name: string;
+    description?: string;
+    category?: string;
+    definitionJson: string;
+    isActive: boolean;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface SavePipelineResponse {
+    id: string;
+    name: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PipelineListItem {
+    id: string;
+    name: string;
+    description?: string;
+    version: number;
+    category?: string;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    lastExecutedAt?: string;
+    lastExecutionStatus?: PipelineStatus;
+    executionCount: number;
+    successRate: number;
+    tags?: string[];
+}
+export interface PipelineDetails {
+    id: string;
+    name: string;
+    description?: string;
+    version: number;
+    definitionJson: string;
+    category?: string;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    createdBy?: string;
+    updatedBy?: string;
+    lastExecutedAt?: string;
+    lastExecutionStatus?: PipelineStatus;
+    executionCount: number;
+    successCount: number;
+    failureCount: number;
+    successRate: number;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ExecuteSavedPipelineRequest {
+    pipelineId: string;
+    dryRun?: boolean;
+    variableOverrides?: Record<string, unknown>;
+}
+export interface PipelineExecutionHistoryItem {
+    id: string;
+    executionId: string;
+    pipelineId: string;
+    pipelineName: string;
+    pipelineVersion: string;
+    status: PipelineStatus;
+    startTime: string;
+    endTime?: string;
+    formattedDuration?: string;
+    totalItemsProcessed: number;
+    totalItemsDeadLettered: number;
+    totalItemsSkipped: number;
+    successRate: number;
+    errorMessage?: string;
+    executedBy?: string;
+    isDryRun: boolean;
+    serverHostname?: string;
+}
+export interface PipelineExecutionDetails extends PipelineExecutionHistoryItem {
+    errorStackTrace?: string;
+    blockMetricsJson?: string;
+    pipelineDefinitionSnapshot?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RunningExecutionItem {
+    executionId: string;
+    startTime: string;
+    elapsedTime: string;
+}
+export interface StopExecutionResponse {
+    success: boolean;
+    message: string;
+}
+export interface ValidatePipelineRequest {
+    definitionJson: string;
+}
+export interface ExecutePipelineRequest {
+    executionId: string;
+    definitionJson: string;
+    dryRun?: boolean;
+    isDebugMode?: boolean;
+    maxPreviewItems?: number;
+}

package/src/lib/workflow/models/index.d.ts

@@ -1,11 +1,330 @@
-export * from './action-definition';
-export * from './action-input-definition';
-export * from './action-output-definition';
-export * from './action-category-definition';
-export * from './workflow-action';
-export * from './workflow';
-export * from "./workflow-action-input";
-export * from "./workflow-action-input-type";
-export * from './trigger-definition';
-export * from './trigger-category-definition';
-export * from './workflow-trigger';
+export * from './etl.models';
+export interface WorkflowReactFlowSchema {
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    metadata: WorkflowMetadata;
+}
+export interface WorkflowNode {
+    id: string;
+    type: NodeType;
+    position: NodePosition;
+    data: NodeData;
+}
+export type NodeType = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+export declare enum NodeTypeEnum {
+    Action = 0,
+    Parallel = 1,
+    Join = 2,
+    While = 3,
+    ForEach = 4,
+    Schedule = 5,
+    Delay = 6,
+    WaitForEvent = 7,
+    Decision = 8,
+    Start = 9,
+    End = 10
+}
+export interface NodePosition {
+    x: number;
+    y: number;
+}
+export interface NodeData {
+    label: string;
+    stepType?: string;
+    inputs?: Record<string, ActionInput>;
+    outputs?: Record<string, string>;
+    handles: NodeHandles;
+    condition?: string;
+    collection?: string;
+    interval?: string;
+    eventName?: string;
+    eventKey?: string;
+    branches?: number;
+}
+export interface NodeHandles {
+    source: string[];
+    target: string[];
+}
+export interface ActionInput {
+    type: ActionInputType;
+    value: any;
+}
+export type ActionInputType = 0 | 1 | 2 | 3;
+export declare enum ActionInputTypeEnum {
+    Manual = 0,// Valore statico inserito dall'utente
+    Expression = 1,// Espressione dinamica (es. "data.Counter + 1")
+    StepOutput = 2,// Output di step precedente (es. "step0.EmailSentCount")
+    Environment = 3
+}
+export interface WorkflowEdge {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle?: string;
+    targetHandle?: string;
+    label?: string;
+    animated?: boolean;
+}
+export interface WorkflowMetadata {
+    workflowId: string;
+    version: number;
+    description?: string;
+    dataType?: string;
+    triggerId?: string;
+    triggerInputs?: Record<string, any>;
+}
+export interface WorkflowDto {
+    id: number;
+    workflowId: string;
+    name: string;
+    description: string;
+    version: number;
+    reactFlowSchema: WorkflowReactFlowSchema;
+    workflowCoreJson: string;
+    triggerId?: string;
+    triggerInputs?: Record<string, any>;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    createdBy: string;
+    updatedBy: string;
+    tags: string[];
+    category?: string;
+}
+export interface WorkflowSummaryDto {
+    id: number;
+    workflowId: string;
+    name: string;
+    description: string;
+    version: number;
+    isActive: boolean;
+    category?: string;
+    tags: string[];
+    updatedAt: string;
+    updatedBy: string;
+}
+export interface CreateWorkflowRequest {
+    workflowId?: string;
+    name: string;
+    description?: string;
+    reactFlowSchema: WorkflowReactFlowSchema;
+    triggerId?: string;
+    triggerInputs?: Record<string, any>;
+    category?: string;
+    tags?: string[];
+    createdBy: string;
+}
+export interface UpdateWorkflowRequest {
+    name?: string;
+    description?: string;
+    reactFlowSchema?: WorkflowReactFlowSchema;
+    triggerId?: string;
+    triggerInputs?: Record<string, any>;
+    category?: string;
+    tags?: string[];
+    updatedBy: string;
+}
+export interface CloneWorkflowRequest {
+    newWorkflowId?: string;
+    newName?: string;
+    createdBy: string;
+}
+export interface WorkflowValidationResult {
+    isValid: boolean;
+    errors: WorkflowValidationError[];
+    warnings: WorkflowValidationWarning[];
+}
+export interface WorkflowValidationError {
+    code: string;
+    message: string;
+    nodeId?: string;
+    field?: string;
+}
+export interface WorkflowValidationWarning {
+    code: string;
+    message: string;
+    nodeId?: string;
+}
+export interface WorkflowActionCategoryDto {
+    name: string;
+    actions: WorkflowActionDto[];
+}
+export interface WorkflowActionDto {
+    id: string;
+    category: string;
+    name: string;
+    type: string;
+    inputs: ActionInputDescriptor[];
+    outputs: ActionOutputDescriptor[];
+    outcomes?: string[];
+    description?: string;
+    icon?: string;
+    color?: string;
+    tags?: string[];
+    groups?: InputGroup[];
+}
+export interface ActionInputDescriptor {
+    id: string;
+    name: string;
+    description?: string;
+    type: string;
+    required: boolean;
+    defaultValue?: any;
+    hasOptionsProvider: boolean;
+    uiHint: string;
+    helpText?: string;
+    placeholder?: string;
+    group?: string;
+    order: number;
+    validation?: InputValidation;
+    dependencies?: InputDependency[];
+}
+export interface ActionOutputDescriptor {
+    id: string;
+    name: string;
+    description?: string;
+    type: string;
+    displayName?: string;
+}
+/**
+ * Input group for organizing inputs in sections
+ */
+export interface InputGroup {
+    id: string;
+    displayName: string;
+    order: number;
+    collapsed: boolean;
+    description?: string;
+}
+/**
+ * Input validation rules
+ */
+export interface InputValidation {
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    pattern?: string;
+    message?: string;
+}
+/**
+ * Input dependency for conditional visibility/enabled/required
+ */
+export interface InputDependency {
+    dependsOn: string;
+    operator: DependencyOperator;
+    value?: any;
+    action: DependencyAction;
+}
+/**
+ * Dependency operators for condition evaluation
+ */
+export type DependencyOperator = 'equals' | 'notEquals' | 'in' | 'notIn' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual' | 'isNotEmpty' | 'isEmpty';
+/**
+ * Dependency actions (what happens when condition is true)
+ */
+export type DependencyAction = 'visible' | 'enabled' | 'required';
+export interface ActionInputOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+export interface WorkflowTriggerCategoryDto {
+    name: string;
+    triggers: WorkflowTriggerDto[];
+}
+export interface WorkflowTriggerDto {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    icon?: string;
+    inputs: ActionInputDescriptor[];
+    outputs: ActionOutputDescriptor[];
+}
+export interface ConvertToWorkflowCoreResponse {
+    workflowCoreJson: string;
+}
+export interface ConvertToReactFlowRequest {
+    workflowCoreJson: string;
+    autoLayout?: boolean;
+}
+export interface Workflow {
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+}
+export interface ActionCategoryDefinition {
+    name: string;
+    actions: WorkflowActionDto[];
+}
+export interface TriggerCategoryDefinition {
+    name: string;
+    triggers: WorkflowTriggerDto[];
+}
+export declare enum WorkflowStatus {
+    Runnable = 0,// In esecuzione o pronta per eseguire
+    Suspended = 1,// Sospesa manualmente
+    Complete = 2,// Completata con successo
+    Terminated = 3
+}
+export declare enum PointerStatus {
+    Legacy = 0,
+    Pending = 1,
+    Running = 2,
+    Complete = 3,
+    Sleeping = 4,
+    WaitingForEvent = 5,
+    Failed = 6,
+    Compensated = 7,
+    Cancelled = 8
+}
+export interface WorkflowExecutionSummaryDto {
+    instanceId: string;
+    workflowDefinitionId: string;
+    version: number;
+    description: string;
+    reference: string;
+    status: WorkflowStatus;
+    createTime: string;
+    completeTime?: string;
+    nextExecution?: string;
+}
+export interface WorkflowExecutionDetailsDto {
+    instanceId: string;
+    workflowDefinitionId: string;
+    version: number;
+    description: string;
+    reference: string;
+    status: WorkflowStatus;
+    createTime: string;
+    completeTime?: string;
+    nextExecution?: string;
+    data: string;
+    steps: WorkflowExecutionStepDto[];
+    errors: WorkflowExecutionErrorDto[];
+}
+export interface WorkflowExecutionStepDto {
+    id: string;
+    stepId: number;
+    stepName: string;
+    active: boolean;
+    startTime?: string;
+    endTime?: string;
+    status: PointerStatus;
+    outcome: string;
+    retryCount: number;
+    sleepUntil?: string;
+    eventName?: string;
+    eventKey?: string;
+    eventPublished: boolean;
+    persistenceData?: string;
+    contextItem?: string;
+    predecessorId?: string;
+    scope?: string;
+}
+export interface WorkflowExecutionErrorDto {
+    workflowId: string;
+    executionPointerId: string;
+    errorTime: string;
+    message: string;
+}

package/src/lib/workflow/workflow.service.d.ts

@@ -1,6 +1,116 @@
-import { ActionCategoryDefinition, TriggerCategoryDefinition, Workflow } from "./models";
+import { Workflow, WorkflowDto, WorkflowSummaryDto, CreateWorkflowRequest, UpdateWorkflowRequest, CloneWorkflowRequest, WorkflowValidationResult, WorkflowReactFlowSchema, ConvertToWorkflowCoreResponse, ConvertToReactFlowRequest, WorkflowActionCategoryDto, WorkflowTriggerCategoryDto, WorkflowExecutionSummaryDto, WorkflowExecutionDetailsDto, WorkflowExecutionStepDto, WorkflowExecutionErrorDto } from "./models";
+import { BlockDescriptor, BlocksByCategory, ExecutePipelineRequest, ExecuteSavedPipelineRequest, PipelineDetails, PipelineExecutionDetails, PipelineExecutionHistoryItem, PipelineListItem, PipelineResult, RunningExecutionItem, SavePipelineRequest, SavePipelineResponse, StopExecutionResponse, ValidatePipelineRequest, ValidationResult } from "./models/etl.models";
 export declare class WorkflowService {
-    getActionsDefinition(): Promise<ActionCategoryDefinition[]>;
-    getTriggersDefinition(): Promise<TriggerCategoryDefinition[]>;
+    getEtlBlocks(): Promise<BlockDescriptor[]>;
+    getEtlBlocksGrouped(): Promise<BlocksByCategory>;
+    getEtlBlock(type: string): Promise<BlockDescriptor>;
+    /**
+     * Ottiene tutte le azioni disponibili organizzate per categoria
+     */
+    getActionsDefinition(): Promise<WorkflowActionCategoryDto[]>;
+    /**
+     * Ottiene tutti i trigger disponibili organizzati per categoria
+     */
+    getTriggersDefinition(): Promise<WorkflowTriggerCategoryDto[]>;
+    /**
+     * Crea un nuovo workflow
+     */
+    createWorkflow(request: CreateWorkflowRequest): Promise<WorkflowDto>;
+    /**
+     * Ottiene un workflow per ID database
+     */
+    getWorkflowById(id: number): Promise<WorkflowDto>;
+    /**
+     * Ottiene un workflow per WorkflowId
+     */
+    getWorkflowByWorkflowId(workflowId: string): Promise<WorkflowDto>;
+    /**
+     * Ottiene tutti i workflow (summary)
+     */
+    listWorkflows(): Promise<WorkflowSummaryDto[]>;
+    /**
+     * Aggiorna un workflow esistente
+     */
+    updateWorkflow(id: number, request: UpdateWorkflowRequest): Promise<WorkflowDto>;
+    /**
+     * Elimina un workflow
+     */
+    deleteWorkflow(id: number): Promise<void>;
+    /**
+     * Attiva un workflow
+     */
+    activateWorkflow(id: number, updatedBy: string): Promise<WorkflowDto>;
+    /**
+     * Disattiva un workflow
+     */
+    deactivateWorkflow(id: number, updatedBy: string): Promise<WorkflowDto>;
+    /**
+     * Avvia un workflow con un trigger specifico
+     * @param workflowId - ID del workflow da avviare
+     * @param triggerId - ID del trigger da utilizzare
+     * @param inputs - Inputs per il trigger (opzionale)
+     */
+    startWorkflow(workflowId: number, triggerId: string, inputs?: Record<string, any>): Promise<{
+        executionId: string;
+    }>;
+    /**
+     * Clona un workflow
+     */
+    cloneWorkflow(id: number, request: CloneWorkflowRequest): Promise<WorkflowDto>;
+    /**
+     * Valida uno schema ReactFlow
+     */
+    validateWorkflow(schema: WorkflowReactFlowSchema): Promise<WorkflowValidationResult>;
+    /**
+     * Converte uno schema ReactFlow in WorkflowCore JSON
+     */
+    convertToWorkflowCore(schema: WorkflowReactFlowSchema): Promise<ConvertToWorkflowCoreResponse>;
+    /**
+     * Converte un WorkflowCore JSON in schema ReactFlow
+     */
+    convertToReactFlow(request: ConvertToReactFlowRequest): Promise<WorkflowReactFlowSchema>;
+    /**
+     * @deprecated Use validateWorkflow instead
+     */
     test(workflow: Workflow): Promise<void>;
+    /**
+     * Ottiene tutte le esecuzioni di un workflow specifico
+     */
+    getWorkflowExecutions(workflowId: number): Promise<WorkflowExecutionSummaryDto[]>;
+    /**
+     * Ottiene i dettagli completi di un'esecuzione
+     */
+    getExecutionDetails(instanceId: string): Promise<WorkflowExecutionDetailsDto>;
+    /**
+     * Ottiene solo gli step di un'esecuzione
+     */
+    getExecutionSteps(instanceId: string): Promise<WorkflowExecutionStepDto[]>;
+    /**
+     * Ottiene solo gli errori di un'esecuzione
+     */
+    getExecutionErrors(instanceId: string): Promise<WorkflowExecutionErrorDto[]>;
+    /**
+     * Termina un'esecuzione in corso
+     */
+    terminateExecution(instanceId: string): Promise<void>;
+    /**
+     * Sospende un'esecuzione in corso
+     */
+    suspendExecution(instanceId: string): Promise<void>;
+    /**
+     * Riprende un'esecuzione sospesa
+     */
+    resumeExecution(instanceId: string): Promise<void>;
+    saveEtlPipeline(request: SavePipelineRequest): Promise<SavePipelineResponse>;
+    listEtlPipelines(): Promise<PipelineListItem[]>;
+    getEtlPipeline(id: string): Promise<PipelineDetails>;
+    deleteEtlPipeline(id: string): Promise<void>;
+    executeSavedEtlPipeline(pipelineId: string, request?: ExecuteSavedPipelineRequest): Promise<PipelineResult>;
+    getEtlPipelineExecutions(pipelineId: string): Promise<PipelineExecutionHistoryItem[]>;
+    getEtlExecutionDetails(executionId: string): Promise<PipelineExecutionDetails>;
+    getRunningEtlExecutions(): Promise<RunningExecutionItem[]>;
+    stopEtlExecution(executionId: string): Promise<StopExecutionResponse>;
+    validateEtlPipeline(request: ValidatePipelineRequest): Promise<ValidationResult>;
+    executeEtlPipeline(request: ExecutePipelineRequest): Promise<PipelineResult>;
+    dryRunEtlPipeline(request: ExecutePipelineRequest): Promise<PipelineResult>;
 }

package/src/lib/workflow/models/action-category-definition.d.ts

@@ -1,5 +0,0 @@
-import { ActionDefinition } from "./action-definition";
-export interface ActionCategoryDefinition {
-    name: string;
-    actions: ActionDefinition[];
-}

package/src/lib/workflow/models/action-definition.d.ts

@@ -1,11 +0,0 @@
-import { ActionInputDefinition } from "./action-input-definition";
-import { ActionOutputDefinition } from "./action-output-definition";
-export interface ActionDefinition {
-    id: string;
-    category: string;
-    name: string;
-    type: string;
-    inputs: ActionInputDefinition[];
-    outputs: ActionOutputDefinition[];
-    outcomes: string[];
-}

package/src/lib/workflow/models/action-input-definition.d.ts

@@ -1,8 +0,0 @@
-export interface ActionInputDefinition {
-    name: string;
-    type: string;
-    required: boolean;
-    uiHint: string;
-    displayName: null | string;
-    optionsProviderType: null | string;
-}

package/src/lib/workflow/models/action-output-definition.d.ts

@@ -1,4 +0,0 @@
-export interface ActionOutputDefinition {
-    name: string;
-    type: string;
-}

package/src/lib/workflow/models/trigger-category-definition.d.ts

@@ -1,5 +0,0 @@
-import { TriggerDefinition } from "./trigger-definition";
-export interface TriggerCategoryDefinition {
-    name: string;
-    triggers: TriggerDefinition[];
-}

package/src/lib/workflow/models/trigger-definition.d.ts

@@ -1,10 +0,0 @@
-import { ActionInputDefinition } from "./action-input-definition";
-import { ActionOutputDefinition } from "./action-output-definition";
-export interface TriggerDefinition {
-    id: string;
-    category: string;
-    name: string;
-    type: string;
-    inputs: ActionInputDefinition[];
-    outputs: ActionOutputDefinition[];
-}

package/src/lib/workflow/models/workflow-action-input-type.d.ts

@@ -1,6 +0,0 @@
-export declare enum WorkflowActionInputType {
-    none = 0,
-    manual = 1,
-    dynamic = 2,
-    expression = 3
-}

package/src/lib/workflow/models/workflow-action-input.d.ts

@@ -1,5 +0,0 @@
-import { WorkflowActionInputType } from "./workflow-action-input-type";
-export interface WorkflowActionInput {
-    type: WorkflowActionInputType;
-    value: string | undefined;
-}

package/src/lib/workflow/models/workflow-action.d.ts

@@ -1,16 +0,0 @@
-import { WorkflowActionInput } from "./workflow-action-input";
-export interface WorkflowAction {
-    id: string;
-    name: string;
-    color: string;
-    description: string;
-    type: string;
-    outcomes: string[];
-    nextActions: {
-        [outcome: string]: WorkflowAction;
-    };
-    parallelActions: WorkflowAction[];
-    inputs: {
-        [property: string]: WorkflowActionInput;
-    };
-}

package/src/lib/workflow/models/workflow-trigger.d.ts

@@ -1,11 +0,0 @@
-import { WorkflowActionInput } from "./workflow-action-input";
-export interface WorkflowTrigger {
-    id: string;
-    name: string;
-    color: string;
-    description: string;
-    type: string;
-    inputs: {
-        [property: string]: WorkflowActionInput;
-    };
-}

package/src/lib/workflow/models/workflow.d.ts

@@ -1,9 +0,0 @@
-import { WorkflowAction } from "./workflow-action";
-import { WorkflowTrigger } from "./workflow-trigger";
-export interface Workflow {
-    id: string;
-    description: string;
-    version: number;
-    trigger?: WorkflowTrigger;
-    firstAction?: WorkflowAction;
-}