@uipath/uipath-typescript 1.5.0 → 1.5.1

package/dist/index.umd.js

@@ -4625,6 +4625,7 @@
             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`,
@@ -4658,6 +4659,8 @@
             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`,
         },
     };
 
@@ -4707,6 +4710,14 @@
             UPDATE_BY_NAME: (choiceSetName, valueId) => `${DATAFABRIC_BASE}/api/EntityService/${choiceSetName}/choiceset/${valueId}/update`,
             DELETE_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/choiceset/delete`,
         },
+        ROLES: {
+            GET_ALL: `${DATAFABRIC_BASE}/api/v2/Role`,
+        },
+        DIRECTORY: {
+            GET_ALL: `${DATAFABRIC_BASE}/api/Directory`,
+            ASSIGN_ROLES: `${DATAFABRIC_BASE}/api/Directory/Role`,
+            REVOKE_ROLES: `${DATAFABRIC_BASE}/api/Directory/RevokeRole`,
+        },
     };
 
     /**
@@ -9113,7 +9124,7 @@
      * SDK's public API.
      */
     /** SDK version placeholder — patched by the SDK publish workflow. */
-    const SDK_VERSION = '1.5.0';
+    const SDK_VERSION = '1.5.1';
     const CLOUD_ROLE_NAME = 'uipath-ts-sdk';
     const SDK_SERVICE_NAME = 'UiPath.TypeScript.Sdk';
     const SDK_LOGGER_NAME = 'uipath-ts-sdk-telemetry';
@@ -14050,6 +14061,419 @@
         track('Choicesets.DeleteValuesById')
     ], ChoiceSetService.prototype, "deleteValuesById", null);
 
+    /**
+     * @internal
+     */
+    var DataFabricRoleType;
+    (function (DataFabricRoleType) {
+        DataFabricRoleType["System"] = "System";
+        DataFabricRoleType["UserDefined"] = "UserDefined";
+    })(DataFabricRoleType || (DataFabricRoleType = {}));
+
+    function isRecord$1(value) {
+        return value !== null && typeof value === 'object' && !Array.isArray(value);
+    }
+    function isDataFabricRole(value) {
+        if (!isRecord$1(value)) {
+            return false;
+        }
+        const { id, name, type, directoryEntityCount, folderId } = value;
+        const hasValidDirectoryEntityCount = directoryEntityCount === undefined ||
+            directoryEntityCount === null ||
+            typeof directoryEntityCount === 'number';
+        const hasValidFolderId = folderId === undefined || typeof folderId === 'string';
+        return typeof id === 'string' &&
+            typeof name === 'string' &&
+            (type === DataFabricRoleType.System || type === DataFabricRoleType.UserDefined) &&
+            hasValidDirectoryEntityCount &&
+            hasValidFolderId;
+    }
+    function validateRolesResponse(data) {
+        if (Array.isArray(data) && data.every(isDataFabricRole)) {
+            return data;
+        }
+        throw new ServerError({
+            message: 'Invalid Data Fabric roles response format.',
+        });
+    }
+    /**
+     * @internal
+     */
+    class DataFabricRoleService extends BaseService {
+        /**
+         * Lists Data Fabric access roles.
+         *
+         * Returns tenant Data Fabric roles such as Admin, Designer, DataWriter, and
+         * DataReader. Role IDs from this method can be passed to
+         * `DataFabricDirectoryService.assignRoles()`.
+         *
+         * @param options - Optional query options
+         * @returns Promise resolving to an array of {@link DataFabricRole}
+         *
+         * @example
+         * ```typescript
+         * import { DataFabricRoleService } from '@uipath/uipath-typescript/entities';
+         *
+         * const roles = new DataFabricRoleService(sdk);
+         * const allRoles = await roles.getAll();
+         * const dataWriter = allRoles.find(role => role.name === 'DataWriter');
+         * ```
+         *
+         * @example
+         * ```typescript
+         * const rolesWithoutStats = await roles.getAll({ stats: false });
+         * ```
+         *
+         * @example
+         * ```typescript
+         * const folderRoles = await roles.getAll({ folderKey: '<folder-key>' });
+         * ```
+         *
+         * @internal
+         */
+        async getAll(options = {}) {
+            const params = createParams({
+                stats: options.stats ?? true,
+            });
+            const headers = createHeaders({ [FOLDER_KEY]: options.folderKey });
+            const response = await this.get(DATA_FABRIC_ENDPOINTS.ROLES.GET_ALL, { params, headers });
+            return validateRolesResponse(response.data);
+        }
+    }
+    __decorate([
+        track('DataFabricRoles.GetAll')
+    ], DataFabricRoleService.prototype, "getAll", null);
+
+    /**
+     * @internal
+     */
+    var DataFabricDirectoryEntityType;
+    (function (DataFabricDirectoryEntityType) {
+        /** Identity user, robot user, or directory robot principal. */
+        DataFabricDirectoryEntityType[DataFabricDirectoryEntityType["User"] = 0] = "User";
+        /** Identity group principal. */
+        DataFabricDirectoryEntityType[DataFabricDirectoryEntityType["Group"] = 1] = "Group";
+        /** External application principal. */
+        DataFabricDirectoryEntityType[DataFabricDirectoryEntityType["Application"] = 2] = "Application";
+    })(DataFabricDirectoryEntityType || (DataFabricDirectoryEntityType = {}));
+    /**
+     * @internal
+     */
+    var DataFabricDirectoryEntityTypeName;
+    (function (DataFabricDirectoryEntityTypeName) {
+        DataFabricDirectoryEntityTypeName["User"] = "User";
+        DataFabricDirectoryEntityTypeName["Group"] = "Group";
+        DataFabricDirectoryEntityTypeName["Application"] = "Application";
+    })(DataFabricDirectoryEntityTypeName || (DataFabricDirectoryEntityTypeName = {}));
+
+    const DEFAULT_DIRECTORY_PAGE_SIZE = 100;
+    const MAX_DIRECTORY_PAGE_SIZE = 100;
+    function validateDirectoryListResponse(data) {
+        if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+            throw new ServerError({
+                message: 'Invalid Data Fabric directory response format.',
+            });
+        }
+        const response = data;
+        if (typeof response.totalCount !== 'number' || !Array.isArray(response.results)) {
+            throw new ServerError({
+                message: 'Invalid Data Fabric directory response format.',
+            });
+        }
+        return {
+            totalCount: response.totalCount,
+            results: response.results,
+        };
+    }
+    function isRecord(value) {
+        return value !== null && typeof value === 'object' && !Array.isArray(value);
+    }
+    function isDirectoryEntityTypeName(value) {
+        return value === DataFabricDirectoryEntityTypeName.User ||
+            value === DataFabricDirectoryEntityTypeName.Group ||
+            value === DataFabricDirectoryEntityTypeName.Application;
+    }
+    function isDirectoryRole(value) {
+        if (!isRecord(value)) {
+            return false;
+        }
+        return typeof value.id === 'string' && typeof value.name === 'string';
+    }
+    function normalizeDirectoryEntry(entry) {
+        if (!isRecord(entry) ||
+            typeof entry.externalId !== 'string' ||
+            typeof entry.name !== 'string' ||
+            !isDirectoryEntityTypeName(entry.type) ||
+            (entry.email !== undefined && entry.email !== null && typeof entry.email !== 'string') ||
+            (entry.objectType !== undefined && entry.objectType !== null && typeof entry.objectType !== 'string') ||
+            (entry.isUIEnabled !== undefined && typeof entry.isUIEnabled !== 'boolean') ||
+            (entry.roles !== undefined && entry.roles !== null && (!Array.isArray(entry.roles) || !entry.roles.every(isDirectoryRole)))) {
+            throw new ServerError({
+                message: 'Invalid Data Fabric directory entry response format.',
+            });
+        }
+        const normalized = {
+            externalId: entry.externalId,
+            name: entry.name,
+            type: entry.type,
+            roles: entry.roles ?? [],
+            isUIEnabled: entry.isUIEnabled ?? true,
+        };
+        if (entry.email !== undefined) {
+            normalized.email = entry.email;
+        }
+        if (entry.objectType !== undefined) {
+            normalized.objectType = entry.objectType;
+        }
+        return normalized;
+    }
+    function normalizePrincipalIds(principalIds) {
+        const ids = Array.isArray(principalIds) ? principalIds : [principalIds];
+        return [...new Set(ids.map(id => id.trim()).filter(Boolean))];
+    }
+    function normalizeRoleIds(roleIds) {
+        return [...new Set(roleIds.map(id => id.trim()).filter(Boolean))];
+    }
+    function normalizePrincipalType(type) {
+        if (typeof type === 'number') {
+            if (type === DataFabricDirectoryEntityType.User ||
+                type === DataFabricDirectoryEntityType.Group ||
+                type === DataFabricDirectoryEntityType.Application) {
+                return type;
+            }
+            throw new ValidationError({
+                message: 'Invalid Data Fabric principal type.',
+            });
+        }
+        switch (type) {
+            case DataFabricDirectoryEntityTypeName.User:
+                return DataFabricDirectoryEntityType.User;
+            case DataFabricDirectoryEntityTypeName.Group:
+                return DataFabricDirectoryEntityType.Group;
+            case DataFabricDirectoryEntityTypeName.Application:
+                return DataFabricDirectoryEntityType.Application;
+            default:
+                throw new ValidationError({
+                    message: 'Invalid Data Fabric principal type.',
+                });
+        }
+    }
+    function roleIdsFromEntry(entry) {
+        if (!entry) {
+            return [];
+        }
+        return normalizeRoleIds(entry.roles.map(role => role.id));
+    }
+    function clampDirectoryPageSize(pageSize) {
+        return Math.max(1, Math.min(pageSize ?? DEFAULT_DIRECTORY_PAGE_SIZE, MAX_DIRECTORY_PAGE_SIZE));
+    }
+    /**
+     * @internal
+     */
+    class DataFabricDirectoryService extends BaseService {
+        async fetchAllEntries(options = {}) {
+            const top = clampDirectoryPageSize(options.pageSize);
+            const entries = [];
+            let skip = 0;
+            while (true) {
+                const page = await this.list(skip === 0 ? { top } : { top, skip });
+                entries.push(...page.results);
+                if (page.results.length < top || (page.totalCount !== undefined && entries.length >= page.totalCount)) {
+                    return entries;
+                }
+                skip += top;
+            }
+        }
+        /**
+         * Lists one page of Data Fabric directory principals and their current roles.
+         *
+         * Returns directory entries with external IDs, principal metadata, and
+         * assigned Data Fabric roles.
+         *
+         * @param options - Optional offset paging options
+         * @returns Promise resolving to {@link DataFabricDirectoryListResponse}
+         *
+         * @example
+         * ```typescript
+         * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+         *
+         * const directory = new DataFabricDirectoryService(sdk);
+         * const page = await directory.list({ skip: 0, top: 50 });
+         * const firstPrincipal = page.results[0];
+         * ```
+         *
+         * @internal
+         */
+        async list(options = {}) {
+            const params = createParams({
+                skip: options.skip,
+                top: clampDirectoryPageSize(options.top),
+            });
+            const response = await this.get(DATA_FABRIC_ENDPOINTS.DIRECTORY.GET_ALL, { params });
+            const data = validateDirectoryListResponse(response.data);
+            const results = data.results.map(normalizeDirectoryEntry);
+            return {
+                totalCount: data.totalCount,
+                results,
+            };
+        }
+        /**
+         * Lists all Data Fabric directory principals and their current roles.
+         *
+         * Follows the Data Fabric directory top/skip pagination and returns
+         * normalized entries. Entries without assigned roles include an empty
+         * `roles` array.
+         *
+         * @param options - Optional page-size options
+         * @returns Promise resolving to an array of {@link DataFabricDirectoryEntry}
+         *
+         * @example
+         * ```typescript
+         * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+         *
+         * const directory = new DataFabricDirectoryService(sdk);
+         * const principals = await directory.getAll({ pageSize: 100 });
+         * ```
+         *
+         * @internal
+         */
+        async getAll(options = {}) {
+            return this.fetchAllEntries(options);
+        }
+        /**
+         * Assigns Data Fabric roles to one or more principals.
+         *
+         * The Data Fabric API replaces the role set for each principal, so this
+         * method preserves existing roles by default and posts the union of current
+         * and requested role IDs.
+         *
+         * Role IDs can be discovered with `DataFabricRoleService.getAll()`. Set
+         * `preserveExisting: false` only when intentionally replacing a principal's
+         * Data Fabric role set.
+         *
+         * @param principalIds - Principal external ID or IDs
+         * @param principalType - Principal type
+         * @param roleIds - Data Fabric role IDs to assign
+         * @param options - Optional assignment behavior
+         * @returns Promise resolving to an array of {@link DataFabricDirectoryAssignmentResult}
+         *
+         * @example
+         * ```typescript
+         * import { DataFabricDirectoryEntityTypeName, DataFabricDirectoryService, DataFabricRoleService } from '@uipath/uipath-typescript/entities';
+         *
+         * const roles = new DataFabricRoleService(sdk);
+         * const directory = new DataFabricDirectoryService(sdk);
+         *
+         * const dataWriter = (await roles.getAll()).find(role => role.name === 'DataWriter');
+         * if (!dataWriter) {
+         *   throw new Error('DataWriter role not found');
+         * }
+         *
+         * await directory.assignRoles('<identity-group-id>', DataFabricDirectoryEntityTypeName.Group, [dataWriter.id]);
+         * ```
+         *
+         * @example
+         * ```typescript
+         * await directory.assignRoles('<identity-user-id>', DataFabricDirectoryEntityTypeName.User, ['<role-id>'], {
+         *   preserveExisting: false,
+         * });
+         * ```
+         *
+         * @internal
+         */
+        async assignRoles(principalIds, principalType, roleIds, options = {}) {
+            const normalizedPrincipalIds = normalizePrincipalIds(principalIds);
+            const normalizedRoleIds = normalizeRoleIds(roleIds);
+            if (normalizedPrincipalIds.length === 0) {
+                throw new ValidationError({ message: 'At least one principal ID is required.' });
+            }
+            if (normalizedRoleIds.length === 0) {
+                throw new ValidationError({ message: 'At least one Data Fabric role ID is required.' });
+            }
+            const type = normalizePrincipalType(principalType);
+            const preserveExisting = options.preserveExisting ?? true;
+            const existingById = new Map();
+            if (preserveExisting) {
+                for (const entry of await this.fetchAllEntries()) {
+                    existingById.set(entry.externalId.toLowerCase(), entry);
+                }
+            }
+            return Promise.all(normalizedPrincipalIds.map(async (principalId) => {
+                const existing = existingById.get(principalId.toLowerCase());
+                const mergedRoleIds = preserveExisting
+                    ? normalizeRoleIds([...roleIdsFromEntry(existing), ...normalizedRoleIds])
+                    : normalizedRoleIds;
+                const payload = {
+                    directoryEntities: [
+                        {
+                            externalId: principalId,
+                            type,
+                            resolved: true,
+                        },
+                    ],
+                    roles: mergedRoleIds,
+                    isUIEnabled: options.uiEnabled ?? true,
+                };
+                await this.post(DATA_FABRIC_ENDPOINTS.DIRECTORY.ASSIGN_ROLES, payload);
+                return {
+                    principalId,
+                    roleIds: mergedRoleIds,
+                };
+            }));
+        }
+        /**
+         * Revokes all direct Data Fabric roles from one or more principals.
+         *
+         * The Data Fabric API removes all role assignments for each supplied external
+         * ID. Use this when a principal should no longer have direct Data Fabric
+         * access. Inherited access through groups is not changed.
+         *
+         * @param principalIds - Principal external ID or IDs
+         * @returns Promise resolving when the roles are revoked
+         *
+         * @example
+         * ```typescript
+         * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+         *
+         * const directory = new DataFabricDirectoryService(sdk);
+         *
+         * await directory.revokeRoles('<identity-user-id>');
+         * ```
+         *
+         * @example
+         * ```typescript
+         * await directory.revokeRoles([
+         *   '<identity-user-id>',
+         *   '<identity-group-id>',
+         * ]);
+         * ```
+         *
+         * @internal
+         */
+        async revokeRoles(principalIds) {
+            const normalizedPrincipalIds = normalizePrincipalIds(principalIds);
+            if (normalizedPrincipalIds.length === 0) {
+                throw new ValidationError({ message: 'At least one principal ID is required.' });
+            }
+            const payload = {
+                externalIds: normalizedPrincipalIds,
+            };
+            await this.post(DATA_FABRIC_ENDPOINTS.DIRECTORY.REVOKE_ROLES, payload);
+        }
+    }
+    __decorate([
+        track('DataFabricDirectory.List')
+    ], DataFabricDirectoryService.prototype, "list", null);
+    __decorate([
+        track('DataFabricDirectory.GetAll')
+    ], DataFabricDirectoryService.prototype, "getAll", null);
+    __decorate([
+        track('DataFabricDirectory.AssignRoles')
+    ], DataFabricDirectoryService.prototype, "assignRoles", null);
+    __decorate([
+        track('DataFabricDirectory.RevokeRoles')
+    ], DataFabricDirectoryService.prototype, "revokeRoles", null);
+
     /**
      * Maps API field names (countOf*) to SDK field names (*Count) for InstanceStats,
      * aligning naming with ElementStats and other count-suffixed conventions.
@@ -14110,6 +14534,16 @@
                     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] });
             }
         };
     }
@@ -14126,260 +14560,78 @@
     }
 
     /**
-     * Builds the request body for Insights RTM "top" endpoints.
+     * Creates methods for a process instance
      *
-     * @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 filters (packageId, processKey, version)
-     * @returns Request body for the Insights RTM endpoint
-     * @internal
+     * @param instanceData - The process instance data (response from API)
+     * @param service - The process instance service instance
+     * @returns Object containing process instance methods
      */
-    function buildInsightsTopBody(startTime, endTime, isCaseManagement, options) {
+    function createProcessInstanceMethods(instanceData, service) {
         return {
-            commonParams: {
-                startTime: startTime.getTime(),
-                endTime: endTime.getTime(),
-                isCaseManagement,
-                ...(options?.packageId ? { packageId: options.packageId } : {}),
-                ...(options?.processKey ? { processKey: options.processKey } : {}),
-                ...(options?.version ? { version: options.version } : {}),
+            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);
             }
         };
     }
     /**
-     * Fetches instance status timeline from the Insights API.
-     * Shared implementation used by both MaestroProcessesService and CasesService.
+     * Creates an actionable process instance by combining API process instance data with operational methods.
      *
-     * @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
-     * @internal
-     */
-    async function fetchInstanceStatusTimeline(postFn, startTime, endTime, isCaseManagement, options) {
-        const response = await postFn(MAESTRO_ENDPOINTS.INSIGHTS.INSTANCE_STATUS_BY_DATE, {
-            commonParams: {
-                startTime: startTime.getTime(),
-                endTime: endTime.getTime(),
-                isCaseManagement,
-            },
-            timeSliceUnit: options?.groupBy,
-            timezoneOffset: new Date().getTimezoneOffset() * -1,
-        });
-        return response.data ?? [];
-    }
-    /**
-     * Builds the commonParams request body for Insights RTM endpoints
-     * that filter by process key, package, time range, and version.
-     *
-     * @param request - Process scope + time range to aggregate over
-     * @returns Request body with commonParams
-     * @internal
-     */
-    function buildInsightsCommonBody(request) {
-        return {
-            commonParams: {
-                processKey: request.processKey,
-                packageId: request.packageId,
-                startTime: request.startTime.getTime(),
-                endTime: request.endTime.getTime(),
-                version: request.packageVersion
-            }
-        };
-    }
-
-    /**
-     * Maps fields for Incident entities
-     */
-    const ProcessIncidentMap = {
-        errorTimeUtc: 'errorTime'
-    };
-    /**
-     * Maps fields for Incident Summary entities
-     */
-    const ProcessIncidentSummaryMap = {
-        firstTimeUtc: 'firstOccuranceTime'
-    };
-
-    /**
-    * Helpers for fetching BPMN XML and extracting element details used to annotate responses
-    */
-    class BpmnHelpers {
-        /**
-         * Parse BPMN XML and extract element id → {name,type} used for incidents
-         */
-        static parseBpmnElementsForIncidents(bpmnXml) {
-            const elementInfo = {};
-            try {
-                // Find <bpmn:...> start tags and capture the element type.
-                // Then read 'id' and 'name' attributes from each tag.
-                const bpmnOpenTagRegex = /<bpmn:([A-Za-z][\w.-]*)\b[^>]*>/g;
-                for (const tagMatch of bpmnXml.matchAll(bpmnOpenTagRegex)) {
-                    const [fullTag, elementType] = tagMatch;
-                    // Extract attributes from the current tag text.
-                    const idMatch = /\bid\s*=\s*"([^"]*)"/.exec(fullTag);
-                    if (!idMatch) {
-                        continue;
-                    }
-                    const elementId = idMatch[1];
-                    const nameMatch = /\bname\s*=\s*"([^"]*)"/.exec(fullTag);
-                    const name = nameMatch ? nameMatch[1] : '';
-                    // Convert BPMN element type to human-readable format
-                    const activityType = this.formatActivityTypeForIncidents(elementType);
-                    const activityName = name || elementId;
-                    elementInfo[elementId] = {
-                        type: activityType,
-                        name: activityName
-                    };
-                }
-            }
-            catch (error) {
-                console.warn('Failed to parse BPMN XML for incidents:', error);
-            }
-            return elementInfo;
-        }
-        /**
-         * Format BPMN element type to human-readable activity type for incidents
-         */
-        static formatActivityTypeForIncidents(elementType) {
-            // Convert camelCase BPMN element types to human-readable format
-            // e.g., "serviceTask" -> "Service Task", "exclusiveGateway" -> "Exclusive Gateway"
-            return elementType
-                .replace(/([A-Z])/g, ' $1') // Add space before uppercase letters
-                .replace(/^./, str => str.toUpperCase()) // Capitalize first letter
-                .trim(); // Remove any leading/trailing spaces
-        }
-        /**
-         * Fetch BPMN via getBpmn and add element name/type to each incident
-         */
-        static async enrichIncidentsWithBpmnData(incidents, folderKey, service) {
-            // Check if all incidents have the same instanceId
-            const uniqueInstanceIds = [...new Set(incidents.map(i => i.instanceId))];
-            if (uniqueInstanceIds.length === 1) {
-                // Single instance optimization (in case of process instance incidents)
-                const elementInfo = await this.getBpmnElementInfo(uniqueInstanceIds[0], folderKey, service);
-                return incidents.map((incident) => this.transformIncidentWithBpmn(incident, elementInfo));
-            }
-            else {
-                // Multiple instances optimization (in case of process incidents)
-                return this.enrichMultipleInstanceIncidents(incidents, folderKey, service);
-            }
-        }
-        /**
-         * When incidents span multiple instances, fetch BPMN per instance and annotate
-         */
-        static async enrichMultipleInstanceIncidents(incidents, folderKey, service) {
-            const groups = incidents.reduce((acc, incident) => {
-                const id = incident.instanceId || NO_INSTANCE;
-                (acc[id] = acc[id] || []).push(incident);
-                return acc;
-            }, {});
-            const results = await Promise.all(Object.entries(groups).map(async (entry) => {
-                const [instanceId, groupIncidents] = entry;
-                const elementInfo = await this.getBpmnElementInfo(instanceId, folderKey, service);
-                return groupIncidents.map((incident) => this.transformIncidentWithBpmn(incident, elementInfo));
-            }));
-            return results.flat();
-        }
-        /**
-         * Retrieve BPMN XML for an instance and derive element id → {name,type}
-         */
-        static async getBpmnElementInfo(instanceId, folderKey, service) {
-            if (!instanceId || instanceId === NO_INSTANCE) {
-                return {};
-            }
-            try {
-                const bpmnXml = await service.getBpmn(instanceId, folderKey);
-                return this.parseBpmnElementsForIncidents(bpmnXml);
-            }
-            catch (error) {
-                console.warn(`Failed to get BPMN for instance ${instanceId}:`, error);
-                return {};
-            }
-        }
-        /**
-         * Transform a raw incident by attaching element name/type from BPMN
-         */
-        static transformIncidentWithBpmn(incident, elementInfo) {
-            const element = elementInfo[incident.elementId];
-            const transformed = transformData(incident, ProcessIncidentMap);
-            return {
-                ...transformed,
-                incidentElementActivityType: element?.type || UNKNOWN,
-                incidentElementActivityName: element?.name || UNKNOWN
-            };
-        }
-    }
-
-    /**
-     * 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);
-            }
-        };
-    }
-    /**
-     * 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
+     * @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);
@@ -14460,6 +14712,16 @@
                     startTime,
                     endTime,
                 });
+            },
+            getInstanceStatusTimeline(startTime, endTime, options) {
+                if (!caseData.processKey)
+                    throw new Error('Process key is undefined');
+                return service.getInstanceStatusTimeline(startTime, endTime, { ...options, processKeys: [caseData.processKey] });
+            },
+            getIncidentsTimeline(startTime, endTime, options) {
+                if (!caseData.processKey)
+                    throw new Error('Process key is undefined');
+                return service.getIncidentsTimeline(startTime, endTime, { ...options, processKeys: [caseData.processKey] });
             }
         };
     }
@@ -14661,20 +14923,210 @@
         TimeInterval["Week"] = "WEEK";
     })(exports.TimeInterval || (exports.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.
+     * 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.
+     */
+    exports.InstanceFinalStatus = void 0;
+    (function (InstanceFinalStatus) {
+        /** Instance completed successfully */
+        InstanceFinalStatus["Completed"] = "Completed";
+        /** Instance encountered an error */
+        InstanceFinalStatus["Faulted"] = "Faulted";
+        /** Instance was cancelled */
+        InstanceFinalStatus["Cancelled"] = "Cancelled";
+    })(exports.InstanceFinalStatus || (exports.InstanceFinalStatus = {}));
+
+    /**
+     * Builds the request body for Insights RTM "top" endpoints.
+     *
+     * @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 filters (packageId, processKey, version)
+     * @returns Request body for the Insights RTM endpoint
+     * @internal
+     */
+    function buildInsightsTopBody(startTime, endTime, isCaseManagement, options) {
+        return {
+            commonParams: {
+                startTime: startTime.getTime(),
+                endTime: endTime.getTime(),
+                isCaseManagement,
+                ...(options?.packageId ? { packageId: options.packageId } : {}),
+                ...(options?.processKey ? { processKey: options.processKey } : {}),
+                ...(options?.version ? { version: options.version } : {}),
+            }
+        };
+    }
+    /**
+     * Builds the request body for Insights RTM timeline endpoints
+     * (`InstanceStatusByDate`, `IncidentsByTimeWindow`).
+     *
+     * @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 time bucketing and filtering settings
+     * @returns Request body for the Insights RTM timeline endpoint
+     * @internal
+     */
+    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 ?? exports.TimeInterval.Day,
+            timezoneOffset: new Date().getTimezoneOffset() * -1,
+        };
+    }
+    /**
+     * Builds the commonParams request body for Insights RTM endpoints
+     * that filter by process key, package, time range, and version.
+     *
+     * @param request - Process scope + time range to aggregate over
+     * @returns Request body with commonParams
+     * @internal
+     */
+    function buildInsightsCommonBody(request) {
+        return {
+            commonParams: {
+                processKey: request.processKey,
+                packageId: request.packageId,
+                startTime: request.startTime.getTime(),
+                endTime: request.endTime.getTime(),
+                version: request.packageVersion
+            }
+        };
+    }
+
+    /**
+     * Maps fields for Incident entities
+     */
+    const ProcessIncidentMap = {
+        errorTimeUtc: 'errorTime'
+    };
+    /**
+     * Maps fields for Incident Summary entities
      */
-    exports.InstanceFinalStatus = void 0;
-    (function (InstanceFinalStatus) {
-        /** Instance completed successfully */
-        InstanceFinalStatus["Completed"] = "Completed";
-        /** Instance encountered an error */
-        InstanceFinalStatus["Faulted"] = "Faulted";
-        /** Instance was cancelled */
-        InstanceFinalStatus["Cancelled"] = "Cancelled";
-    })(exports.InstanceFinalStatus || (exports.InstanceFinalStatus = {}));
+    const ProcessIncidentSummaryMap = {
+        firstTimeUtc: 'firstOccuranceTime'
+    };
+
+    /**
+    * Helpers for fetching BPMN XML and extracting element details used to annotate responses
+    */
+    class BpmnHelpers {
+        /**
+         * Parse BPMN XML and extract element id → {name,type} used for incidents
+         */
+        static parseBpmnElementsForIncidents(bpmnXml) {
+            const elementInfo = {};
+            try {
+                // Find <bpmn:...> start tags and capture the element type.
+                // Then read 'id' and 'name' attributes from each tag.
+                const bpmnOpenTagRegex = /<bpmn:([A-Za-z][\w.-]*)\b[^>]*>/g;
+                for (const tagMatch of bpmnXml.matchAll(bpmnOpenTagRegex)) {
+                    const [fullTag, elementType] = tagMatch;
+                    // Extract attributes from the current tag text.
+                    const idMatch = /\bid\s*=\s*"([^"]*)"/.exec(fullTag);
+                    if (!idMatch) {
+                        continue;
+                    }
+                    const elementId = idMatch[1];
+                    const nameMatch = /\bname\s*=\s*"([^"]*)"/.exec(fullTag);
+                    const name = nameMatch ? nameMatch[1] : '';
+                    // Convert BPMN element type to human-readable format
+                    const activityType = this.formatActivityTypeForIncidents(elementType);
+                    const activityName = name || elementId;
+                    elementInfo[elementId] = {
+                        type: activityType,
+                        name: activityName
+                    };
+                }
+            }
+            catch (error) {
+                console.warn('Failed to parse BPMN XML for incidents:', error);
+            }
+            return elementInfo;
+        }
+        /**
+         * Format BPMN element type to human-readable activity type for incidents
+         */
+        static formatActivityTypeForIncidents(elementType) {
+            // Convert camelCase BPMN element types to human-readable format
+            // e.g., "serviceTask" -> "Service Task", "exclusiveGateway" -> "Exclusive Gateway"
+            return elementType
+                .replace(/([A-Z])/g, ' $1') // Add space before uppercase letters
+                .replace(/^./, str => str.toUpperCase()) // Capitalize first letter
+                .trim(); // Remove any leading/trailing spaces
+        }
+        /**
+         * Fetch BPMN via getBpmn and add element name/type to each incident
+         */
+        static async enrichIncidentsWithBpmnData(incidents, folderKey, service) {
+            // Check if all incidents have the same instanceId
+            const uniqueInstanceIds = [...new Set(incidents.map(i => i.instanceId))];
+            if (uniqueInstanceIds.length === 1) {
+                // Single instance optimization (in case of process instance incidents)
+                const elementInfo = await this.getBpmnElementInfo(uniqueInstanceIds[0], folderKey, service);
+                return incidents.map((incident) => this.transformIncidentWithBpmn(incident, elementInfo));
+            }
+            else {
+                // Multiple instances optimization (in case of process incidents)
+                return this.enrichMultipleInstanceIncidents(incidents, folderKey, service);
+            }
+        }
+        /**
+         * When incidents span multiple instances, fetch BPMN per instance and annotate
+         */
+        static async enrichMultipleInstanceIncidents(incidents, folderKey, service) {
+            const groups = incidents.reduce((acc, incident) => {
+                const id = incident.instanceId || NO_INSTANCE;
+                (acc[id] = acc[id] || []).push(incident);
+                return acc;
+            }, {});
+            const results = await Promise.all(Object.entries(groups).map(async (entry) => {
+                const [instanceId, groupIncidents] = entry;
+                const elementInfo = await this.getBpmnElementInfo(instanceId, folderKey, service);
+                return groupIncidents.map((incident) => this.transformIncidentWithBpmn(incident, elementInfo));
+            }));
+            return results.flat();
+        }
+        /**
+         * Retrieve BPMN XML for an instance and derive element id → {name,type}
+         */
+        static async getBpmnElementInfo(instanceId, folderKey, service) {
+            if (!instanceId || instanceId === NO_INSTANCE) {
+                return {};
+            }
+            try {
+                const bpmnXml = await service.getBpmn(instanceId, folderKey);
+                return this.parseBpmnElementsForIncidents(bpmnXml);
+            }
+            catch (error) {
+                console.warn(`Failed to get BPMN for instance ${instanceId}:`, error);
+                return {};
+            }
+        }
+        /**
+         * Transform a raw incident by attaching element name/type from BPMN
+         */
+        static transformIncidentWithBpmn(incident, elementInfo) {
+            const element = elementInfo[incident.elementId];
+            const transformed = transformData(incident, ProcessIncidentMap);
+            return {
+                ...transformed,
+                incidentElementActivityType: element?.type || UNKNOWN,
+                incidentElementActivityName: element?.name || UNKNOWN
+            };
+        }
+    }
 
     /**
      * Maps fields for Process Instance entities to ensure consistent naming
@@ -14751,7 +15203,7 @@
             }, 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>
@@ -14890,6 +15342,25 @@
                 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
@@ -15040,6 +15511,9 @@
     __decorate([
         track('ProcessInstances.Resume')
     ], ProcessInstancesService.prototype, "resume", null);
+    __decorate([
+        track('ProcessInstances.Retry')
+    ], ProcessInstancesService.prototype, "retry", null);
     __decorate([
         track('ProcessInstances.GetVariables')
     ], ProcessInstancesService.prototype, "getVariables", null);
@@ -15196,7 +15670,7 @@
          *
          * @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
@@ -15223,12 +15697,67 @@
          *
          * @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.
@@ -15414,6 +15943,9 @@
     __decorate([
         track('MaestroProcesses.GetInstanceStatusTimeline')
     ], MaestroProcessesService.prototype, "getInstanceStatusTimeline", null);
+    __decorate([
+        track('MaestroProcesses.GetIncidentsTimeline')
+    ], MaestroProcessesService.prototype, "getIncidentsTimeline", null);
     __decorate([
         track('MaestroProcesses.GetTopFaultedCount')
     ], MaestroProcessesService.prototype, "getTopFaultedCount", null);
@@ -15606,7 +16138,7 @@
          *
          * @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
@@ -15633,12 +16165,67 @@
          *
          * @example
          * ```typescript
