@uipath/uipath-typescript 1.4.2 → 1.5.1

package/dist/maestro-processes/index.mjs

@@ -42,6 +42,108 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+/**
+ * Maps API field names (countOf*) to SDK field names (*Count) for InstanceStats,
+ * aligning naming with ElementStats and other count-suffixed conventions.
+ */
+const InstanceStatsMap = {
+    countOfAllInstances: 'totalCount',
+    countOfRunning: 'runningCount',
+    countOfTransitioning: 'transitioningCount',
+    countOfPaused: 'pausedCount',
+    countOfFaulted: 'faultedCount',
+    countOfCompleted: 'completedCount',
+    countOfCancelled: 'cancelledCount',
+    countOfDeleted: 'deletedCount'
+};
+
+/**
+ * Converts a UTC timestamp string (e.g., "5/8/2026 11:20:17 AM") to ISO 8601 UTC format.
+ * Returns the original value if parsing fails.
+ */
+/**
+ * Transforms data by renaming each key in `data` exactly once, using the
+ * mapping (`sourceField → targetField`). Keys not present in the mapping
+ * pass through unchanged. The original (pre-rename) key is dropped — the
+ * result contains only the renamed key.
+ *
+ * Each rename is independent. If the mapping happens to contain chained
+ * entries (`a → b` and `b → c`), they do NOT compose: a field named `a`
+ * in `data` becomes `b` (not `c`), because the renames are applied based
+ * on the original data's keys, not the running result.
+ *
+ * @param data The source data to transform
+ * @param fieldMapping Object mapping source field names to target field names
+ * @returns Transformed data with mapped field names
+ *
+ * @example
+ * ```typescript
+ * // Single object transformation
+ * const data = { id: '123', userName: 'john' };
+ * const mapping = { id: 'userId', userName: 'name' };
+ * const result = transformData(data, mapping);
+ * // result = { userId: '123', name: 'john' }
+ *
+ * // Array transformation
+ * const dataArray = [
+ *   { id: '123', userName: 'john' },
+ *   { id: '456', userName: 'jane' }
+ * ];
+ * const result = transformData(dataArray, mapping);
+ * // result = [
+ * //   { userId: '123', name: 'john' },
+ * //   { userId: '456', name: 'jane' }
+ * // ]
+ *
+ * // No chaining — `a → b` does not become `a → c` even if the map has `b → c`.
+ * transformData({ a: 1 }, { a: 'b', b: 'c' });
+ * // result = { b: 1 }
+ * ```
+ */
+function transformData(data, fieldMapping) {
+    // Pass null/undefined through unchanged — callers (e.g. AttachmentService.getById)
+    // may invoke this on optional fields that an OData `select` excluded.
+    if (data == null) {
+        return data;
+    }
+    // Handle array of objects
+    if (Array.isArray(data)) {
+        return data.map(item => transformData(item, fieldMapping));
+    }
+    // Walk the ORIGINAL data's keys, look up each in the mapping. One rename
+    // per data key — no mutation of an in-progress result, so chains can't form.
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const renamedKey = fieldMapping[key] ?? key;
+        result[renamedKey] = value;
+    }
+    return result;
+}
+/**
+ * Adds a prefix to specified keys in an object, returning a new object.
+ * Only the provided keys are prefixed; all others are left unchanged.
+ *
+ * @param obj The source object
+ * @param prefix The prefix to add (e.g., '$')
+ * @param keys The keys to prefix (e.g., ['expand', 'filter'])
+ * @returns A new object with specified keys prefixed
+ *
+ * @example
+ * addPrefixToKeys({ expand: 'a', foo: 1 }, '$', ['expand']) // { $expand: 'a', foo: 1 }
+ */
+function addPrefixToKeys(obj, prefix, keys) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (keys.includes(key)) {
+            result[`${prefix}${key}`] = value;
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
 /**
  * Base path constants for different services
  */
@@ -67,6 +169,7 @@ const MAESTRO_ENDPOINTS = {
         CANCEL: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/cancel`,
         PAUSE: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/pause`,
         RESUME: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/resume`,
+        RETRY: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/retry`,
     },
     INCIDENTS: {
         GET_ALL: `${PIMS_BASE}/api/v1/incidents/summary`,
@@ -87,8 +190,12 @@ const MAESTRO_ENDPOINTS = {
         INSTANCE_STATUS_BY_DATE: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/InstanceStatusByDate`,
         /** Top processes ranked by total duration */
         TOP_PROCESSES_BY_DURATION: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopProcessesByDuration`,
+        /** Instance stats (counts by status + duration percentiles) */
+        INSTANCE_COUNT_BY_STATUS: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/InstanceCountByStatus`,
         /** Element count by status for agentic instances (process and case) */
         ELEMENT_COUNT_BY_STATUS: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/ElementCountByStatus`,
+        /** Incident counts aggregated by time bucket for time-series charts */
+        INCIDENTS_BY_TIME_WINDOW: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/IncidentsByTimeWindow`,
     },
 };
 
@@ -117,7 +224,36 @@ function createProcessMethods(processData, service) {
                 throw new Error('Process key is undefined');
             if (!processData.packageId)
                 throw new Error('Package ID is undefined');
-            return service.getElementStats(processData.processKey, processData.packageId, startTime, endTime, packageVersion);
+            return service.getElementStats({
+                processKey: processData.processKey,
+                packageId: processData.packageId,
+                packageVersion,
+                startTime,
+                endTime,
+            });
+        },
+        getInstanceStats(startTime, endTime, packageVersion) {
+            if (!processData.processKey)
+                throw new Error('Process key is undefined');
+            if (!processData.packageId)
+                throw new Error('Package ID is undefined');
+            return service.getInstanceStats({
+                processKey: processData.processKey,
+                packageId: processData.packageId,
+                packageVersion,
+                startTime,
+                endTime,
+            });
+        },
+        getInstanceStatusTimeline(startTime, endTime, options) {
+            if (!processData.processKey)
+                throw new Error('Process key is undefined');
+            return service.getInstanceStatusTimeline(startTime, endTime, { ...options, processKeys: [processData.processKey] });
+        },
+        getIncidentsTimeline(startTime, endTime, options) {
+            if (!processData.processKey)
+                throw new Error('Process key is undefined');
+            return service.getIncidentsTimeline(startTime, endTime, { ...options, processKeys: [processData.processKey] });
         }
     };
 }
@@ -133,6 +269,242 @@ function createProcessWithMethods(processData, service) {
     return Object.assign({}, processData, methods);
 }
 
+/**
+ * Creates methods for a process instance
+ *
+ * @param instanceData - The process instance data (response from API)
+ * @param service - The process instance service instance
+ * @returns Object containing process instance methods
+ */
+function createProcessInstanceMethods(instanceData, service) {
+    return {
+        async cancel(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
+            return service.cancel(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async pause(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
+            return service.pause(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async resume(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
+            return service.resume(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async retry(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
+            return service.retry(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async getIncidents() {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
+            return service.getIncidents(instanceData.instanceId, instanceData.folderKey);
+        },
+        async getExecutionHistory() {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
+            return service.getExecutionHistory(instanceData.instanceId, instanceData.folderKey);
+        },
+        async getBpmn() {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
+            return service.getBpmn(instanceData.instanceId, instanceData.folderKey);
+        },
+        async getVariables(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
+            return service.getVariables(instanceData.instanceId, instanceData.folderKey, options);
+        }
+    };
+}
+/**
+ * Creates an actionable process instance by combining API process instance data with operational methods.
+ *
+ * @param instanceData - The process instance data from API
+ * @param service - The process instance service instance
+ * @returns A process instance object with added methods
+ */
+function createProcessInstanceWithMethods(instanceData, service) {
+    const methods = createProcessInstanceMethods(instanceData, service);
+    return Object.assign({}, instanceData, methods);
+}
+
+/**
+ * Process Incident Status
+ */
+var ProcessIncidentStatus;
+(function (ProcessIncidentStatus) {
+    ProcessIncidentStatus["Open"] = "Open";
+    ProcessIncidentStatus["Closed"] = "Closed";
+})(ProcessIncidentStatus || (ProcessIncidentStatus = {}));
+/**
+ * Process Incident Type
+ */
+var ProcessIncidentType;
+(function (ProcessIncidentType) {
+    ProcessIncidentType["System"] = "System";
+    ProcessIncidentType["User"] = "User";
+    ProcessIncidentType["Deployment"] = "Deployment";
+})(ProcessIncidentType || (ProcessIncidentType = {}));
+/**
+ * Process Incident Severity
+ */
+var ProcessIncidentSeverity;
+(function (ProcessIncidentSeverity) {
+    ProcessIncidentSeverity["Error"] = "Error";
+    ProcessIncidentSeverity["Warning"] = "Warning";
+})(ProcessIncidentSeverity || (ProcessIncidentSeverity = {}));
+/**
+ * Process Incident Debug Mode
+ */
+var DebugMode;
+(function (DebugMode) {
+    DebugMode["None"] = "None";
+    DebugMode["Default"] = "Default";
+    DebugMode["StepByStep"] = "StepByStep";
+    DebugMode["SingleStep"] = "SingleStep";
+})(DebugMode || (DebugMode = {}));
+
+/**
+ * Case Instance Types
+ * Types and interfaces for Maestro case instance management
+ */
+/**
+ * SLA status for a case instance
+ */
+var SlaSummaryStatus;
+(function (SlaSummaryStatus) {
+    /** Case is within SLA deadline */
+    SlaSummaryStatus["ON_TRACK"] = "On Track";
+    /** Case is approaching SLA deadline based on at-risk percentage threshold */
+    SlaSummaryStatus["AT_RISK"] = "At Risk";
+    /** Case has exceeded SLA deadline */
+    SlaSummaryStatus["OVERDUE"] = "Overdue";
+    /** Case instance has completed */
+    SlaSummaryStatus["COMPLETED"] = "Completed";
+    /** SLA status cannot be determined (no SLA deadline defined) */
+    SlaSummaryStatus["UNKNOWN"] = "Unknown";
+})(SlaSummaryStatus || (SlaSummaryStatus = {}));
+/**
+ * Instance status values for case instances and process instances
+ */
+var InstanceStatus;
+(function (InstanceStatus) {
+    /** Instance status not yet populated by the backend */
+    InstanceStatus["UNKNOWN"] = "";
+    InstanceStatus["CANCELLED"] = "Cancelled";
+    InstanceStatus["CANCELING"] = "Canceling";
+    InstanceStatus["COMPLETED"] = "Completed";
+    InstanceStatus["FAULTED"] = "Faulted";
+    InstanceStatus["PAUSED"] = "Paused";
+    InstanceStatus["PAUSING"] = "Pausing";
+    InstanceStatus["PENDING"] = "Pending";
+    InstanceStatus["RESUMING"] = "Resuming";
+    InstanceStatus["RETRYING"] = "Retrying";
+    InstanceStatus["RUNNING"] = "Running";
+    InstanceStatus["UPGRADING"] = "Upgrading";
+})(InstanceStatus || (InstanceStatus = {}));
+/**
+ * Case stage task type
+ */
+var StageTaskType;
+(function (StageTaskType) {
+    StageTaskType["EXTERNAL_AGENT"] = "external-agent";
+    StageTaskType["RPA"] = "rpa";
+    StageTaskType["AGENTIC_PROCESS"] = "process";
+    StageTaskType["AGENT"] = "agent";
+    StageTaskType["ACTION"] = "action";
+    StageTaskType["API_WORKFLOW"] = "api-workflow";
+})(StageTaskType || (StageTaskType = {}));
+/**
+ * Escalation recipient scope
+ */
+var EscalationRecipientScope;
+(function (EscalationRecipientScope) {
+    EscalationRecipientScope["USER"] = "user";
+    EscalationRecipientScope["USER_GROUP"] = "usergroup";
+})(EscalationRecipientScope || (EscalationRecipientScope = {}));
+/**
+ * Escalation action type
+ */
+var EscalationActionType;
+(function (EscalationActionType) {
+    EscalationActionType["NOTIFICATION"] = "notification";
+})(EscalationActionType || (EscalationActionType = {}));
+/**
+ * Escalation rule trigger type
+ */
+var EscalationTriggerType;
+(function (EscalationTriggerType) {
+    EscalationTriggerType["SLA_BREACHED"] = "sla-breached";
+    EscalationTriggerType["AT_RISK"] = "at-risk";
+    /** Default value when no escalation rule is defined */
+    EscalationTriggerType["NONE"] = "None";
+})(EscalationTriggerType || (EscalationTriggerType = {}));
+/**
+ * SLA duration unit
+ */
+var SLADurationUnit;
+(function (SLADurationUnit) {
+    SLADurationUnit["HOURS"] = "h";
+    SLADurationUnit["DAYS"] = "d";
+    SLADurationUnit["WEEKS"] = "w";
+    SLADurationUnit["MONTHS"] = "m";
+})(SLADurationUnit || (SLADurationUnit = {}));
+
+/**
+ * Insights Types
+ * Shared types for Maestro insights analytics endpoints
+ */
+/**
+ * Time bucketing granularity for insights time-series queries.
+ *
+ * Controls how data points are grouped on the time axis.
+ */
+var TimeInterval;
+(function (TimeInterval) {
+    /** Group data points by hour */
+    TimeInterval["Hour"] = "HOUR";
+    /** Group data points by day */
+    TimeInterval["Day"] = "DAY";
+    /** Group data points by week */
+    TimeInterval["Week"] = "WEEK";
+})(TimeInterval || (TimeInterval = {}));
+/**
+ * Final instance statuses returned by the instance status timeline endpoint.
+ *
+ * Only includes statuses where the instance has finished execution — Completed, Faulted, or Cancelled.
+ * Active statuses like Running or Paused are not included.
+ */
+var InstanceFinalStatus;
+(function (InstanceFinalStatus) {
+    /** Instance completed successfully */
+    InstanceFinalStatus["Completed"] = "Completed";
+    /** Instance encountered an error */
+    InstanceFinalStatus["Faulted"] = "Faulted";
+    /** Instance was cancelled */
+    InstanceFinalStatus["Cancelled"] = "Cancelled";
+})(InstanceFinalStatus || (InstanceFinalStatus = {}));
+
 /**
  * Builds the request body for Insights RTM "top" endpoints.
  *
@@ -156,48 +528,46 @@ function buildInsightsTopBody(startTime, endTime, isCaseManagement, options) {
     };
 }
 /**
- * Fetches instance status timeline from the Insights API.
- * Shared implementation used by both MaestroProcessesService and CasesService.
+ * Builds the request body for Insights RTM timeline endpoints
+ * (`InstanceStatusByDate`, `IncidentsByTimeWindow`).
  *
- * @param postFn - Bound post method from a BaseService subclass
  * @param startTime - Start of the time range to query
  * @param endTime - End of the time range to query
  * @param isCaseManagement - Whether to filter for case management processes
- * @param options - Optional settings for time bucketing granularity
- * @returns Promise resolving to an array of instance status timeline entries
+ * @param options - Optional time bucketing and filtering settings
+ * @returns Request body for the Insights RTM timeline endpoint
  * @internal
  */
-async function fetchInstanceStatusTimeline(postFn, startTime, endTime, isCaseManagement, options) {
-    const response = await postFn(MAESTRO_ENDPOINTS.INSIGHTS.INSTANCE_STATUS_BY_DATE, {
+function buildInsightsTimelineBody(startTime, endTime, isCaseManagement, options) {
+    return {
         commonParams: {
             startTime: startTime.getTime(),
             endTime: endTime.getTime(),
             isCaseManagement,
+            ...(options?.packageId ? { packageId: options.packageId } : {}),
+            ...(options?.version ? { version: options.version } : {}),
+            ...(options?.processKeys ? { processKeys: options.processKeys } : {}),
         },
-        timeSliceUnit: options?.groupBy,
+        timeSliceUnit: options?.groupBy ?? TimeInterval.Day,
         timezoneOffset: new Date().getTimezoneOffset() * -1,
-    });
-    return response.data ?? [];
+    };
 }
 /**
- * Builds the request body for the ElementCountByStatus endpoint.
+ * Builds the commonParams request body for Insights RTM endpoints
+ * that filter by process key, package, time range, and version.
  *
- * @param processKey - Process key to filter by
- * @param packageId - Package identifier
- * @param startTime - Start of the time range to query
- * @param endTime - End of the time range to query
- * @param packageVersion - Package version to filter by
- * @returns Request body for the ElementCountByStatus endpoint
+ * @param request - Process scope + time range to aggregate over
+ * @returns Request body with commonParams
  * @internal
  */
-function buildElementCountByStatusBody(processKey, packageId, startTime, endTime, packageVersion) {
+function buildInsightsCommonBody(request) {
     return {
         commonParams: {
-            processKey,
-            packageId,
-            startTime: startTime.getTime(),
-            endTime: endTime.getTime(),
-            version: packageVersion
+            processKey: request.processKey,
+            packageId: request.packageId,
+            startTime: request.startTime.getTime(),
+            endTime: request.endTime.getTime(),
+            version: request.packageVersion
         }
     };
 }
@@ -256,77 +626,6 @@ const PROCESS_INSTANCE_TOKEN_PARAMS = {
     TOKEN_PARAM: 'nextPage'
 };
 
-/**
- * Converts a UTC timestamp string (e.g., "5/8/2026 11:20:17 AM") to ISO 8601 UTC format.
- * Returns the original value if parsing fails.
- */
-/**
- * Transforms data by mapping fields according to the provided field mapping
- * @param data The source data to transform
- * @param fieldMapping Object mapping source field names to target field names
- * @returns Transformed data with mapped field names
- *
- * @example
- * ```typescript
- * // Single object transformation
- * const data = { id: '123', userName: 'john' };
- * const mapping = { id: 'userId', userName: 'name' };
- * const result = transformData(data, mapping);
- * // result = { userId: '123', name: 'john' }
- *
- * // Array transformation
- * const dataArray = [
- *   { id: '123', userName: 'john' },
- *   { id: '456', userName: 'jane' }
- * ];
- * const result = transformData(dataArray, mapping);
- * // result = [
- * //   { userId: '123', name: 'john' },
- * //   { userId: '456', name: 'jane' }
- * // ]
- * ```
- */
-function transformData(data, fieldMapping) {
-    // Handle array of objects
-    if (Array.isArray(data)) {
-        return data.map(item => transformData(item, fieldMapping));
-    }
-    // Handle single object
-    const result = { ...data };
-    for (const [sourceField, targetField] of Object.entries(fieldMapping)) {
-        if (sourceField in result) {
-            const value = result[sourceField];
-            delete result[sourceField];
-            result[targetField] = value;
-        }
-    }
-    return result;
-}
-/**
- * Adds a prefix to specified keys in an object, returning a new object.
- * Only the provided keys are prefixed; all others are left unchanged.
- *
- * @param obj The source object
- * @param prefix The prefix to add (e.g., '$')
- * @param keys The keys to prefix (e.g., ['expand', 'filter'])
- * @returns A new object with specified keys prefixed
- *
- * @example
- * addPrefixToKeys({ expand: 'a', foo: 1 }, '$', ['expand']) // { $expand: 'a', foo: 1 }
- */
-function addPrefixToKeys(obj, prefix, keys) {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (keys.includes(key)) {
-            result[`${prefix}${key}`] = value;
-        }
-        else {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-
 /**
  * Maps fields for Incident entities
  */
@@ -1931,249 +2230,20 @@ class BaseService {
             case PaginationType.OFFSET:
                 const effectivePageSize = info.pageSize ?? DEFAULT_PAGE_SIZE;
                 // If totalCount is available, use it for precise calculation
-                if (info.totalCount !== undefined) {
-                    return (info.currentPage * effectivePageSize) < info.totalCount;
-                }
-                // Fallback when totalCount is not available
-                // NOTE: This code path should rarely be executed as the APIs typically return totalCount
-                return info.itemsCount === effectivePageSize;
-            case PaginationType.TOKEN:
-                return !!info.continuationToken;
-            default:
-                return false;
-        }
-    }
-}
-_BaseService_apiClient = new WeakMap();
-
-/**
- * Creates methods for a process instance
- *
- * @param instanceData - The process instance data (response from API)
- * @param service - The process instance service instance
- * @returns Object containing process instance methods
- */
-function createProcessInstanceMethods(instanceData, service) {
-    return {
-        async cancel(options) {
-            if (!instanceData.instanceId)
-                throw new Error('Process instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Process instance folder key is undefined');
-            return service.cancel(instanceData.instanceId, instanceData.folderKey, options);
-        },
-        async pause(options) {
-            if (!instanceData.instanceId)
-                throw new Error('Process instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Process instance folder key is undefined');
-            return service.pause(instanceData.instanceId, instanceData.folderKey, options);
-        },
-        async resume(options) {
-            if (!instanceData.instanceId)
-                throw new Error('Process instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Process instance folder key is undefined');
-            return service.resume(instanceData.instanceId, instanceData.folderKey, options);
-        },
-        async getIncidents() {
-            if (!instanceData.instanceId)
-                throw new Error('Process instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Process instance folder key is undefined');
-            return service.getIncidents(instanceData.instanceId, instanceData.folderKey);
-        },
-        async getExecutionHistory() {
-            if (!instanceData.instanceId)
-                throw new Error('Process instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Process instance folder key is undefined');
-            return service.getExecutionHistory(instanceData.instanceId, instanceData.folderKey);
-        },
-        async getBpmn() {
-            if (!instanceData.instanceId)
-                throw new Error('Process instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Process instance folder key is undefined');
-            return service.getBpmn(instanceData.instanceId, instanceData.folderKey);
-        },
-        async getVariables(options) {
-            if (!instanceData.instanceId)
-                throw new Error('Process instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Process instance folder key is undefined');
-            return service.getVariables(instanceData.instanceId, instanceData.folderKey, options);
+                if (info.totalCount !== undefined) {
+                    return (info.currentPage * effectivePageSize) < info.totalCount;
+                }
+                // Fallback when totalCount is not available
+                // NOTE: This code path should rarely be executed as the APIs typically return totalCount
+                return info.itemsCount === effectivePageSize;
+            case PaginationType.TOKEN:
+                return !!info.continuationToken;
+            default:
+                return false;
         }
-    };
-}
-/**
- * Creates an actionable process instance by combining API process instance data with operational methods.
- *
- * @param instanceData - The process instance data from API
- * @param service - The process instance service instance
- * @returns A process instance object with added methods
- */
-function createProcessInstanceWithMethods(instanceData, service) {
-    const methods = createProcessInstanceMethods(instanceData, service);
-    return Object.assign({}, instanceData, methods);
+    }
 }
-
-/**
- * Process Incident Status
- */
-var ProcessIncidentStatus;
-(function (ProcessIncidentStatus) {
-    ProcessIncidentStatus["Open"] = "Open";
-    ProcessIncidentStatus["Closed"] = "Closed";
-})(ProcessIncidentStatus || (ProcessIncidentStatus = {}));
-/**
- * Process Incident Type
- */
-var ProcessIncidentType;
-(function (ProcessIncidentType) {
-    ProcessIncidentType["System"] = "System";
-    ProcessIncidentType["User"] = "User";
-    ProcessIncidentType["Deployment"] = "Deployment";
-})(ProcessIncidentType || (ProcessIncidentType = {}));
-/**
- * Process Incident Severity
- */
-var ProcessIncidentSeverity;
-(function (ProcessIncidentSeverity) {
-    ProcessIncidentSeverity["Error"] = "Error";
-    ProcessIncidentSeverity["Warning"] = "Warning";
-})(ProcessIncidentSeverity || (ProcessIncidentSeverity = {}));
-/**
- * Process Incident Debug Mode
- */
-var DebugMode;
-(function (DebugMode) {
-    DebugMode["None"] = "None";
-    DebugMode["Default"] = "Default";
-    DebugMode["StepByStep"] = "StepByStep";
-    DebugMode["SingleStep"] = "SingleStep";
-})(DebugMode || (DebugMode = {}));
-
-/**
- * Case Instance Types
- * Types and interfaces for Maestro case instance management
- */
-/**
- * SLA status for a case instance
- */
-var SlaSummaryStatus;
-(function (SlaSummaryStatus) {
-    /** Case is within SLA deadline */
-    SlaSummaryStatus["ON_TRACK"] = "On Track";
-    /** Case is approaching SLA deadline based on at-risk percentage threshold */
-    SlaSummaryStatus["AT_RISK"] = "At Risk";
-    /** Case has exceeded SLA deadline */
-    SlaSummaryStatus["OVERDUE"] = "Overdue";
-    /** Case instance has completed */
-    SlaSummaryStatus["COMPLETED"] = "Completed";
-    /** SLA status cannot be determined (no SLA deadline defined) */
-    SlaSummaryStatus["UNKNOWN"] = "Unknown";
-})(SlaSummaryStatus || (SlaSummaryStatus = {}));
-/**
- * Instance status values for case instances and process instances
- */
-var InstanceStatus;
-(function (InstanceStatus) {
-    /** Instance status not yet populated by the backend */
-    InstanceStatus["UNKNOWN"] = "";
-    InstanceStatus["CANCELLED"] = "Cancelled";
-    InstanceStatus["CANCELING"] = "Canceling";
-    InstanceStatus["COMPLETED"] = "Completed";
-    InstanceStatus["FAULTED"] = "Faulted";
-    InstanceStatus["PAUSED"] = "Paused";
-    InstanceStatus["PAUSING"] = "Pausing";
-    InstanceStatus["PENDING"] = "Pending";
-    InstanceStatus["RESUMING"] = "Resuming";
-    InstanceStatus["RETRYING"] = "Retrying";
-    InstanceStatus["RUNNING"] = "Running";
-    InstanceStatus["UPGRADING"] = "Upgrading";
-})(InstanceStatus || (InstanceStatus = {}));
-/**
- * Case stage task type
- */
-var StageTaskType;
-(function (StageTaskType) {
-    StageTaskType["EXTERNAL_AGENT"] = "external-agent";
-    StageTaskType["RPA"] = "rpa";
-    StageTaskType["AGENTIC_PROCESS"] = "process";
-    StageTaskType["AGENT"] = "agent";
-    StageTaskType["ACTION"] = "action";
-    StageTaskType["API_WORKFLOW"] = "api-workflow";
-})(StageTaskType || (StageTaskType = {}));
-/**
- * Escalation recipient scope
- */
-var EscalationRecipientScope;
-(function (EscalationRecipientScope) {
-    EscalationRecipientScope["USER"] = "user";
-    EscalationRecipientScope["USER_GROUP"] = "usergroup";
-})(EscalationRecipientScope || (EscalationRecipientScope = {}));
-/**
- * Escalation action type
- */
-var EscalationActionType;
-(function (EscalationActionType) {
-    EscalationActionType["NOTIFICATION"] = "notification";
-})(EscalationActionType || (EscalationActionType = {}));
-/**
- * Escalation rule trigger type
- */
-var EscalationTriggerType;
-(function (EscalationTriggerType) {
-    EscalationTriggerType["SLA_BREACHED"] = "sla-breached";
-    EscalationTriggerType["AT_RISK"] = "at-risk";
-    /** Default value when no escalation rule is defined */
-    EscalationTriggerType["NONE"] = "None";
-})(EscalationTriggerType || (EscalationTriggerType = {}));
-/**
- * SLA duration unit
- */
-var SLADurationUnit;
-(function (SLADurationUnit) {
-    SLADurationUnit["HOURS"] = "h";
-    SLADurationUnit["DAYS"] = "d";
-    SLADurationUnit["WEEKS"] = "w";
-    SLADurationUnit["MONTHS"] = "m";
-})(SLADurationUnit || (SLADurationUnit = {}));
-
-/**
- * Insights Types
- * Shared types for Maestro insights analytics endpoints
- */
-/**
- * Time bucketing granularity for insights time-series queries.
- *
- * Controls how data points are grouped on the time axis.
- */
-var TimeInterval;
-(function (TimeInterval) {
-    /** Group data points by hour */
-    TimeInterval["Hour"] = "HOUR";
-    /** Group data points by day */
-    TimeInterval["Day"] = "DAY";
-    /** Group data points by week */
-    TimeInterval["Week"] = "WEEK";
-})(TimeInterval || (TimeInterval = {}));
-/**
- * Final instance statuses returned by the instance status timeline endpoint.
- *
- * Only includes statuses where the instance has finished execution — Completed, Faulted, or Cancelled.
- * Active statuses like Running or Paused are not included.
- */
-var InstanceFinalStatus;
-(function (InstanceFinalStatus) {
-    /** Instance completed successfully */
-    InstanceFinalStatus["Completed"] = "Completed";
-    /** Instance encountered an error */
-    InstanceFinalStatus["Faulted"] = "Faulted";
-    /** Instance was cancelled */
-    InstanceFinalStatus["Cancelled"] = "Cancelled";
-})(InstanceFinalStatus || (InstanceFinalStatus = {}));
+_BaseService_apiClient = new WeakMap();
 
 /**
  * Maps fields for Process Instance entities to ensure consistent naming
@@ -2250,7 +2320,7 @@ class ProcessInstancesService extends BaseService {
         }, options);
     }
     /**
-     * Get a process instance by ID with operation methods (cancel, pause, resume)
+     * Get a process instance by ID with operation methods (cancel, pause, resume, retry)
      * @param id The ID of the instance to retrieve
      * @param folderKey The folder key for authorization
      * @returns Promise<ProcessInstanceGetResponse>
@@ -2389,6 +2459,25 @@ class ProcessInstancesService extends BaseService {
             data: response.data
         };
     }
+    /**
+     * Retry a faulted process instance
+     *
+     * Re-runs the failed elements of the instance (and the elements that follow) within
+     * the same instance, spawning new jobs. Use to recover from transient/flaky failures.
+     * @param instanceId The ID of the instance to retry
+     * @param folderKey The folder key for authorization
+     * @param options Optional retry options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    async retry(instanceId, folderKey, options) {
+        const response = await this.post(MAESTRO_ENDPOINTS.INSTANCES.RETRY(instanceId), options || {}, {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        return {
+            success: true,
+            data: response.data
+        };
+    }
     /**
      * Parses BPMN XML to extract variable metadata from uipath:inputOutput elements
      * @private
@@ -2539,6 +2628,9 @@ __decorate([
 __decorate([
     track('ProcessInstances.Resume')
 ], ProcessInstancesService.prototype, "resume", null);
+__decorate([
+    track('ProcessInstances.Retry')
+], ProcessInstancesService.prototype, "retry", null);
 __decorate([
     track('ProcessInstances.GetVariables')
 ], ProcessInstancesService.prototype, "getVariables", null);
@@ -2695,7 +2787,7 @@ class MaestroProcessesService extends BaseService {
      *
      * @param startTime - Start of the time range to query
      * @param endTime - End of the time range to query
-     * @param options - Optional settings for time bucketing granularity
+     * @param options - Optional settings for filtering and time bucket granularity
      * @returns Promise resolving to an array of {@link InstanceStatusTimelineResponse}
      *
      * @example
@@ -2722,12 +2814,67 @@ class MaestroProcessesService extends BaseService {
      *
      * @example
      * ```typescript
+     * // Filter to a specific process
+     * const filtered = await maestroProcesses.getInstanceStatusTimeline(startTime, endTime, {
+     *   processKeys: ['<processKey>'],
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
      * // Get all-time data (from Unix epoch to now)
      * const allTime = await maestroProcesses.getInstanceStatusTimeline(new Date(0), new Date());
      * ```
      */
     async getInstanceStatusTimeline(startTime, endTime, options) {
-        return fetchInstanceStatusTimeline(this.post.bind(this), startTime, endTime, false, options);
+        const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.INSTANCE_STATUS_BY_DATE, buildInsightsTimelineBody(startTime, endTime, false, options));
+        return data ?? [];
+    }
+    /**
+     * Get incident counts aggregated by time bucket for maestro processes.
+     *
+     * Returns time-grouped counts of incidents that occurred within each bucket,
+     * useful for rendering incident time-series charts. Use `groupBy` to control
+     * the time bucket size (hour, day, or week) — defaults to day if not provided.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional settings for filtering and time bucket granularity
+     * @returns Promise resolving to an array of {@link IncidentTimelineResponse}
+     *
+     * @example
+     * ```typescript
+     * // Get daily incident counts for the last 7 days
+     * const now = new Date();
+     * const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+     * const incidents = await maestroProcesses.getIncidentsTimeline(sevenDaysAgo, now);
+     *
+     * for (const incident of incidents) {
+     *   console.log(`${incident.startTime} → ${incident.endTime}: ${incident.count} incidents`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * import { TimeInterval } from '@uipath/uipath-typescript/maestro-processes';
+     *
+     * // Get weekly breakdown
+     * const incidents = await maestroProcesses.getIncidentsTimeline(startTime, endTime, {
+     *   groupBy: TimeInterval.Week,
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Filter to a specific process
+     * const filtered = await maestroProcesses.getIncidentsTimeline(startTime, endTime, {
+     *   processKeys: ['<processKey>'],
+     * });
+     * ```
+     */
+    async getIncidentsTimeline(startTime, endTime, options) {
+        const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.INCIDENTS_BY_TIME_WINDOW, buildInsightsTimelineBody(startTime, endTime, false, options));
+        return data?.dataPoints ?? [];
     }
     /**
      * Get the top 10 processes ranked by failure count within a time range.
@@ -2822,22 +2969,22 @@ class MaestroProcessesService extends BaseService {
      * Returns per-element execution counts (success, fail, terminated, paused, in-progress) and
      * duration percentile metrics (min, max, avg, p50, p95, p99) for BPMN elements within a process.
      *
-     * @param processKey - Process key to filter by
-     * @param packageId - Package identifier
-     * @param startTime - Start of the time range to query
-     * @param endTime - End of the time range to query
-     * @param packageVersion - Package version to filter by
+     * @param request - Process scope + time range to aggregate over
      * @returns Promise resolving to an array of {@link ElementStats}
      * @example
      * ```typescript
-     * // Get element metrics for a process
-     * const elements = await maestroProcesses.getElementStats(
-     *   '<processKey>',
-     *   '<packageId>',
-     *   new Date('2026-04-01'),
-     *   new Date(),
-     *   '1.0.1'
-     * );
+     * // First, list processes to find the processKey, packageId, and available versions
+     * const processes = await maestroProcesses.getAll();
+     * const process = processes[0];
+     *
+     * // Get element metrics for that process
+     * const elements = await maestroProcesses.getElementStats({
+     *   processKey: process.processKey,
+     *   packageId: process.packageId,
+     *   packageVersion: process.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
      *
      * // Analyze element performance
      * for (const element of elements) {
@@ -2845,12 +2992,58 @@ class MaestroProcessesService extends BaseService {
      *   console.log(`  Success: ${element.successCount}, Failed: ${element.failCount}`);
      *   console.log(`  Avg duration: ${element.avgDurationMs}ms, P95: ${element.p95DurationMs}ms`);
      * }
+     *
+     * // Using bound method on a process — auto-fills processKey and packageId
+     * const boundElements = await process.getElementStats(
+     *   new Date('2026-04-01'),
+     *   new Date(),
+     *   process.packageVersions[0]
+     * );
      * ```
      */
-    async getElementStats(processKey, packageId, startTime, endTime, packageVersion) {
-        const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.ELEMENT_COUNT_BY_STATUS, buildElementCountByStatusBody(processKey, packageId, startTime, endTime, packageVersion));
+    async getElementStats(request) {
+        const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.ELEMENT_COUNT_BY_STATUS, buildInsightsCommonBody(request));
         return data ?? [];
     }
+    /**
+     * Get instance stats for a process.
+     *
+     * Returns total instance counts broken down by status (running, completed, faulted, etc.)
+     * and the average execution duration for all instances of a process within a time range.
+     *
+     * @param request - Process scope + time range to aggregate over
+     * @returns Promise resolving to {@link InstanceStats}
+     * @example
+     * ```typescript
+     * // First, list processes to find the processKey, packageId, and available versions
+     * const processes = await maestroProcesses.getAll();
+     * const process = processes[0];
+     *
+     * // Get instance status breakdown for that process
+     * const counts = await maestroProcesses.getInstanceStats({
+     *   processKey: process.processKey,
+     *   packageId: process.packageId,
+     *   packageVersion: process.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
+     *
+     * console.log(`Total: ${counts.totalCount}`);
+     * console.log(`Running: ${counts.runningCount}, Completed: ${counts.completedCount}`);
+     * console.log(`Faulted: ${counts.faultedCount}, Avg duration: ${counts.avgDurationMs}ms`);
+     *
+     * // Using bound method on a process — auto-fills processKey and packageId
+     * const boundCounts = await process.getInstanceStats(
+     *   new Date('2026-04-01'),
+     *   new Date(),
+     *   process.packageVersions[0]
+     * );
+     * ```
+     */
+    async getInstanceStats(request) {
+        const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.INSTANCE_COUNT_BY_STATUS, buildInsightsCommonBody(request));
+        return transformData(data, InstanceStatsMap);
+    }
 }
 __decorate([
     track('MaestroProcesses.GetAll')
@@ -2867,6 +3060,9 @@ __decorate([
 __decorate([
     track('MaestroProcesses.GetInstanceStatusTimeline')
 ], MaestroProcessesService.prototype, "getInstanceStatusTimeline", null);
+__decorate([
+    track('MaestroProcesses.GetIncidentsTimeline')
+], MaestroProcessesService.prototype, "getIncidentsTimeline", null);
 __decorate([
     track('MaestroProcesses.GetTopFaultedCount')
 ], MaestroProcessesService.prototype, "getTopFaultedCount", null);
@@ -2876,6 +3072,9 @@ __decorate([
 __decorate([
     track('MaestroProcesses.GetElementStats')
 ], MaestroProcessesService.prototype, "getElementStats", null);
+__decorate([
+    track('MaestroProcesses.GetInstanceStats')
+], MaestroProcessesService.prototype, "getInstanceStats", null);
 
 /**
  * Service class for Maestro Process Incidents