@uipath/uipath-typescript 1.4.2 → 1.5.1

package/dist/index.cjs

@@ -4623,6 +4623,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`,
@@ -4652,8 +4653,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`,
     },
 };
 
@@ -4703,6 +4708,14 @@ const DATA_FABRIC_ENDPOINTS = {
         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`,
+    },
 };
 
 /**
@@ -5013,7 +5026,7 @@ class EmbeddedTokenManager {
  * SDK's public API.
  */
 /** SDK version placeholder — patched by the SDK publish workflow. */
-const SDK_VERSION = '1.4.2';
+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';
@@ -6980,7 +6993,16 @@ function toISOUtc(value) {
     return isNaN(date.getTime()) ? value : date.toISOString();
 }
 /**
- * Transforms data by mapping fields according to the provided field mapping
+ * 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
@@ -7003,21 +7025,28 @@ function toISOUtc(value) {
  * //   { 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));
     }
-    // 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;
-        }
+    // 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;
 }
@@ -7295,6 +7324,79 @@ function transformRequest(data, responseMap) {
     }
     return result;
 }
+/**
+ * OData query-string keys whose values may contain field identifiers that
+ * need rewriting from SDK names → API names.
+ */
+const ODATA_FIELD_PARAM_KEYS = ['filter', 'orderby', 'select', 'expand'];
+/**
+ * Matches one token at a time in an OData expression:
+ *   1. A single-quoted string literal, allowing the `''` escape sequence —
+ *      consumed atomically so identifiers inside the literal can't match.
+ *   2. An OData identifier (`[A-Za-z_][A-Za-z0-9_]*`).
+ * Anything else (whitespace, operators, parens, commas) is left alone by
+ * `String.prototype.replace`, which only substitutes matched substrings.
+ */
+const ODATA_TOKEN_RE = /'(?:[^']|'')*'|[A-Za-z_][A-Za-z0-9_]*/g;
+/**
+ * Rewrites SDK field identifiers to API field identifiers inside an OData
+ * expression string (`$filter`, `$orderby`, `$select`, `$expand`).
+ *
+ * Field maps (e.g. `JobMap`) rename API fields → SDK fields on responses, so
+ * SDK consumers see the renamed names. Without this rewrite, the same name
+ * in a `filter` string would be forwarded verbatim and the API (which still
+ * uses the original name) would reject it.
+ *
+ * Quoted string literals (with the OData `''` escape) are preserved exactly:
+ * the token regex consumes them whole, so identifiers inside literals never
+ * match. Identifier tokens are looked up in the reversed field map.
+ *
+ * @example
+ * ```typescript
+ * const requestMap = { processName: 'releaseName' };
+ * rewriteODataIdentifiers("processName eq 'processName'", requestMap);
+ * // "releaseName eq 'processName'"  — identifier rewritten, literal preserved
+ * ```
+ */
+function rewriteODataIdentifiers(expression, requestMap) {
+    if (!expression)
+        return expression;
+    return expression.replace(ODATA_TOKEN_RE, (match) => match.startsWith("'") ? match : (requestMap[match] ?? match));
+}
+/**
+ * Symmetric counterpart of {@link transformRequest} for OData query options:
+ * rewrites SDK field identifiers inside the recognized OData string params
+ * (`filter`, `orderby`, `select`, `expand`) to their API names using the
+ * reversed form of a response field map. Returns a shallow copy with the
+ * relevant values rewritten; other keys pass through unchanged.
+ *
+ * Use at the OData edge so SDK consumers can refer to renamed fields by
+ * their SDK name throughout — for reading the response and for filtering /
+ * sorting / projecting / expanding.
+ *
+ * @param options The OData query options as authored with SDK field names
+ * @param responseMap The response field map (API → SDK); reversed internally
+ *
+ * @example
+ * ```typescript
+ * // JobMap renames releaseName → processName on responses.
+ * transformOptions({ filter: "processName eq 'X'" }, JobMap);
+ * // { filter: "releaseName eq 'X'" }
+ * ```
+ */
+function transformOptions(options, responseMap) {
+    const requestMap = reverseMap(responseMap);
+    if (Object.keys(requestMap).length === 0)
+        return options;
+    const result = { ...options };
+    for (const key of ODATA_FIELD_PARAM_KEYS) {
+        const value = result[key];
+        if (typeof value === 'string') {
+            result[key] = rewriteODataIdentifiers(value, requestMap);
+        }
+    }
+    return result;
+}
 /**
  * Transforms an array-based dictionary with separate keys and values arrays
  * into a standard JavaScript object/record
@@ -9861,6 +9963,434 @@ __decorate([
     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.
+ */
+const InstanceStatsMap = {
+    countOfAllInstances: 'totalCount',
+    countOfRunning: 'runningCount',
+    countOfTransitioning: 'transitioningCount',
+    countOfPaused: 'pausedCount',
+    countOfFaulted: 'faultedCount',
+    countOfCompleted: 'completedCount',
+    countOfCancelled: 'cancelledCount',
+    countOfDeleted: 'deletedCount'
+};
+
 /**
  * Maestro Process Models
  * Model classes for Maestro processes
@@ -9886,7 +10416,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] });
         }
     };
 }
@@ -9903,226 +10462,41 @@ function createProcessWithMethods(processData, service) {
 }
 
 /**
- * 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 } : {}),
-        }
-    };
-}
-/**
- * Fetches instance status timeline from the Insights API.
- * Shared implementation used by both MaestroProcessesService and CasesService.
- *
- * @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,
+        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);
         },
-        timeSliceUnit: options?.groupBy,
-        timezoneOffset: new Date().getTimezoneOffset() * -1,
-    });
-    return response.data ?? [];
-}
-/**
- * Builds the request body for the ElementCountByStatus endpoint.
- *
- * @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
- * @internal
- */
-function buildElementCountByStatusBody(processKey, packageId, startTime, endTime, packageVersion) {
-    return {
-        commonParams: {
-            processKey,
-            packageId,
-            startTime: startTime.getTime(),
-            endTime: endTime.getTime(),
-            version: 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) {
+        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.cancel(instanceData.instanceId, instanceData.folderKey, options);
+            return service.pause(instanceData.instanceId, instanceData.folderKey, options);
         },
-        async pause(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.pause(instanceData.instanceId, instanceData.folderKey, options);
+            return service.resume(instanceData.instanceId, instanceData.folderKey, options);
         },
-        async resume(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.resume(instanceData.instanceId, instanceData.folderKey, options);
+            return service.retry(instanceData.instanceId, instanceData.folderKey, options);
         },
         async getIncidents() {
             if (!instanceData.instanceId)
@@ -10220,7 +10594,36 @@ function createCaseMethods(caseData, service) {
                 throw new Error('Process key is undefined');
             if (!caseData.packageId)
                 throw new Error('Package ID is undefined');
-            return service.getElementStats(caseData.processKey, caseData.packageId, startTime, endTime, packageVersion);
+            return service.getElementStats({
+                processKey: caseData.processKey,
+                packageId: caseData.packageId,
+                packageVersion,
+                startTime,
+                endTime,
+            });
+        },
+        getInstanceStats(startTime, endTime, packageVersion) {
+            if (!caseData.processKey)
+                throw new Error('Process key is undefined');
+            if (!caseData.packageId)
+                throw new Error('Package ID is undefined');
+            return service.getInstanceStats({
+                processKey: caseData.processKey,
+                packageId: caseData.packageId,
+                packageVersion,
+                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] });
         }
     };
 }
@@ -10389,54 +10792,244 @@ function createCaseInstanceMethods(instanceData, service) {
                 throw new Error('Case instance ID is undefined');
             return service.getStagesSlaSummary({ caseInstanceId: instanceData.instanceId });
         }
-    };
-}
-/**
- * Creates an actionable case instance by combining API case instance data with operational methods.
- *
- * @param instanceData - The case instance data from API
- * @param service - The case instance service instance
- * @returns A case instance object with added methods
- */
-function createCaseInstanceWithMethods(instanceData, service) {
-    const methods = createCaseInstanceMethods(instanceData, service);
-    return Object.assign({}, instanceData, methods);
+    };
+}
+/**
+ * Creates an actionable case instance by combining API case instance data with operational methods.
+ *
+ * @param instanceData - The case instance data from API
+ * @param service - The case instance service instance
+ * @returns A case instance object with added methods
+ */
+function createCaseInstanceWithMethods(instanceData, service) {
+    const methods = createCaseInstanceMethods(instanceData, service);
+    return Object.assign({}, instanceData, methods);
+}
+
+/**
+ * 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.
+ */
+exports.TimeInterval = void 0;
+(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";
+})(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.
+ */
+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
+ */
+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
+        };
+    }
 }
 
-/**
- * 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.
- */
-exports.TimeInterval = void 0;
-(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";
-})(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.
- */
-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 = {}));
-
 /**
  * Maps fields for Process Instance entities to ensure consistent naming
  */
@@ -10512,7 +11105,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>
@@ -10651,6 +11244,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
@@ -10801,6 +11413,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);
@@ -10957,7 +11572,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
@@ -10984,12 +11599,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.
@@ -11084,22 +11754,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) {
@@ -11107,12 +11777,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')
@@ -11129,6 +11845,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);
@@ -11138,6 +11857,9 @@ __decorate([
 __decorate([
     track('MaestroProcesses.GetElementStats')
 ], MaestroProcessesService.prototype, "getElementStats", null);
+__decorate([
+    track('MaestroProcesses.GetInstanceStats')
+], MaestroProcessesService.prototype, "getInstanceStats", null);
 
 /**
  * Service class for Maestro Process Incidents
@@ -11318,7 +12040,7 @@ class CasesService 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
@@ -11345,12 +12067,67 @@ class CasesService extends BaseService {
      *
      * @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.
@@ -11445,34 +12222,79 @@ class CasesService 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 case.
      *
-     * @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 case
-     * const elements = await cases.getElementStats(
-     *   '<processKey>',
-     *   '<packageId>',
-     *   new Date('2026-04-01'),
-     *   new Date(),
-     *   '1.0.1'
-     * );
+     * // First, list cases to find the processKey, packageId, and available versions
+     * const allCases = await cases.getAll();
+     * const caseItem = allCases[0];
+     *
+     * // Get element metrics for that case
+     * const elements = await cases.getElementStats({
+     *   processKey: caseItem.processKey,
+     *   packageId: caseItem.packageId,
+     *   packageVersion: caseItem.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
      *
      * // Find elements with failures
      * const failedElements = elements.filter(e => e.failCount > 0);
      * for (const element of failedElements) {
      *   console.log(`Failed element: ${element.elementId}, failures: ${element.failCount}`);
      * }
+     *
+     * // Using bound method on a case — auto-fills processKey and packageId
+     * const boundElements = await caseItem.getElementStats(
+     *   new Date('2026-04-01'),
+     *   new Date(),
+     *   caseItem.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 case.
+     *
+     * Returns total instance counts broken down by status (running, completed, faulted, etc.)
+     * and the average execution duration for all instances of a case within a time range.
+     *
+     * @param request - Process scope + time range to aggregate over
+     * @returns Promise resolving to {@link InstanceStats}
+     * @example
+     * ```typescript
+     * // First, list cases to find the processKey, packageId, and available versions
+     * const allCases = await cases.getAll();
+     * const caseItem = allCases[0];
+     *
+     * // Get instance status breakdown for that case
+     * const counts = await cases.getInstanceStats({
+     *   processKey: caseItem.processKey,
+     *   packageId: caseItem.packageId,
+     *   packageVersion: caseItem.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
+     *
+     * console.log(`Total: ${counts.totalCount}`);
+     * console.log(`Completed: ${counts.completedCount}, Faulted: ${counts.faultedCount}`);
+     *
+     * // Using bound method on a case — auto-fills processKey and packageId
+     * const boundCounts = await caseItem.getInstanceStats(
+     *   new Date('2026-04-01'),
+     *   new Date(),
+     *   caseItem.packageVersions[0]
+     * );
+     * ```
+     */
+    async getInstanceStats(request) {
+        const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.INSTANCE_COUNT_BY_STATUS, buildInsightsCommonBody(request));
+        return transformData(data, InstanceStatsMap);
+    }
     /**
      * Extract a readable case name from the packageId
      * @param packageId - The full package identifier
@@ -11504,6 +12326,9 @@ __decorate([
 __decorate([
     track('Cases.GetInstanceStatusTimeline')
 ], CasesService.prototype, "getInstanceStatusTimeline", null);
+__decorate([
+    track('Cases.GetIncidentsTimeline')
+], CasesService.prototype, "getIncidentsTimeline", null);
 __decorate([
     track('Cases.GetTopFaultedCount')
 ], CasesService.prototype, "getTopFaultedCount", null);
@@ -11513,6 +12338,9 @@ __decorate([
 __decorate([
     track('Cases.GetElementStats')
 ], CasesService.prototype, "getElementStats", null);
+__decorate([
+    track('Cases.GetInstanceStats')
+], CasesService.prototype, "getInstanceStats", null);
 
 /**
  * Maps fields for Case Instance entities to ensure consistent naming
@@ -11818,6 +12646,10 @@ class TaskService extends BaseService {
             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,
@@ -11834,7 +12666,7 @@ class TaskService extends BaseService {
                     countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM // OData OFFSET parameter
                 }
             }
-        }, options);
+        }, apiOptions);
     }
     /**
      * Gets a task by ID
@@ -11870,9 +12702,10 @@ class TaskService extends BaseService {
         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
@@ -12865,9 +13698,12 @@ class FolderScopedService extends BaseService {
      * @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({
@@ -12877,8 +13713,11 @@ class FolderScopedService extends BaseService {
             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',
         };
@@ -12978,6 +13817,10 @@ class AssetService extends FolderScopedService {
     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,
@@ -12993,7 +13836,7 @@ class AssetService extends FolderScopedService {
                     countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
                 }
             }
-        }, options);
+        }, apiOptions);
     }
     /**
      * Gets a single asset by ID
@@ -13015,8 +13858,8 @@ class AssetService extends FolderScopedService {
      */
     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
@@ -13051,7 +13894,7 @@ class AssetService extends FolderScopedService {
      * ```
      */
     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.
@@ -13325,6 +14168,9 @@ class BucketService extends FolderScopedService {
         });
         // 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),
@@ -13340,7 +14186,7 @@ class BucketService extends FolderScopedService {
             },
             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.
@@ -13424,9 +14270,10 @@ class BucketService extends FolderScopedService {
             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);
     }
@@ -13546,6 +14393,9 @@ class BucketService extends FolderScopedService {
             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),
@@ -13562,7 +14412,7 @@ class BucketService extends FolderScopedService {
             },
             excludeFromPrefix: ['directory', 'recursive', 'fileNameRegex'],
             headers,
-        }, { ...restOptions, directory: '/', recursive: true });
+        }, { ...apiRestOptions, directory: '/', recursive: true });
     }
     /**
      * Deletes a file from a bucket
@@ -13609,9 +14459,10 @@ class BucketService extends FolderScopedService {
      */
     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);
     }