+         * // Filter to a specific case process
+         * const filtered = await cases.getInstanceStatusTimeline(startTime, endTime, {
+         *   processKeys: ['<processKey>'],
+         * });
+         * ```
+         *
+         * @example
+         * ```typescript
          * // Get all-time data (from Unix epoch to now)
          * const allTime = await cases.getInstanceStatusTimeline(new Date(0), new Date());
          * ```
          */
         async getInstanceStatusTimeline(startTime, endTime, options) {
-            return fetchInstanceStatusTimeline(this.post.bind(this), startTime, endTime, true, options);
+            const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.INSTANCE_STATUS_BY_DATE, buildInsightsTimelineBody(startTime, endTime, true, options));
+            return data ?? [];
+        }
+        /**
+         * Get incident counts aggregated by time bucket for case management 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 cases.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/cases';
+         *
+         * // Get weekly breakdown
+         * const incidents = await cases.getIncidentsTimeline(startTime, endTime, {
+         *   groupBy: TimeInterval.Week,
+         * });
+         * ```
+         *
+         * @example
+         * ```typescript
+         * // Filter to a specific case process
+         * const filtered = await cases.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, true, options));
+            return data?.dataPoints ?? [];
         }
         /**
          * Get the top 10 case processes ranked by failure count within a time range.
@@ -15837,6 +16424,9 @@
     __decorate([
         track('Cases.GetInstanceStatusTimeline')
     ], CasesService.prototype, "getInstanceStatusTimeline", null);
+    __decorate([
+        track('Cases.GetIncidentsTimeline')
+    ], CasesService.prototype, "getIncidentsTimeline", null);
     __decorate([
         track('Cases.GetTopFaultedCount')
     ], CasesService.prototype, "getTopFaultedCount", null);
@@ -16154,6 +16744,10 @@
                 const transformedTask = transformData(pascalToCamelCaseKeys(task), TaskMap);
                 return createTaskWithMethods(applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }), this);
             };
+            // Rewrite renamed SDK field names → API names inside OData strings
+            // before delegating, mirroring the transformRequest pattern used for
+            // request bodies.
+            const apiOptions = options ? transformOptions(options, TaskMap) : options;
             return PaginationHelpers.getAll({
                 serviceAccess: this.createPaginationServiceAccess(),
                 getEndpoint: () => endpoint,
@@ -16170,7 +16764,7 @@
                         countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM // OData OFFSET parameter
                     }
                 }
-            }, options);
+            }, apiOptions);
         }
         /**
          * Gets a task by ID
@@ -16206,9 +16800,10 @@
             const headers = createHeaders({ [FOLDER_ID]: folderId });
             // Add default expand parameters
             const modifiedOptions = this.addDefaultExpand(restOptions);
-            // prefix all keys in options
-            const keysToPrefix = Object.keys(modifiedOptions);
-            const apiOptions = addPrefixToKeys(modifiedOptions, ODATA_PREFIX, keysToPrefix);
+            // Rewrite renamed SDK field names → API names inside OData strings,
+            // then prefix all keys for OData.
+            const apiFieldOptions = transformOptions(modifiedOptions, TaskMap);
+            const apiOptions = addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions));
             const response = await this.get(TASK_ENDPOINTS.GET_BY_ID(id), {
                 params: apiOptions,
                 headers
@@ -17201,9 +17796,12 @@
          * @param name - Resource name to search for
          * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) + OData query options (`expand`, `select`)
          * @param transform - Maps a raw OData item to the typed response (e.g. PascalCase → camelCase via field map)
+         * @param responseFieldMap - Optional response field map (API → SDK), reversed internally by
+         *   `transformOptions` to rewrite SDK field names back to API names in user-supplied
+         *   `expand` / `select` (symmetric counterpart to `transform`)
          * @throws ValidationError when inputs are malformed; NotFoundError when no match
          */
-        async getByNameLookup(resourceType, endpoint, name, options, transform) {
+        async getByNameLookup(resourceType, endpoint, name, options, transform, responseFieldMap) {
             const validatedName = validateName(resourceType, name);
             const { folderId, folderKey, folderPath, ...queryOptions } = options;
             const headers = resolveFolderHeaders({
@@ -17213,8 +17811,11 @@
                 resourceType: `${resourceType}.getByName`,
                 fallbackFolderKey: this.config.folderKey,
             });
+            const apiFieldOptions = responseFieldMap
+                ? transformOptions(queryOptions, responseFieldMap)
+                : queryOptions;
             const apiOptions = {
-                ...addPrefixToKeys(queryOptions, ODATA_PREFIX, Object.keys(queryOptions)),
+                ...addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions)),
                 '$filter': `Name eq '${validatedName.replace(SINGLE_QUOTE_RE, "''")}'`,
                 '$top': '1',
             };
@@ -17314,6 +17915,10 @@
         async getAll(options) {
             // Transformation function for assets
             const transformAssetResponse = (asset) => transformData(pascalToCamelCaseKeys(asset), AssetMap);
+            // Rewrite renamed SDK field names → API names inside OData strings
+            // before delegating, mirroring the transformRequest pattern used for
+            // request bodies.
+            const apiOptions = options ? transformOptions(options, AssetMap) : options;
             return PaginationHelpers.getAll({
                 serviceAccess: this.createPaginationServiceAccess(),
                 getEndpoint: (folderId) => folderId ? ASSET_ENDPOINTS.GET_BY_FOLDER : ASSET_ENDPOINTS.GET_ALL,
@@ -17329,7 +17934,7 @@
                         countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
                     }
                 }
-            }, options);
+            }, apiOptions);
         }
         /**
          * Gets a single asset by ID
@@ -17351,8 +17956,8 @@
          */
         async getById(id, folderId, options = {}) {
             const headers = createHeaders({ [FOLDER_ID]: folderId });
-            const keysToPrefix = Object.keys(options);
-            const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+            const apiFieldOptions = transformOptions(options, AssetMap);
+            const apiOptions = addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions));
             const response = await this.get(ASSET_ENDPOINTS.GET_BY_ID(id), {
                 headers,
                 params: apiOptions
@@ -17387,7 +17992,7 @@
          * ```
          */
         async getByName(name, options = {}) {
-            return this.getByNameLookup('Asset', ASSET_ENDPOINTS.GET_BY_FOLDER, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), AssetMap));
+            return this.getByNameLookup('Asset', ASSET_ENDPOINTS.GET_BY_FOLDER, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), AssetMap), AssetMap);
         }
         /**
          * Updates the value of an existing asset by ID.
@@ -17661,6 +18266,9 @@
             });
             // Transformation function for blob items
             const transformBlobItem = (item) => transformData(item, BucketMap);
+            // Rewrite renamed SDK field names → API names inside OData strings
+            // before delegating.
+            const apiRestOptions = transformOptions(restOptions, BucketMap);
             return PaginationHelpers.getAll({
                 serviceAccess: this.createPaginationServiceAccess(),
                 getEndpoint: () => BUCKET_ENDPOINTS.GET_FILE_META_DATA(bucketId),
@@ -17676,7 +18284,7 @@
                 },
                 excludeFromPrefix: ['prefix'], // Bucket-specific param, not OData
                 headers,
-            }, restOptions);
+            }, apiRestOptions);
         }
         async uploadFile(bucketIdOrOptions, path, content, options) {
             // Normalize the two overload forms into a single internal shape.
@@ -17760,9 +18368,10 @@
                 resourceType: 'Buckets.getReadUri',
                 fallbackFolderKey: this.config.folderKey,
             });
+            const apiRestOptions = transformOptions(restOptions, BucketMap);
             const queryOptions = {
                 expiryInMinutes,
-                ...addPrefixToKeys(restOptions, ODATA_PREFIX, Object.keys(restOptions))
+                ...addPrefixToKeys(apiRestOptions, ODATA_PREFIX, Object.keys(apiRestOptions))
             };
             return this._getUri(BUCKET_ENDPOINTS.GET_READ_URI(bucketId), bucketId, resolvedPath, headers, queryOptions);
         }
@@ -17882,6 +18491,9 @@
                 fallbackFolderKey: this.config.folderKey,
             });
             const transformBucketFile = (file) => transformData(pascalToCamelCaseKeys(file), BucketMap);
+            // Rewrite renamed SDK field names → API names inside OData strings
+            // before delegating.
+            const apiRestOptions = transformOptions(restOptions, BucketMap);
             return PaginationHelpers.getAll({
                 serviceAccess: this.createPaginationServiceAccess(),
                 getEndpoint: () => BUCKET_ENDPOINTS.GET_FILES(bucketId),
@@ -17898,7 +18510,7 @@
                 },
                 excludeFromPrefix: ['directory', 'recursive', 'fileNameRegex'],
                 headers,
-            }, { ...restOptions, directory: '/', recursive: true });
+            }, { ...apiRestOptions, directory: '/', recursive: true });
         }
         /**
          * Deletes a file from a bucket
@@ -17945,9 +18557,10 @@
          */
         async _getWriteUri(options) {
             const { bucketId, path, expiryInMinutes, headers, ...restOptions } = options;
+            const apiRestOptions = transformOptions(restOptions, BucketMap);
             const queryOptions = {
                 expiryInMinutes,
-                ...addPrefixToKeys(restOptions, ODATA_PREFIX, Object.keys(restOptions))
+                ...addPrefixToKeys(apiRestOptions, ODATA_PREFIX, Object.keys(apiRestOptions))
             };
             return this._getUri(BUCKET_ENDPOINTS.GET_WRITE_URI(bucketId), bucketId, path, headers, queryOptions);
         }
