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

package/index.cjs.js

@@ -2667,6 +2667,10 @@ let HttpClient$1 = class HttpClient {
       return config;
     }));
     this._axiosInstance.interceptors.response.use(response => response.data, error => {
+      if (error.code === 'ERR_NETWORK') return Promise.reject({
+        code: "ERR_NETWORK",
+        message: "Il server non è raggiungibile."
+      });
       if (error.response.status === 401) ;
       return Promise.reject({
         code: error.response.status,
@@ -4167,7 +4171,8 @@ class AuthService {
       userId,
       canChangePassword: info.canChangePassword,
       canHandle2FA: info.canHandle2FA,
-      canHandleAccessTokens: info.canHandleAccessTokens
+      canHandleAccessTokens: info.canHandleAccessTokens,
+      canDisable2FA: info.canDisable2FA
     }, {
       withCredentials: true
     }).then(() => {
@@ -5376,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 {
@@ -9698,6 +10005,8 @@ class SessionHubService {
     this.eventHandlers = new Map();
     this.reconnectTimeoutId = null;
     this.isManualStop = false; // Flag to prevent reconnection after manual stop (e.g., logout)
+    this.hasReachedMaxAttempts = false; // Flag to track if max attempts reached
+    this.useAutomaticReconnect = true; // Flag to control automatic reconnection behavior
     this.hubUrl = `${baseUrl}/ws/session`;
     this.getAccessToken = getAccessToken;
   }
@@ -9723,27 +10032,50 @@ class SessionHubService {
         const deviceId = DeviceIdManager.getDeviceId();
         // Aggiungi device-id come query parameter all'URL
         const hubUrlWithDeviceId = `${this.hubUrl}?deviceId=${encodeURIComponent(deviceId)}`;
-        this.connection = new HubConnectionBuilder().withUrl(hubUrlWithDeviceId, {
+        const builder = new HubConnectionBuilder().withUrl(hubUrlWithDeviceId, {
           accessTokenFactory: () => this.getAccessToken(),
           transport: HttpTransportType.WebSockets,
           withCredentials: false
-        }).withAutomaticReconnect({
-          nextRetryDelayInMilliseconds: retryContext => {
-            // Exponential backoff: 0, 2, 10, 30 seconds, then 30 seconds
-            if (retryContext.previousRetryCount === 0) return 0;
-            if (retryContext.previousRetryCount === 1) return 2000;
-            if (retryContext.previousRetryCount === 2) return 10000;
-            return 30000;
-          }
-        }).configureLogging(LogLevel.Information).build();
+        });
+        // Conditionally add automatic reconnect based on flag
+        if (this.useAutomaticReconnect) {
+          builder.withAutomaticReconnect({
+            nextRetryDelayInMilliseconds: retryContext => {
+              // Track attempts using SignalR's counter
+              this.reconnectAttempts = retryContext.previousRetryCount + 1;
+              // Stop after max attempts
+              if (retryContext.previousRetryCount >= this.maxReconnectAttempts) {
+                console.warn(`SessionHub: Max automatic reconnection attempts (${this.maxReconnectAttempts}) reached`);
+                this.hasReachedMaxAttempts = true;
+                this.useAutomaticReconnect = false; // Disable for next connection
+                return null; // Stop automatic reconnection
+              }
+              // Exponential backoff: 0, 2, 10 seconds, then 5 seconds
+              if (retryContext.previousRetryCount === 0) return 0;
+              if (retryContext.previousRetryCount === 1) return 2000;
+              if (retryContext.previousRetryCount === 2) return 10000;
+              return this.reconnectDelay;
+            }
+          });
+        }
+        this.connection = builder.configureLogging(LogLevel.Information).build();
         this.setupConnectionHandlers();
         this.reattachEventHandlers();
         yield this.connection.start();
         console.info('SessionHub: Connection established successfully with device-id:', deviceId);
         this.reconnectAttempts = 0;
+        this.hasReachedMaxAttempts = false;
+        // Re-enable automatic reconnect for future disconnections
+        this.useAutomaticReconnect = true;
       } catch (error) {
         console.error('SessionHub: Error starting connection', error);
-        this.scheduleReconnect();
+        // Only schedule reconnect if in automatic mode
+        if (this.useAutomaticReconnect && !this.hasReachedMaxAttempts) {
+          this.scheduleReconnect();
+        } else {
+          // Manual mode: just set flag for UI
+          this.hasReachedMaxAttempts = true;
+        }
       }
     });
   }
@@ -9861,6 +10193,51 @@ class SessionHubService {
     var _a, _b;
     return (_b = (_a = this.connection) === null || _a === void 0 ? void 0 : _a.connectionId) !== null && _b !== void 0 ? _b : null;
   }
+  /**
+   * Get current reconnection attempts count
+   */
+  get currentReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+  /**
+   * Get max reconnection attempts limit
+   */
+  get maxReconnectAttemptsLimit() {
+    return this.maxReconnectAttempts;
+  }
+  /**
+   * Check if max reconnection attempts have been reached
+   */
+  get hasReachedMaxReconnectAttempts() {
+    return this.hasReachedMaxAttempts;
+  }
+  /**
+   * Manually retry connection - performs single connection attempt without automatic retries
+   * User must click retry button again if connection fails
+   */
+  manualRetry() {
+    return __awaiter(this, void 0, void 0, function* () {
+      console.info('SessionHub: Manual retry initiated by user');
+      // Reset counters and flags
+      this.reconnectAttempts = 0;
+      this.hasReachedMaxAttempts = false;
+      this.isManualStop = false;
+      this.useAutomaticReconnect = false; // Force manual mode - no automatic retries
+      // Cancel any pending reconnection attempt
+      if (this.reconnectTimeoutId) {
+        clearTimeout(this.reconnectTimeoutId);
+        this.reconnectTimeoutId = null;
+      }
+      // Attempt to start connection (will be without automatic reconnect)
+      try {
+        yield this.start();
+      } catch (error) {
+        console.error('SessionHub: Manual retry failed', error);
+        // Set flag so UI shows retry button again
+        this.hasReachedMaxAttempts = true;
+      }
+    });
+  }
   /**
    * Setup connection lifecycle handlers
    */
@@ -9868,14 +10245,30 @@ class SessionHubService {
     if (!this.connection) return;
     this.connection.onclose(error => {
       console.warn('SessionHub: Connection closed', error);
-      this.scheduleReconnect();
+      // Don't schedule reconnect if in manual mode - user must click retry button
+      if (!this.useAutomaticReconnect) {
+        console.info('SessionHub: In manual mode - waiting for user to retry');
+        this.hasReachedMaxAttempts = true;
+        return;
+      }
+      // In automatic mode, check if we've reached max attempts
+      if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+        console.error('SessionHub: Max reconnection attempts reached');
+        this.hasReachedMaxAttempts = true;
+        this.useAutomaticReconnect = false;
+      } else {
+        // Schedule next reconnect attempt
+        this.scheduleReconnect();
+      }
     });
     this.connection.onreconnecting(error => {
-      console.warn('SessionHub: Attempting to reconnect...', error);
+      console.warn(`SessionHub: Attempting to reconnect... (attempt ${this.reconnectAttempts} of ${this.maxReconnectAttempts})`, error);
     });
     this.connection.onreconnected(connectionId => {
       console.info(`SessionHub: Reconnected successfully. ConnectionId: ${connectionId}`);
       this.reconnectAttempts = 0;
+      this.hasReachedMaxAttempts = false;
+      this.useAutomaticReconnect = true; // Re-enable automatic reconnect
     });
   }
   /**
@@ -9900,6 +10293,8 @@ class SessionHubService {
     }
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
       console.error('SessionHub: Max reconnection attempts reached. Giving up.');
+      this.hasReachedMaxAttempts = true;
+      this.useAutomaticReconnect = false; // Disable automatic reconnect
       return;
     }
     this.reconnectAttempts++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluxo-dev/api-client-base",
-  "version": "25.4.3",
+  "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": "^25.4.3"
+    "@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/session-hub/session-hub.service.d.ts

@@ -13,6 +13,8 @@ export declare class SessionHubService {
     private eventHandlers;
     private reconnectTimeoutId;
     private isManualStop;
+    private hasReachedMaxAttempts;
+    private useAutomaticReconnect;
     constructor(baseUrl: string, getAccessToken: () => string);
     getConnectedUsers(): Promise<{
         userId: string;
@@ -75,6 +77,23 @@ export declare class SessionHubService {
      * Get the connection ID
      */
     get connectionId(): string | null;
+    /**
+     * Get current reconnection attempts count
+     */
+    get currentReconnectAttempts(): number;
+    /**
+     * Get max reconnection attempts limit
+     */
+    get maxReconnectAttemptsLimit(): number;
+    /**
+     * Check if max reconnection attempts have been reached
+     */
+    get hasReachedMaxReconnectAttempts(): boolean;
+    /**
+     * Manually retry connection - performs single connection attempt without automatic retries
+     * User must click retry button again if connection fails
+     */
+    manualRetry(): Promise<void>;
     /**
      * Setup connection lifecycle handlers
      */