@@ -13744,9 +14595,10 @@ class AttachmentService extends BaseService {
         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,
         });
@@ -13970,8 +14822,9 @@ class JobService extends FolderScopedService {
      * const folderJobs = await jobs.getAll({ folderId: <folderId> });
      *
      * // With filtering
-     * const runningJobs = await jobs.getAll({
-     *   filter: "state eq 'Running'"
+     * const recentInvoiceJobs = await jobs.getAll({
+     *   filter: "processName eq 'InvoiceBot'",
+     *   orderby: 'createdTime desc',
      * });
      *
      * // First page with pagination
@@ -13994,6 +14847,10 @@ class JobService extends FolderScopedService {
             const rawJob = transformData(pascalToCamelCaseKeys(job), JobMap);
             return createJobWithMethods(rawJob, 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, JobMap) : options;
         return PaginationHelpers.getAll({
             serviceAccess: this.createPaginationServiceAccess(),
             getEndpoint: () => JOB_ENDPOINTS.GET_ALL,
@@ -14009,7 +14866,7 @@ class JobService extends FolderScopedService {
                     countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM,
                 },
             },
-        }, options);
+        }, apiOptions);
     }
     /**
      * Gets a job by its unique key (GUID).
@@ -14046,8 +14903,8 @@ class JobService extends FolderScopedService {
             throw new ValidationError({ message: 'folderId is required for getById' });
         }
         const headers = createHeaders({ [FOLDER_ID]: folderId });
-        const keysToPrefix = Object.keys(options ?? {});
-        const apiOptions = options ? addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix) : {};
+        const apiFieldOptions = options ? transformOptions(options, JobMap) : {};
+        const apiOptions = addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions));
         const response = await this.get(JOB_ENDPOINTS.GET_BY_KEY(id), {
             params: apiOptions,
             headers,
@@ -14350,6 +15207,9 @@ exports.JobState = void 0;
     JobState["Stopped"] = "Stopped";
     JobState["Suspended"] = "Suspended";
     JobState["Resumed"] = "Resumed";
+    JobState["Cancelled"] = "Cancelled";
+    /** Server-side fallback for an unrecognized or missing job state. */
+    JobState["Unknown"] = "Unknown";
 })(exports.JobState || (exports.JobState = {}));
 
 /**
@@ -14420,6 +15280,10 @@ class ProcessService extends FolderScopedService {
     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,
@@ -14435,7 +15299,7 @@ class ProcessService extends FolderScopedService {
                     countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
                 }
             }
-        }, options);
+        }, apiOptions);
     }
     async start(request, optionsOrFolderId, legacyOptions) {
         // Normalize the two overload forms into a single internal shape.
@@ -14469,9 +15333,10 @@ class ProcessService extends FolderScopedService {
         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
@@ -14499,8 +15364,8 @@ class ProcessService extends FolderScopedService {
      */
     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