@@ -18080,9 +18693,10 @@
             if (!id) {
                 throw new ValidationError({ message: 'id is required for getById' });
             }
-            // Prefix all keys in options with $ for OData
-            const keysToPrefix = Object.keys(options);
-            const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+            // Response applies both maps (BucketMap on blobFileAccess, AttachmentsMap on top-level);
+            // merge so SDK names from either are rewritten in one pass.
+            const apiFieldOptions = transformOptions(options, { ...AttachmentsMap, ...BucketMap });
+            const apiOptions = addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions));
             const response = await this.get(ORCHESTRATOR_ATTACHMENT_ENDPOINTS.GET_BY_ID(id), {
                 params: apiOptions,
             });
@@ -18764,6 +19378,10 @@
         async getAll(options) {
             // Transformation function for processes
             const transformProcessResponse = (process) => transformData(pascalToCamelCaseKeys(process), ProcessMap);
+            // Rewrite renamed SDK field names → API names inside OData strings
+            // before delegating, mirroring the transformRequest pattern used for
+            // request bodies.
+            const apiOptions = options ? transformOptions(options, ProcessMap) : options;
             return PaginationHelpers.getAll({
                 serviceAccess: this.createPaginationServiceAccess(),
                 getEndpoint: () => PROCESS_ENDPOINTS.GET_ALL,
@@ -18779,7 +19397,7 @@
                         countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
                     }
                 }
-            }, options);
+            }, apiOptions);
         }
         async start(request, optionsOrFolderId, legacyOptions) {
             // Normalize the two overload forms into a single internal shape.
@@ -18813,9 +19431,10 @@
             const requestBody = {
                 startInfo: apiRequest
             };
-            // Prefix all query parameter keys with '$' for OData
-            const keysToPrefix = Object.keys(queryOptions);
-            const apiOptions = addPrefixToKeys(queryOptions, ODATA_PREFIX, keysToPrefix);
+            // Rewrite renamed SDK field names → API names inside OData strings,
+            // then prefix all query parameter keys with '$' for OData.
+            const apiFieldOptions = transformOptions(queryOptions, ProcessMap);
+            const apiOptions = addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions));
             const response = await this.post(PROCESS_ENDPOINTS.START_PROCESS, requestBody, {
                 params: apiOptions,
                 headers
@@ -18843,8 +19462,8 @@
          */
         async getById(id, folderId, options = {}) {
             const headers = createHeaders({ [FOLDER_ID]: folderId });
-            const keysToPrefix = Object.keys(options);
-            const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+            const apiFieldOptions = transformOptions(options, ProcessMap);
+            const apiOptions = addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions));
             const response = await this.get(PROCESS_ENDPOINTS.GET_BY_ID(id), {
                 headers,
                 params: apiOptions
@@ -18879,7 +19498,7 @@
          * ```
          */
         async getByName(name, options = {}) {
-            return this.getByNameLookup('Process', PROCESS_ENDPOINTS.GET_ALL, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), ProcessMap));
+            return this.getByNameLookup('Process', PROCESS_ENDPOINTS.GET_ALL, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), ProcessMap), ProcessMap);
         }
     }
     __decorate([
@@ -18955,6 +19574,10 @@
         async getAll(options) {
             // Transformation function for queues
             const transformQueueResponse = (queue) => transformData(pascalToCamelCaseKeys(queue), QueueMap);
+            // Rewrite renamed SDK field names → API names inside OData strings
+            // before delegating, mirroring the transformRequest pattern used for
+            // request bodies.
+            const apiOptions = options ? transformOptions(options, QueueMap) : options;
             return PaginationHelpers.getAll({
                 serviceAccess: this.createPaginationServiceAccess(),
                 getEndpoint: (folderId) => folderId ? QUEUE_ENDPOINTS.GET_BY_FOLDER : QUEUE_ENDPOINTS.GET_ALL,
@@ -18970,7 +19593,7 @@
                         countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
                     }
                 }
-            }, options);
+            }, apiOptions);
         }
         /**
          * Gets a single queue by ID
@@ -18991,8 +19614,8 @@
          */
         async getById(id, folderId, options = {}) {
             const headers = createHeaders({ [FOLDER_ID]: folderId });
-            const keysToPrefix = Object.keys(options);
-            const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+            const apiFieldOptions = transformOptions(options, QueueMap);
+            const apiOptions = addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions));
             const response = await this.get(QUEUE_ENDPOINTS.GET_BY_ID(id), {
                 headers,
                 params: apiOptions
@@ -19087,7 +19710,19 @@
                 /**
                  * Access to ChoiceSet service for managing choice sets
                  */
-                choicesets: this.getService(ChoiceSetService)
+                choicesets: this.getService(ChoiceSetService),
+                /**
+                 * Access to Data Fabric roles for manage-access flows
+                 *
+                 * @internal
+                 */
+                roles: this.getService(DataFabricRoleService),
+                /**
+                 * Access to Data Fabric directory principals and role assignments
+                 *
+                 * @internal
+                 */
+                directory: this.getService(DataFabricDirectoryService)
             });
         }
         /**
@@ -19847,6 +20482,52 @@
         SpanAttachmentDirection["Out"] = "Out";
     })(exports.SpanAttachmentDirection || (exports.SpanAttachmentDirection = {}));
 
+    // ─── Governance ─────────────────────────────────────────────────────
+    /**
+     * Evaluation mode of a governance decision.
+     */
+    exports.AgentGovernanceMode = void 0;
+    (function (AgentGovernanceMode) {
+        /** Policy evaluated and logged, but not enforced. */
+        AgentGovernanceMode["Audit"] = "AUDIT";
+        /** Policy evaluated and enforced. */
+        AgentGovernanceMode["Enforce"] = "ENFORCE";
+        /** Unrecognized or missing mode. */
+        AgentGovernanceMode["Unknown"] = "Unknown";
+    })(exports.AgentGovernanceMode || (exports.AgentGovernanceMode = {}));
+    /**
+     * Verdict of a governance decision (`Deny` = violation).
+     */
+    exports.AgentGovernanceVerdict = void 0;
+    (function (AgentGovernanceVerdict) {
+        /** Allowed — not a violation. */
+        AgentGovernanceVerdict["Allow"] = "ALLOW";
+        /** Denied — counts as a violation. */
+        AgentGovernanceVerdict["Deny"] = "DENY";
+        /** Unrecognized or missing verdict. */
+        AgentGovernanceVerdict["Unknown"] = "Unknown";
+    })(exports.AgentGovernanceVerdict || (exports.AgentGovernanceVerdict = {}));
+    /**
+     * Sections the governance summary can compute. `action` and `mode` are opt-in.
+     */
+    exports.AgentGovernanceSection = void 0;
+    (function (AgentGovernanceSection) {
+        /** Scalar totals (`total`, `violations`). */
+        AgentGovernanceSection["Totals"] = "totals";
+        /** Breakdown by governance hook. */
+        AgentGovernanceSection["Hook"] = "hook";
+        /** Breakdown by agent. */
+        AgentGovernanceSection["Agent"] = "agent";
+        /** Breakdown by policy. */
+        AgentGovernanceSection["Policy"] = "policy";
+        /** Breakdown by governance pack. */
+        AgentGovernanceSection["Pack"] = "pack";
+        /** Breakdown by enforcement action (opt-in). */
+        AgentGovernanceSection["Action"] = "action";
+        /** Breakdown by evaluation mode (opt-in). */
+        AgentGovernanceSection["Mode"] = "mode";
+    })(exports.AgentGovernanceSection || (exports.AgentGovernanceSection = {}));
+
     /**
      * Asset resolution utilities for UiPath Coded Apps
      *