@@ -14535,7 +15400,7 @@ class ProcessService extends FolderScopedService {
      * ```
      */
     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([
@@ -14611,6 +15476,10 @@ class QueueService extends FolderScopedService {
     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,
@@ -14626,7 +15495,7 @@ class QueueService extends FolderScopedService {
                     countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
                 }
             }
-        }, options);
+        }, apiOptions);
     }
     /**
      * Gets a single queue by ID
@@ -14647,8 +15516,8 @@ class QueueService extends FolderScopedService {
      */
     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
@@ -14743,7 +15612,19 @@ class UiPath extends UiPath$1 {
             /**
              * 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)
         });
     }
     /**
@@ -15071,9 +15952,9 @@ exports.AgentListSortColumn = void 0;
     AgentListSortColumn["HealthScore"] = "HealthScore";
     AgentListSortColumn["LastIncident"] = "LastIncident";
     AgentListSortColumn["FolderName"] = "FolderName";
-    /** Quantity of AGU (Agent Units) consumed */
+    /** Quantity of Agent Units consumed */
     AgentListSortColumn["QuantityAGU"] = "QuantityAGU";
-    /** Quantity of PLTU (Platform Units) consumed */
+    /** Quantity of Platform Units consumed */
     AgentListSortColumn["QuantityPLTU"] = "QuantityPLTU";
     AgentListSortColumn["FolderPath"] = "FolderPath";
 })(exports.AgentListSortColumn || (exports.AgentListSortColumn = {}));
@@ -15095,6 +15976,30 @@ exports.AgentErrorSortColumn = void 0;
     AgentErrorSortColumn["LastSeenFolderName"] = "LastSeenFolderName";
     AgentErrorSortColumn["LastSeenFolderPath"] = "LastSeenFolderPath";
 })(exports.AgentErrorSortColumn || (exports.AgentErrorSortColumn = {}));
+/**
+ * Agent type, used to filter consumption results.
+ *
+ * Wire format is the string name, per the API's `StringEnumConverter` serialization.
+ */
+exports.AgentType = void 0;
+(function (AgentType) {
+    AgentType["Autonomous"] = "Autonomous";
+    AgentType["Conversational"] = "Conversational";
+    AgentType["Coded"] = "Coded";
+})(exports.AgentType || (exports.AgentType = {}));
+/**
+ * Job execution mode filter accepted by the summary endpoints.
+ *
+ * Wire format is the string name (`"Debug"` / `"Runtime"`), per the API's
+ * `StringEnumConverter` serialization.
+ */
+exports.AgentExecutionType = void 0;
+(function (AgentExecutionType) {
+    /** Test runs */
+    AgentExecutionType["Debug"] = "Debug";
+    /** Production runs */
+    AgentExecutionType["Runtime"] = "Runtime";
+})(exports.AgentExecutionType || (exports.AgentExecutionType = {}));
 
 /**
  * Types for the Agent Memory metrics service.
@@ -15479,6 +16384,52 @@ exports.SpanAttachmentDirection = void 0;
     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
  *