@uipath/uipath-typescript 1.4.2 → 1.5.1

package/dist/cases/index.cjs

@@ -45,214 +45,867 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 /**
- * Internal types for Maestro Cases
- * These types are used internally by the cases service
- */
-/**
- * Process type enum for filtering
- */
-var ProcessType;
-(function (ProcessType) {
-    ProcessType["CaseManagement"] = "CaseManagement";
-})(ProcessType || (ProcessType = {}));
-
-/**
- * Base path constants for different services
- */
-const ORCHESTRATOR_BASE = 'orchestrator_';
-const PIMS_BASE = 'pims_';
-const LLMOPS_BASE = 'llmopstenant_';
-const INSIGHTS_RTM_BASE = 'insightsrtm_';
-
-/**
- * Orchestrator Service Endpoints
- */
-/**
- * Task Service (Action Center) Endpoints
- */
-const TASK_ENDPOINTS = {
-    CREATE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CreateTask`,
-    GET_TASK_USERS: (folderId) => `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTaskUsers(organizationUnitId=${folderId})`,
-    GET_TASKS_ACROSS_FOLDERS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFolders`,
-    GET_TASKS_ACROSS_FOLDERS_ADMIN: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFoldersForAdmin`,
-    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Tasks(${id})`,
-    ASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks`,
-    REASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.ReassignTasks`,
-    UNASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.UnassignTasks`,
-    COMPLETE_FORM_TASK: `${ORCHESTRATOR_BASE}/forms/TaskForms/CompleteTask`,
-    COMPLETE_APP_TASK: `${ORCHESTRATOR_BASE}/tasks/AppTasks/CompleteAppTask`,
-    COMPLETE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CompleteTask`,
-    GET_TASK_FORM_BY_ID: `${ORCHESTRATOR_BASE}/forms/TaskForms/GetTaskFormById`,
-    GET_GENERIC_TASK_BY_ID: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/GetTaskDataById`,
-    GET_APP_TASK_BY_ID: `${ORCHESTRATOR_BASE}/tasks/AppTasks/GetAppTaskById`,
-};
-
-/**
- * Maestro Service Endpoints
+ * Maps API field names (countOf*) to SDK field names (*Count) for InstanceStats,
+ * aligning naming with ElementStats and other count-suffixed conventions.
  */
-/**
- * Maestro Process Service Endpoints
- */
-const MAESTRO_ENDPOINTS = {
-    PROCESSES: {
-        GET_ALL: `${PIMS_BASE}/api/v1/processes/summary`,
-        GET_SETTINGS: (processKey) => `${PIMS_BASE}/api/v1/processes/${processKey}/settings`,
-    },
-    INSTANCES: {
-        GET_ALL: `${PIMS_BASE}/api/v1/instances`,
-        GET_BY_ID: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}`,
-        GET_ELEMENT_EXECUTIONS: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/element-executions`,
-        GET_BPMN: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/bpmn`,
-        GET_VARIABLES: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/variables`,
-        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`,
-    },
-    INCIDENTS: {
-        GET_ALL: `${PIMS_BASE}/api/v1/incidents/summary`,
-        GET_BY_PROCESS: (processKey) => `${PIMS_BASE}/api/v1/incidents/process/${processKey}`,
-        GET_BY_INSTANCE: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/incidents`,
-    },
-    TRACES: {
-        GET_SPANS: (traceId) => `${LLMOPS_BASE}/api/Traces/spans?traceId=${traceId}`,
-    },
-    CASES: {
-        GET_CASE_JSON: (instanceId) => `${PIMS_BASE}/api/v1/cases/${instanceId}/case-json`,
-        GET_ELEMENT_EXECUTIONS: (instanceId) => `${PIMS_BASE}/api/v1/element-executions/case-instances/${instanceId}`,
-        REOPEN: (instanceId) => `${PIMS_BASE}/api/v1/cases/${instanceId}/reopen`,
-    },
-    INSIGHTS: {
-        /** SLA summary for case instances */
-        SLA_SUMMARY: `${INSIGHTS_RTM_BASE}/caseManagement/slaSummary`,
-        /** Stages summary for case instances */
-        STAGES_SUMMARY: `${INSIGHTS_RTM_BASE}/caseManagement/stages`,
-        /** Top processes ranked by run count */
-        TOP_PROCESSES_BY_RUN_COUNT: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopProcessesByRunCount`,
-        /** Top processes ranked by failure count */
-        TOP_PROCESSES_WITH_FAILURE: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopProcesseswithFailure`,
-        /** Top elements ranked by failure count */
-        TOP_ELEMENTS_WITH_FAILURE: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopElementswithFailure`,
-        /** Instance status aggregated by date for time-series charts */
-        INSTANCE_STATUS_BY_DATE: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/InstanceStatusByDate`,
-        /** Top processes ranked by total duration */
-        TOP_PROCESSES_BY_DURATION: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopProcessesByDuration`,
-        /** Element count by status for agentic instances (process and case) */
-        ELEMENT_COUNT_BY_STATUS: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/ElementCountByStatus`,
-    },
+const InstanceStatsMap = {
+    countOfAllInstances: 'totalCount',
+    countOfRunning: 'runningCount',
+    countOfTransitioning: 'transitioningCount',
+    countOfPaused: 'pausedCount',
+    countOfFaulted: 'faultedCount',
+    countOfCompleted: 'completedCount',
+    countOfCancelled: 'cancelledCount',
+    countOfDeleted: 'deletedCount'
 };
 
 /**
- * Maestro Cases Models
- * Model classes for Maestro cases
- */
-/**
- * Creates methods for a case object
- *
- * @param caseData - The case data (response from API)
- * @param service - The cases service instance
- * @returns Object containing case methods
+ * Converts a UTC timestamp string (e.g., "5/8/2026 11:20:17 AM") to ISO 8601 UTC format.
+ * Returns the original value if parsing fails.
  */
-function createCaseMethods(caseData, service) {
-    return {
-        getElementStats(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.getElementStats(caseData.processKey, caseData.packageId, startTime, endTime, packageVersion);
-        }
-    };
+function toISOUtc(value) {
+    const date = new Date(value + ' UTC');
+    return isNaN(date.getTime()) ? value : date.toISOString();
 }
 /**
- * Creates an actionable case by combining API case data with operational methods.
+ * 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.
  *
- * @param caseData - The case data from API
- * @param service - The cases service instance
- * @returns A case object with added methods
+ * Each rename is independent. If the mapping happens to contain chained
+ * entries (`a → b` and `b → c`), they do NOT compose: a field named `a`
+ * in `data` becomes `b` (not `c`), because the renames are applied based
+ * on the original data's keys, not the running result.
+ *
+ * @param data The source data to transform
+ * @param fieldMapping Object mapping source field names to target field names
+ * @returns Transformed data with mapped field names
+ *
+ * @example
+ * ```typescript
+ * // Single object transformation
+ * const data = { id: '123', userName: 'john' };
+ * const mapping = { id: 'userId', userName: 'name' };
+ * const result = transformData(data, mapping);
+ * // result = { userId: '123', name: 'john' }
+ *
+ * // Array transformation
+ * const dataArray = [
+ *   { id: '123', userName: 'john' },
+ *   { id: '456', userName: 'jane' }
+ * ];
+ * const result = transformData(dataArray, mapping);
+ * // result = [
+ * //   { userId: '123', name: 'john' },
+ * //   { userId: '456', name: 'jane' }
+ * // ]
+ *
+ * // No chaining — `a → b` does not become `a → c` even if the map has `b → c`.
+ * transformData({ a: 1 }, { a: 'b', b: 'c' });
+ * // result = { b: 1 }
+ * ```
  */
-function createCaseWithMethods(caseData, service) {
-    const methods = createCaseMethods(caseData, service);
-    return Object.assign({}, caseData, methods);
+function transformData(data, fieldMapping) {
+    // Pass null/undefined through unchanged — callers (e.g. AttachmentService.getById)
+    // may invoke this on optional fields that an OData `select` excluded.
+    if (data == null) {
+        return data;
+    }
+    // Handle array of objects
+    if (Array.isArray(data)) {
+        return data.map(item => transformData(item, fieldMapping));
+    }
+    // Walk the ORIGINAL data's keys, look up each in the mapping. One rename
+    // per data key — no mutation of an in-progress result, so chains can't form.
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const renamedKey = fieldMapping[key] ?? key;
+        result[renamedKey] = value;
+    }
+    return result;
 }
-
 /**
- * Builds the request body for Insights RTM "top" endpoints.
+ * Converts a string from PascalCase to camelCase
+ * @param str The PascalCase string to convert
+ * @returns The camelCase version of the string
  *
- * @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
+ * @example
+ * ```typescript
+ * pascalToCamelCase('HelloWorld'); // 'helloWorld'
+ * pascalToCamelCase('TaskAssignmentCriteria'); // 'taskAssignmentCriteria'
+ * ```
  */
-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 } : {}),
-        }
-    };
+function pascalToCamelCase(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toLowerCase() + str.slice(1);
 }
 /**
- * Fetches instance status timeline from the Insights API.
- * Shared implementation used by both MaestroProcessesService and CasesService.
+ * Converts a string from camelCase to PascalCase
+ * @param str The camelCase string to convert
+ * @returns The PascalCase version of the string
  *
- * @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
+ * @example
+ * ```typescript
+ * camelToPascalCase('helloWorld'); // 'HelloWorld'
+ * camelToPascalCase('taskAssignmentCriteria'); // 'TaskAssignmentCriteria'
+ * ```
  */
-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 ?? [];
+function camelToPascalCase(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
 }
 /**
- * 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
+ * Generic function to transform object keys using a provided case conversion function
+ * @param data The object to transform
+ * @param convertCase The function to convert each key
+ * @returns A new object with transformed keys
  */
-function buildElementCountByStatusBody(processKey, packageId, startTime, endTime, packageVersion) {
-    return {
-        commonParams: {
-            processKey,
-            packageId,
-            startTime: startTime.getTime(),
-            endTime: endTime.getTime(),
-            version: packageVersion
+function transformCaseKeys(data, convertCase) {
+    // Handle array of objects
+    if (Array.isArray(data)) {
+        return data.map(item => {
+            // If the array element is a primitive (string, number, etc.), return it as is
+            if (item === null || typeof item !== 'object' || typeof item === 'string') {
+                return item;
+            }
+            // Only recursively transform if it's actually an object
+            return transformCaseKeys(item, convertCase);
+        });
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const transformedKey = convertCase(key);
+        // Recursively transform nested objects and arrays
+        if (value !== null && typeof value === 'object') {
+            result[transformedKey] = transformCaseKeys(value, convertCase);
         }
-    };
+        else {
+            result[transformedKey] = value;
+        }
+    }
+    return result;
 }
-
 /**
- * Type guards for error response types
- */
-function isOrchestratorError(error) {
-    return typeof error === 'object' &&
-        error !== null &&
-        'message' in error &&
-        'errorCode' in error &&
-        typeof error.message === 'string' &&
+ * Transforms an object's keys from PascalCase to camelCase
+ * @param data The object with PascalCase keys
+ * @returns A new object with all keys converted to camelCase
+ *
+ * @example
+ * ```typescript
+ * // Simple object
+ * pascalToCamelCaseKeys({ Id: "123", TaskName: "Invoice" });
+ * // Result: { id: "123", taskName: "Invoice" }
+ *
+ * // Nested object
+ * pascalToCamelCaseKeys({
+ *   TaskId: "456",
+ *   TaskDetails: { AssignedUser: "John", Priority: "High" }
+ * });
+ * // Result: {
+ * //   taskId: "456",
+ * //   taskDetails: { assignedUser: "John", priority: "High" }
+ * // }
+ *
+ * // Array of objects
+ * pascalToCamelCaseKeys([
+ *   { Id: "1", IsComplete: false },
+ *   { Id: "2", IsComplete: true }
+ * ]);
+ * // Result: [
+ * //   { id: "1", isComplete: false },
+ * //   { id: "2", isComplete: true }
+ * // ]
+ * ```
+ */
+function pascalToCamelCaseKeys(data) {
+    return transformCaseKeys(data, pascalToCamelCase);
+}
+/**
+ * Transforms an object's keys from camelCase to PascalCase
+ * @param data The object with camelCase keys
+ * @returns A new object with all keys converted to PascalCase
+ *
+ * @example
+ * ```typescript
+ * // Simple object
+ * camelToPascalCaseKeys({ userId: "789", isActive: true });
+ * // Result: { UserId: "789", IsActive: true }
+ *
+ * // Nested object
+ * camelToPascalCaseKeys({
+ *   taskId: "ABC123",
+ *   submissionData: { customerName: "XYZ Corp" }
+ * });
+ * // Result: {
+ * //   TaskId: "ABC123",
+ * //   SubmissionData: { CustomerName: "XYZ Corp" }
+ * // }
+ *
+ * // Array of objects
+ * camelToPascalCaseKeys([
+ *   { userId: "u1", roleType: "admin" },
+ *   { userId: "u2", roleType: "user" }
+ * ]);
+ * // Result: [
+ * //   { UserId: "u1", RoleType: "admin" },
+ * //   { UserId: "u2", RoleType: "user" }
+ * // ]
+ * ```
+ */
+function camelToPascalCaseKeys(data) {
+    return transformCaseKeys(data, camelToPascalCase);
+}
+/**
+ * Maps a field value in an object using a provided mapping object.
+ * Returns a new object with the mapped field value.
+ *
+ * @param obj The object to map
+ * @param field The field name to map
+ * @param valueMap The mapping object (from input value to output value)
+ * @returns A new object with the mapped field value
+ *
+ * @example
+ * const statusMap = { 0: 'Unassigned', 1: 'Pending', 2: 'Completed' };
+ * const task = { status: 1, id: 123 };
+ * const mapped = mapFieldValue(task, 'status', statusMap);
+ * // mapped = { status: 'Pending', id: 123 }
+ */
+function _mapFieldValue(obj, field, valueMap) {
+    const lookupKey = String(obj[field]);
+    return {
+        ...obj,
+        [field]: lookupKey in valueMap
+            ? valueMap[lookupKey]
+            : obj[field],
+    };
+}
+/**
+ * General API response transformer with optional field value mapping.
+ *
+ * @param data - The API response data to transform
+ * @param options - Optional mapping options:
+ *   - field: The field name to map (optional)
+ *   - valueMap: The mapping object for the field (optional)
+ *   - transform: A function to further transform the data (optional)
+ * @returns The transformed data, with field value mapped if specified
+ *
+ * @example
+ * // Just transform
+ * const result = applyDataTransforms(data);
+ *
+ * // Map a field value, then transform
+ * const result = applyDataTransforms(data, { field: 'status', valueMap: StatusMap });
+ *
+ * // Map a field value, then apply a custom transform
+ * const result = applyDataTransforms(data, { field: 'status', valueMap: StatusMap, transform: customTransform });
+ */
+function applyDataTransforms(data, options) {
+    let result = data;
+    if (options?.field && options?.valueMap) {
+        result = _mapFieldValue(result, options.field, options.valueMap);
+    }
+    if (options?.transform) {
+        result = options.transform(result);
+    }
+    return result;
+}
+/**
+ * Adds a prefix to specified keys in an object, returning a new object.
+ * Only the provided keys are prefixed; all others are left unchanged.
+ *
+ * @param obj The source object
+ * @param prefix The prefix to add (e.g., '$')
+ * @param keys The keys to prefix (e.g., ['expand', 'filter'])
+ * @returns A new object with specified keys prefixed
+ *
+ * @example
+ * addPrefixToKeys({ expand: 'a', foo: 1 }, '$', ['expand']) // { $expand: 'a', foo: 1 }
+ */
+function addPrefixToKeys(obj, prefix, keys) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (keys.includes(key)) {
+            result[`${prefix}${key}`] = value;
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Creates a new map with the keys and values reversed
+ * @param map The original map to reverse
+ * @returns A new map with keys and values swapped
+ *
+ * @example
+ * ```typescript
+ * const original = { key1: 'value1', key2: 'value2' };
+ * const reversed = reverseMap(original);
+ * // reversed = { value1: 'key1', value2: 'key2' }
+ * ```
+ */
+function reverseMap(map) {
+    return Object.entries(map).reduce((acc, [key, value]) => {
+        acc[value] = key;
+        return acc;
+    }, {});
+}
+/**
+ * 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;
+}
+
+/**
+ * Internal types for Maestro Cases
+ * These types are used internally by the cases service
+ */
+/**
+ * Process type enum for filtering
+ */
+var ProcessType;
+(function (ProcessType) {
+    ProcessType["CaseManagement"] = "CaseManagement";
+})(ProcessType || (ProcessType = {}));
+
+/**
+ * Base path constants for different services
+ */
+const ORCHESTRATOR_BASE = 'orchestrator_';
+const PIMS_BASE = 'pims_';
+const LLMOPS_BASE = 'llmopstenant_';
+const INSIGHTS_RTM_BASE = 'insightsrtm_';
+
+/**
+ * Orchestrator Service Endpoints
+ */
+/**
+ * Task Service (Action Center) Endpoints
+ */
+const TASK_ENDPOINTS = {
+    CREATE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CreateTask`,
+    GET_TASK_USERS: (folderId) => `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTaskUsers(organizationUnitId=${folderId})`,
+    GET_TASKS_ACROSS_FOLDERS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFolders`,
+    GET_TASKS_ACROSS_FOLDERS_ADMIN: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFoldersForAdmin`,
+    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Tasks(${id})`,
+    ASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks`,
+    REASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.ReassignTasks`,
+    UNASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.UnassignTasks`,
+    COMPLETE_FORM_TASK: `${ORCHESTRATOR_BASE}/forms/TaskForms/CompleteTask`,
+    COMPLETE_APP_TASK: `${ORCHESTRATOR_BASE}/tasks/AppTasks/CompleteAppTask`,
+    COMPLETE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CompleteTask`,
+    GET_TASK_FORM_BY_ID: `${ORCHESTRATOR_BASE}/forms/TaskForms/GetTaskFormById`,
+    GET_GENERIC_TASK_BY_ID: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/GetTaskDataById`,
+    GET_APP_TASK_BY_ID: `${ORCHESTRATOR_BASE}/tasks/AppTasks/GetAppTaskById`,
+};
+
+/**
+ * Maestro Service Endpoints
+ */
+/**
+ * Maestro Process Service Endpoints
+ */
+const MAESTRO_ENDPOINTS = {
+    PROCESSES: {
+        GET_ALL: `${PIMS_BASE}/api/v1/processes/summary`,
+        GET_SETTINGS: (processKey) => `${PIMS_BASE}/api/v1/processes/${processKey}/settings`,
+    },
+    INSTANCES: {
+        GET_ALL: `${PIMS_BASE}/api/v1/instances`,
+        GET_BY_ID: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}`,
+        GET_ELEMENT_EXECUTIONS: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/element-executions`,
+        GET_BPMN: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/bpmn`,
+        GET_VARIABLES: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/variables`,
+        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`,
+        GET_BY_PROCESS: (processKey) => `${PIMS_BASE}/api/v1/incidents/process/${processKey}`,
+        GET_BY_INSTANCE: (instanceId) => `${PIMS_BASE}/api/v1/instances/${instanceId}/incidents`,
+    },
+    TRACES: {
+        GET_SPANS: (traceId) => `${LLMOPS_BASE}/api/Traces/spans?traceId=${traceId}`,
+    },
+    CASES: {
+        GET_CASE_JSON: (instanceId) => `${PIMS_BASE}/api/v1/cases/${instanceId}/case-json`,
+        GET_ELEMENT_EXECUTIONS: (instanceId) => `${PIMS_BASE}/api/v1/element-executions/case-instances/${instanceId}`,
+        REOPEN: (instanceId) => `${PIMS_BASE}/api/v1/cases/${instanceId}/reopen`,
+    },
+    INSIGHTS: {
+        /** SLA summary for case instances */
+        SLA_SUMMARY: `${INSIGHTS_RTM_BASE}/caseManagement/slaSummary`,
+        /** Stages summary for case instances */
+        STAGES_SUMMARY: `${INSIGHTS_RTM_BASE}/caseManagement/stages`,
+        /** Top processes ranked by run count */
+        TOP_PROCESSES_BY_RUN_COUNT: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopProcessesByRunCount`,
+        /** Top processes ranked by failure count */
+        TOP_PROCESSES_WITH_FAILURE: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopProcesseswithFailure`,
+        /** Top elements ranked by failure count */
+        TOP_ELEMENTS_WITH_FAILURE: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopElementswithFailure`,
+        /** Instance status aggregated by date for time-series charts */
+        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`,
+    },
+};
+
+/**
+ * Maestro Cases Models
+ * Model classes for Maestro cases
+ */
+/**
+ * Creates methods for a case object
+ *
+ * @param caseData - The case data (response from API)
+ * @param service - The cases service instance
+ * @returns Object containing case methods
+ */
+function createCaseMethods(caseData, service) {
+    return {
+        getElementStats(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.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] });
+        }
+    };
+}
+/**
+ * Creates an actionable case by combining API case data with operational methods.
+ *
+ * @param caseData - The case data from API
+ * @param service - The cases service instance
+ * @returns A case object with added methods
+ */
+function createCaseWithMethods(caseData, service) {
+    const methods = createCaseMethods(caseData, service);
+    return Object.assign({}, caseData, methods);
+}
+
+/**
+ * Process Incident Status
+ */
+var ProcessIncidentStatus;
+(function (ProcessIncidentStatus) {
+    ProcessIncidentStatus["Open"] = "Open";
+    ProcessIncidentStatus["Closed"] = "Closed";
+})(ProcessIncidentStatus || (ProcessIncidentStatus = {}));
+/**
+ * Process Incident Type
+ */
+var ProcessIncidentType;
+(function (ProcessIncidentType) {
+    ProcessIncidentType["System"] = "System";
+    ProcessIncidentType["User"] = "User";
+    ProcessIncidentType["Deployment"] = "Deployment";
+})(ProcessIncidentType || (ProcessIncidentType = {}));
+/**
+ * Process Incident Severity
+ */
+var ProcessIncidentSeverity;
+(function (ProcessIncidentSeverity) {
+    ProcessIncidentSeverity["Error"] = "Error";
+    ProcessIncidentSeverity["Warning"] = "Warning";
+})(ProcessIncidentSeverity || (ProcessIncidentSeverity = {}));
+/**
+ * Process Incident Debug Mode
+ */
+var DebugMode;
+(function (DebugMode) {
+    DebugMode["None"] = "None";
+    DebugMode["Default"] = "Default";
+    DebugMode["StepByStep"] = "StepByStep";
+    DebugMode["SingleStep"] = "SingleStep";
+})(DebugMode || (DebugMode = {}));
+
+/**
+ * Case Instance Types
+ * Types and interfaces for Maestro case instance management
+ */
+/**
+ * SLA status for a case instance
+ */
+exports.SlaSummaryStatus = void 0;
+(function (SlaSummaryStatus) {
+    /** Case is within SLA deadline */
+    SlaSummaryStatus["ON_TRACK"] = "On Track";
+    /** Case is approaching SLA deadline based on at-risk percentage threshold */
+    SlaSummaryStatus["AT_RISK"] = "At Risk";
+    /** Case has exceeded SLA deadline */
+    SlaSummaryStatus["OVERDUE"] = "Overdue";
+    /** Case instance has completed */
+    SlaSummaryStatus["COMPLETED"] = "Completed";
+    /** SLA status cannot be determined (no SLA deadline defined) */
+    SlaSummaryStatus["UNKNOWN"] = "Unknown";
+})(exports.SlaSummaryStatus || (exports.SlaSummaryStatus = {}));
+/**
+ * Instance status values for case instances and process instances
+ */
+exports.InstanceStatus = void 0;
+(function (InstanceStatus) {
+    /** Instance status not yet populated by the backend */
+    InstanceStatus["UNKNOWN"] = "";
+    InstanceStatus["CANCELLED"] = "Cancelled";
+    InstanceStatus["CANCELING"] = "Canceling";
+    InstanceStatus["COMPLETED"] = "Completed";
+    InstanceStatus["FAULTED"] = "Faulted";
+    InstanceStatus["PAUSED"] = "Paused";
+    InstanceStatus["PAUSING"] = "Pausing";
+    InstanceStatus["PENDING"] = "Pending";
+    InstanceStatus["RESUMING"] = "Resuming";
+    InstanceStatus["RETRYING"] = "Retrying";
+    InstanceStatus["RUNNING"] = "Running";
+    InstanceStatus["UPGRADING"] = "Upgrading";
+})(exports.InstanceStatus || (exports.InstanceStatus = {}));
+/**
+ * Case stage task type
+ */
+exports.StageTaskType = void 0;
+(function (StageTaskType) {
+    StageTaskType["EXTERNAL_AGENT"] = "external-agent";
+    StageTaskType["RPA"] = "rpa";
+    StageTaskType["AGENTIC_PROCESS"] = "process";
+    StageTaskType["AGENT"] = "agent";
+    StageTaskType["ACTION"] = "action";
+    StageTaskType["API_WORKFLOW"] = "api-workflow";
+})(exports.StageTaskType || (exports.StageTaskType = {}));
+/**
+ * Escalation recipient scope
+ */
+exports.EscalationRecipientScope = void 0;
+(function (EscalationRecipientScope) {
+    EscalationRecipientScope["USER"] = "user";
+    EscalationRecipientScope["USER_GROUP"] = "usergroup";
+})(exports.EscalationRecipientScope || (exports.EscalationRecipientScope = {}));
+/**
+ * Escalation action type
+ */
+exports.EscalationActionType = void 0;
+(function (EscalationActionType) {
+    EscalationActionType["NOTIFICATION"] = "notification";
+})(exports.EscalationActionType || (exports.EscalationActionType = {}));
+/**
+ * Escalation rule trigger type
+ */
+exports.EscalationTriggerType = void 0;
+(function (EscalationTriggerType) {
+    EscalationTriggerType["SLA_BREACHED"] = "sla-breached";
+    EscalationTriggerType["AT_RISK"] = "at-risk";
+    /** Default value when no escalation rule is defined */
+    EscalationTriggerType["NONE"] = "None";
+})(exports.EscalationTriggerType || (exports.EscalationTriggerType = {}));
+/**
+ * SLA duration unit
+ */
+exports.SLADurationUnit = void 0;
+(function (SLADurationUnit) {
+    SLADurationUnit["HOURS"] = "h";
+    SLADurationUnit["DAYS"] = "d";
+    SLADurationUnit["WEEKS"] = "w";
+    SLADurationUnit["MONTHS"] = "m";
+})(exports.SLADurationUnit || (exports.SLADurationUnit = {}));
+
+/**
+ * Creates methods for a case instance
+ *
+ * @param instanceData - The case instance data (response from API)
+ * @param service - The case instance service instance
+ * @returns Object containing case instance methods
+ */
+function createCaseInstanceMethods(instanceData, service) {
+    return {
+        async close(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Case instance folder key is undefined');
+            return service.close(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async pause(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Case instance folder key is undefined');
+            return service.pause(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async reopen(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Case instance folder key is undefined');
+            return service.reopen(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async resume(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Case instance folder key is undefined');
+            return service.resume(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async getExecutionHistory() {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Case instance folder key is undefined');
+            return service.getExecutionHistory(instanceData.instanceId, instanceData.folderKey);
+        },
+        async getStages() {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Case instance folder key is undefined');
+            return service.getStages(instanceData.instanceId, instanceData.folderKey);
+        },
+        async getActionTasks(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            return service.getActionTasks(instanceData.instanceId, options);
+        },
+        async getSlaSummary(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            return service.getSlaSummary({ ...options, caseInstanceId: instanceData.instanceId });
+        },
+        async getStagesSlaSummary() {
+            if (!instanceData.instanceId)
+                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);
+}
+
+/**
+ * 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
+        }
+    };
+}
+
+/**
+ * Type guards for error response types
+ */
+function isOrchestratorError(error) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        'errorCode' in error &&
+        typeof error.message === 'string' &&
         typeof error.errorCode === 'number';
 }
 function isEntityError(error) {
@@ -942,532 +1595,270 @@ isBrowser && window.self != window.top && window.location.href.includes('source=
 const _params = isBrowser ? new URLSearchParams(window.location.search) : null;
 /**
  * True when the coded app has been loaded inside a host frame that explicitly
- * opted into token delegation by adding `?host=embed` to the iframe src URL.
- */
-const isHostEmbedded = isBrowser && window.self !== window.top && _params?.get('host') === 'embed';
-/**
- * The validated parent origin, read from the `?basedomain=` query param set
- * by the embedding host in the iframe src URL.
- * Mirrors the same mechanism used by ActionCenterTokenManager.
- * Non-null only when `?host=embed` is present and `?basedomain=` is a valid URL.
- */
-(() => {
-    if (!isHostEmbedded)
-        return null;
-    const basedomain = _params?.get('basedomain');
-    if (!basedomain)
-        return null;
-    try {
-        return new URL(basedomain).origin;
-    }
-    catch {
-        console.warn('embeddingOrigin: basedomain query param is not a valid URL', basedomain);
-        return null;
-    }
-})();
-
-/**
- * Base64 encoding/decoding
- */
-/**
- * Encodes a string to base64
- * @param str - The string to encode
- * @returns Base64 encoded string
- */
-function encodeBase64(str) {
-    // TextEncoder for UTF-8 encoding (works in both browser and Node.js)
-    const encoder = new TextEncoder();
-    const data = encoder.encode(str);
-    // Convert Uint8Array to base64
-    if (isBrowser) {
-        // Browser environment
-        // Convert Uint8Array to binary string then to base64
-        const binaryString = Array.from(data, byte => String.fromCharCode(byte)).join('');
-        return btoa(binaryString);
-    }
-    else {
-        // Node.js environment
-        return Buffer.from(data).toString('base64');
-    }
-}
-/**
- * Decodes a base64 string
- * @param base64 - The base64 string to decode
- * @returns Decoded string
- */
-function decodeBase64(base64) {
-    let bytes;
-    if (isBrowser) {
-        // Browser environment
-        const binaryString = atob(base64);
-        bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-        }
-    }
-    else {
-        // Node.js environment
-        bytes = new Uint8Array(Buffer.from(base64, 'base64'));
-    }
-    // TextDecoder for UTF-8 decoding (works in both browser and Node.js)
-    const decoder = new TextDecoder();
-    return decoder.decode(bytes);
-}
-
-/**
- * PaginationManager handles the conversion between uniform cursor-based pagination
- * and the specific pagination type for each service
- */
-class PaginationManager {
-    /**
-     * Create a pagination cursor for subsequent page requests
-     */
-    static createCursor({ pageInfo, type }) {
-        if (!pageInfo.hasMore) {
-            return undefined;
-        }
-        const cursorData = {
-            type,
-            pageSize: pageInfo.pageSize,
-        };
-        switch (type) {
-            case PaginationType.OFFSET:
-                if (pageInfo.currentPage) {
-                    cursorData.pageNumber = pageInfo.currentPage + 1;
-                }
-                break;
-            case PaginationType.TOKEN:
-                if (pageInfo.continuationToken) {
-                    cursorData.continuationToken = pageInfo.continuationToken;
-                }
-                else {
-                    return undefined; // No continuation token, can't continue
-                }
-                break;
-        }
-        return {
-            value: encodeBase64(JSON.stringify(cursorData))
-        };
-    }
-    /**
-     * Create a paginated response with navigation cursors
-     */
-    static createPaginatedResponse({ pageInfo, type }, items) {
-        const nextCursor = PaginationManager.createCursor({ pageInfo, type });
-        // Create previous page cursor if applicable
-        let previousCursor = undefined;
-        if (pageInfo.currentPage && pageInfo.currentPage > 1) {
-            const prevCursorData = {
-                type,
-                pageNumber: pageInfo.currentPage - 1,
-                pageSize: pageInfo.pageSize,
-            };
-            previousCursor = {
-                value: encodeBase64(JSON.stringify(prevCursorData))
-            };
-        }
-        // Calculate total pages if we have totalCount and pageSize
-        let totalPages = undefined;
-        if (pageInfo.totalCount !== undefined && pageInfo.pageSize) {
-            totalPages = Math.ceil(pageInfo.totalCount / pageInfo.pageSize);
-        }
-        // Determine if this pagination type supports page jumping
-        const supportsPageJump = type === PaginationType.OFFSET;
-        // Create the result object with all fields, then filter out undefined values
-        const result = filterUndefined({
-            items,
-            totalCount: pageInfo.totalCount,
-            hasNextPage: pageInfo.hasMore,
-            nextCursor: nextCursor,
-            previousCursor: previousCursor,
-            currentPage: pageInfo.currentPage,
-            totalPages,
-            supportsPageJump
-        });
-        return result;
-    }
-}
-
-/**
- * Creates headers object from key-value pairs
- * @param headersObj - Object containing header key-value pairs
- * @returns Headers object with all values converted to strings
- *
- * @example
- * ```typescript
- * // Single header
- * const headers = createHeaders({ 'X-UIPATH-FolderKey': '1234567890' });
- *
- * // Multiple headers
- * const headers = createHeaders({
- *   'X-UIPATH-FolderKey': '1234567890',
- *   'X-UIPATH-OrganizationUnitId': 123,
- *   'Accept': 'application/json'
- * });
- *
- * // Using constants
- * import { FOLDER_KEY, FOLDER_ID } from '../constants/headers';
- * const headers = createHeaders({
- *   [FOLDER_KEY]: 'abc-123',
- *   [FOLDER_ID]: 456
- * });
- *
- * // Empty headers
- * const headers = createHeaders();
- * ```
- */
-function createHeaders(headersObj) {
-    const headers = {};
-    for (const [key, value] of Object.entries(headersObj)) {
-        if (value !== undefined && value !== null) {
-            headers[key] = value.toString();
-        }
-    }
-    return headers;
-}
-
-/**
- * Common constants used across the SDK
- */
-/**
- * Prefix used for OData query parameters
- */
-const ODATA_PREFIX = '$';
-/**
- * HTTP methods
- */
-const HTTP_METHODS = {
-    GET: 'GET',
-    POST: 'POST'};
-/**
- * OData pagination constants
- */
-const ODATA_PAGINATION = {
-    /** Default field name for items in a paginated OData response */
-    ITEMS_FIELD: 'value',
-    /** Default field name for total count in a paginated OData response */
-    TOTAL_COUNT_FIELD: '@odata.count'
-};
-/**
- * SLA Summary pagination constants for page-number-based pagination
- */
-const SLA_SUMMARY_PAGINATION = {
-    /** Field name for items in SLA summary response */
-    ITEMS_FIELD: 'data',
-    /** Dot-notation path for total count in nested pagination object */
-    TOTAL_COUNT_FIELD: 'pagination.totalCount'
-};
-/**
- * SLA Summary OFFSET pagination parameter names (page-number style, no skip conversion)
- */
-const SLA_SUMMARY_OFFSET_PARAMS = {
-    /** Page size parameter name */
-    PAGE_SIZE_PARAM: 'PageSize',
-    /** Page number parameter name (sent directly, not converted to skip) */
-    OFFSET_PARAM: 'PageNumber',
-    /** No count param needed */
-    COUNT_PARAM: undefined
-};
-/**
- * Process Instance pagination constants for token-based pagination
- */
-const PROCESS_INSTANCE_PAGINATION = {
-    /** Field name for items in process instance response */
-    ITEMS_FIELD: 'instances',
-    /** Field name for continuation token in process instance response */
-    CONTINUATION_TOKEN_FIELD: 'nextPage'
-};
-/**
- * OData OFFSET pagination parameter names (ODATA-style)
- */
-const ODATA_OFFSET_PARAMS = {
-    /** OData page size parameter name */
-    PAGE_SIZE_PARAM: '$top',
-    /** OData offset parameter name */
-    OFFSET_PARAM: '$skip',
-    /** OData count parameter name */
-    COUNT_PARAM: '$count'
-};
-/**
- * Bucket TOKEN pagination parameter names
- */
-const BUCKET_TOKEN_PARAMS = {
-    /** Bucket page size parameter name */
-    PAGE_SIZE_PARAM: 'takeHint',
-    /** Bucket token parameter name */
-    TOKEN_PARAM: 'continuationToken'
-};
+ * opted into token delegation by adding `?host=embed` to the iframe src URL.
+ */
+const isHostEmbedded = isBrowser && window.self !== window.top && _params?.get('host') === 'embed';
 /**
- * Process Instance TOKEN pagination parameter names
+ * The validated parent origin, read from the `?basedomain=` query param set
+ * by the embedding host in the iframe src URL.
+ * Mirrors the same mechanism used by ActionCenterTokenManager.
+ * Non-null only when `?host=embed` is present and `?basedomain=` is a valid URL.
  */
-const PROCESS_INSTANCE_TOKEN_PARAMS = {
-    /** Process instance page size parameter name */
-    PAGE_SIZE_PARAM: 'pageSize',
-    /** Process instance token parameter name */
-    TOKEN_PARAM: 'nextPage'
-};
+(() => {
+    if (!isHostEmbedded)
+        return null;
+    const basedomain = _params?.get('basedomain');
+    if (!basedomain)
+        return null;
+    try {
+        return new URL(basedomain).origin;
+    }
+    catch {
+        console.warn('embeddingOrigin: basedomain query param is not a valid URL', basedomain);
+        return null;
+    }
+})();
 
 /**
- * Converts a UTC timestamp string (e.g., "5/8/2026 11:20:17 AM") to ISO 8601 UTC format.
- * Returns the original value if parsing fails.
+ * Base64 encoding/decoding
  */
-function toISOUtc(value) {
-    const date = new Date(value + ' UTC');
-    return isNaN(date.getTime()) ? value : date.toISOString();
-}
 /**
- * Transforms data by mapping fields according to the provided field mapping
- * @param data The source data to transform
- * @param fieldMapping Object mapping source field names to target field names
- * @returns Transformed data with mapped field names
- *
- * @example
- * ```typescript
- * // Single object transformation
- * const data = { id: '123', userName: 'john' };
- * const mapping = { id: 'userId', userName: 'name' };
- * const result = transformData(data, mapping);
- * // result = { userId: '123', name: 'john' }
- *
- * // Array transformation
- * const dataArray = [
- *   { id: '123', userName: 'john' },
- *   { id: '456', userName: 'jane' }
- * ];
- * const result = transformData(dataArray, mapping);
- * // result = [
- * //   { userId: '123', name: 'john' },
- * //   { userId: '456', name: 'jane' }
- * // ]
- * ```
+ * Encodes a string to base64
+ * @param str - The string to encode
+ * @returns Base64 encoded string
  */
-function transformData(data, fieldMapping) {
-    // Handle array of objects
-    if (Array.isArray(data)) {
-        return data.map(item => transformData(item, fieldMapping));
+function encodeBase64(str) {
+    // TextEncoder for UTF-8 encoding (works in both browser and Node.js)
+    const encoder = new TextEncoder();
+    const data = encoder.encode(str);
+    // Convert Uint8Array to base64
+    if (isBrowser) {
+        // Browser environment
+        // Convert Uint8Array to binary string then to base64
+        const binaryString = Array.from(data, byte => String.fromCharCode(byte)).join('');
+        return btoa(binaryString);
     }
-    // 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;
-        }
+    else {
+        // Node.js environment
+        return Buffer.from(data).toString('base64');
     }
-    return result;
-}
-/**
- * Converts a string from PascalCase to camelCase
- * @param str The PascalCase string to convert
- * @returns The camelCase version of the string
- *
- * @example
- * ```typescript
- * pascalToCamelCase('HelloWorld'); // 'helloWorld'
- * pascalToCamelCase('TaskAssignmentCriteria'); // 'taskAssignmentCriteria'
- * ```
- */
-function pascalToCamelCase(str) {
-    if (!str)
-        return str;
-    return str.charAt(0).toLowerCase() + str.slice(1);
 }
 /**
- * Converts a string from camelCase to PascalCase
- * @param str The camelCase string to convert
- * @returns The PascalCase version of the string
- *
- * @example
- * ```typescript
- * camelToPascalCase('helloWorld'); // 'HelloWorld'
- * camelToPascalCase('taskAssignmentCriteria'); // 'TaskAssignmentCriteria'
- * ```
+ * Decodes a base64 string
+ * @param base64 - The base64 string to decode
+ * @returns Decoded string
  */
-function camelToPascalCase(str) {
-    if (!str)
-        return str;
-    return str.charAt(0).toUpperCase() + str.slice(1);
+function decodeBase64(base64) {
+    let bytes;
+    if (isBrowser) {
+        // Browser environment
+        const binaryString = atob(base64);
+        bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+    }
+    else {
+        // Node.js environment
+        bytes = new Uint8Array(Buffer.from(base64, 'base64'));
+    }
+    // TextDecoder for UTF-8 decoding (works in both browser and Node.js)
+    const decoder = new TextDecoder();
+    return decoder.decode(bytes);
 }
+
 /**
- * Generic function to transform object keys using a provided case conversion function
- * @param data The object to transform
- * @param convertCase The function to convert each key
- * @returns A new object with transformed keys
+ * PaginationManager handles the conversion between uniform cursor-based pagination
+ * and the specific pagination type for each service
  */
-function transformCaseKeys(data, convertCase) {
-    // Handle array of objects
-    if (Array.isArray(data)) {
-        return data.map(item => {
-            // If the array element is a primitive (string, number, etc.), return it as is
-            if (item === null || typeof item !== 'object' || typeof item === 'string') {
-                return item;
-            }
-            // Only recursively transform if it's actually an object
-            return transformCaseKeys(item, convertCase);
-        });
+class PaginationManager {
+    /**
+     * Create a pagination cursor for subsequent page requests
+     */
+    static createCursor({ pageInfo, type }) {
+        if (!pageInfo.hasMore) {
+            return undefined;
+        }
+        const cursorData = {
+            type,
+            pageSize: pageInfo.pageSize,
+        };
+        switch (type) {
+            case PaginationType.OFFSET:
+                if (pageInfo.currentPage) {
+                    cursorData.pageNumber = pageInfo.currentPage + 1;
+                }
+                break;
+            case PaginationType.TOKEN:
+                if (pageInfo.continuationToken) {
+                    cursorData.continuationToken = pageInfo.continuationToken;
+                }
+                else {
+                    return undefined; // No continuation token, can't continue
+                }
+                break;
+        }
+        return {
+            value: encodeBase64(JSON.stringify(cursorData))
+        };
     }
-    const result = {};
-    for (const [key, value] of Object.entries(data)) {
-        const transformedKey = convertCase(key);
-        // Recursively transform nested objects and arrays
-        if (value !== null && typeof value === 'object') {
-            result[transformedKey] = transformCaseKeys(value, convertCase);
+    /**
+     * Create a paginated response with navigation cursors
+     */
+    static createPaginatedResponse({ pageInfo, type }, items) {
+        const nextCursor = PaginationManager.createCursor({ pageInfo, type });
+        // Create previous page cursor if applicable
+        let previousCursor = undefined;
+        if (pageInfo.currentPage && pageInfo.currentPage > 1) {
+            const prevCursorData = {
+                type,
+                pageNumber: pageInfo.currentPage - 1,
+                pageSize: pageInfo.pageSize,
+            };
+            previousCursor = {
+                value: encodeBase64(JSON.stringify(prevCursorData))
+            };
         }
-        else {
-            result[transformedKey] = value;
+        // Calculate total pages if we have totalCount and pageSize
+        let totalPages = undefined;
+        if (pageInfo.totalCount !== undefined && pageInfo.pageSize) {
+            totalPages = Math.ceil(pageInfo.totalCount / pageInfo.pageSize);
         }
+        // Determine if this pagination type supports page jumping
+        const supportsPageJump = type === PaginationType.OFFSET;
+        // Create the result object with all fields, then filter out undefined values
+        const result = filterUndefined({
+            items,
+            totalCount: pageInfo.totalCount,
+            hasNextPage: pageInfo.hasMore,
+            nextCursor: nextCursor,
+            previousCursor: previousCursor,
+            currentPage: pageInfo.currentPage,
+            totalPages,
+            supportsPageJump
+        });
+        return result;
     }
-    return result;
-}
-/**
- * Transforms an object's keys from PascalCase to camelCase
- * @param data The object with PascalCase keys
- * @returns A new object with all keys converted to camelCase
- *
- * @example
- * ```typescript
- * // Simple object
- * pascalToCamelCaseKeys({ Id: "123", TaskName: "Invoice" });
- * // Result: { id: "123", taskName: "Invoice" }
- *
- * // Nested object
- * pascalToCamelCaseKeys({
- *   TaskId: "456",
- *   TaskDetails: { AssignedUser: "John", Priority: "High" }
- * });
- * // Result: {
- * //   taskId: "456",
- * //   taskDetails: { assignedUser: "John", priority: "High" }
- * // }
- *
- * // Array of objects
- * pascalToCamelCaseKeys([
- *   { Id: "1", IsComplete: false },
- *   { Id: "2", IsComplete: true }
- * ]);
- * // Result: [
- * //   { id: "1", isComplete: false },
- * //   { id: "2", isComplete: true }
- * // ]
- * ```
- */
-function pascalToCamelCaseKeys(data) {
-    return transformCaseKeys(data, pascalToCamelCase);
 }
+
 /**
- * Transforms an object's keys from camelCase to PascalCase
- * @param data The object with camelCase keys
- * @returns A new object with all keys converted to PascalCase
+ * Creates headers object from key-value pairs
+ * @param headersObj - Object containing header key-value pairs
+ * @returns Headers object with all values converted to strings
  *
  * @example
  * ```typescript
- * // Simple object
- * camelToPascalCaseKeys({ userId: "789", isActive: true });
- * // Result: { UserId: "789", IsActive: true }
+ * // Single header
+ * const headers = createHeaders({ 'X-UIPATH-FolderKey': '1234567890' });
  *
- * // Nested object
- * camelToPascalCaseKeys({
- *   taskId: "ABC123",
- *   submissionData: { customerName: "XYZ Corp" }
+ * // Multiple headers
+ * const headers = createHeaders({
+ *   'X-UIPATH-FolderKey': '1234567890',
+ *   'X-UIPATH-OrganizationUnitId': 123,
+ *   'Accept': 'application/json'
  * });
- * // Result: {
- * //   TaskId: "ABC123",
- * //   SubmissionData: { CustomerName: "XYZ Corp" }
- * // }
  *
- * // Array of objects
- * camelToPascalCaseKeys([
- *   { userId: "u1", roleType: "admin" },
- *   { userId: "u2", roleType: "user" }
- * ]);
- * // Result: [
- * //   { UserId: "u1", RoleType: "admin" },
- * //   { UserId: "u2", RoleType: "user" }
- * // ]
+ * // Using constants
+ * import { FOLDER_KEY, FOLDER_ID } from '../constants/headers';
+ * const headers = createHeaders({
+ *   [FOLDER_KEY]: 'abc-123',
+ *   [FOLDER_ID]: 456
+ * });
+ *
+ * // Empty headers
+ * const headers = createHeaders();
  * ```
  */
-function camelToPascalCaseKeys(data) {
-    return transformCaseKeys(data, camelToPascalCase);
+function createHeaders(headersObj) {
+    const headers = {};
+    for (const [key, value] of Object.entries(headersObj)) {
+        if (value !== undefined && value !== null) {
+            headers[key] = value.toString();
+        }
+    }
+    return headers;
 }
+
 /**
- * Maps a field value in an object using a provided mapping object.
- * Returns a new object with the mapped field value.
- *
- * @param obj The object to map
- * @param field The field name to map
- * @param valueMap The mapping object (from input value to output value)
- * @returns A new object with the mapped field value
- *
- * @example
- * const statusMap = { 0: 'Unassigned', 1: 'Pending', 2: 'Completed' };
- * const task = { status: 1, id: 123 };
- * const mapped = mapFieldValue(task, 'status', statusMap);
- * // mapped = { status: 'Pending', id: 123 }
+ * Common constants used across the SDK
  */
-function _mapFieldValue(obj, field, valueMap) {
-    const lookupKey = String(obj[field]);
-    return {
-        ...obj,
-        [field]: lookupKey in valueMap
-            ? valueMap[lookupKey]
-            : obj[field],
-    };
-}
 /**
- * General API response transformer with optional field value mapping.
- *
- * @param data - The API response data to transform
- * @param options - Optional mapping options:
- *   - field: The field name to map (optional)
- *   - valueMap: The mapping object for the field (optional)
- *   - transform: A function to further transform the data (optional)
- * @returns The transformed data, with field value mapped if specified
- *
- * @example
- * // Just transform
- * const result = applyDataTransforms(data);
- *
- * // Map a field value, then transform
- * const result = applyDataTransforms(data, { field: 'status', valueMap: StatusMap });
- *
- * // Map a field value, then apply a custom transform
- * const result = applyDataTransforms(data, { field: 'status', valueMap: StatusMap, transform: customTransform });
+ * Prefix used for OData query parameters
  */
-function applyDataTransforms(data, options) {
-    let result = data;
-    if (options?.field && options?.valueMap) {
-        result = _mapFieldValue(result, options.field, options.valueMap);
-    }
-    if (options?.transform) {
-        result = options.transform(result);
-    }
-    return result;
-}
+const ODATA_PREFIX = '$';
 /**
- * Adds a prefix to specified keys in an object, returning a new object.
- * Only the provided keys are prefixed; all others are left unchanged.
- *
- * @param obj The source object
- * @param prefix The prefix to add (e.g., '$')
- * @param keys The keys to prefix (e.g., ['expand', 'filter'])
- * @returns A new object with specified keys prefixed
- *
- * @example
- * addPrefixToKeys({ expand: 'a', foo: 1 }, '$', ['expand']) // { $expand: 'a', foo: 1 }
+ * HTTP methods
  */
-function addPrefixToKeys(obj, prefix, keys) {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (keys.includes(key)) {
-            result[`${prefix}${key}`] = value;
-        }
-        else {
-            result[key] = value;
-        }
-    }
-    return result;
-}
+const HTTP_METHODS = {
+    GET: 'GET',
+    POST: 'POST'};
+/**
+ * OData pagination constants
+ */
+const ODATA_PAGINATION = {
+    /** Default field name for items in a paginated OData response */
+    ITEMS_FIELD: 'value',
+    /** Default field name for total count in a paginated OData response */
+    TOTAL_COUNT_FIELD: '@odata.count'
+};
+/**
+ * SLA Summary pagination constants for page-number-based pagination
+ */
+const SLA_SUMMARY_PAGINATION = {
+    /** Field name for items in SLA summary response */
+    ITEMS_FIELD: 'data',
+    /** Dot-notation path for total count in nested pagination object */
+    TOTAL_COUNT_FIELD: 'pagination.totalCount'
+};
+/**
+ * SLA Summary OFFSET pagination parameter names (page-number style, no skip conversion)
+ */
+const SLA_SUMMARY_OFFSET_PARAMS = {
+    /** Page size parameter name */
+    PAGE_SIZE_PARAM: 'PageSize',
+    /** Page number parameter name (sent directly, not converted to skip) */
+    OFFSET_PARAM: 'PageNumber',
+    /** No count param needed */
+    COUNT_PARAM: undefined
+};
+/**
+ * Process Instance pagination constants for token-based pagination
+ */
+const PROCESS_INSTANCE_PAGINATION = {
+    /** Field name for items in process instance response */
+    ITEMS_FIELD: 'instances',
+    /** Field name for continuation token in process instance response */
+    CONTINUATION_TOKEN_FIELD: 'nextPage'
+};
+/**
+ * OData OFFSET pagination parameter names (ODATA-style)
+ */
+const ODATA_OFFSET_PARAMS = {
+    /** OData page size parameter name */
+    PAGE_SIZE_PARAM: '$top',
+    /** OData offset parameter name */
+    OFFSET_PARAM: '$skip',
+    /** OData count parameter name */
+    COUNT_PARAM: '$count'
+};
+/**
+ * Bucket TOKEN pagination parameter names
+ */
+const BUCKET_TOKEN_PARAMS = {
+    /** Bucket page size parameter name */
+    PAGE_SIZE_PARAM: 'takeHint',
+    /** Bucket token parameter name */
+    TOKEN_PARAM: 'continuationToken'
+};
+/**
+ * Process Instance TOKEN pagination parameter names
+ */
+const PROCESS_INSTANCE_TOKEN_PARAMS = {
+    /** Process instance page size parameter name */
+    PAGE_SIZE_PARAM: 'pageSize',
+    /** Process instance token parameter name */
+    TOKEN_PARAM: 'nextPage'
+};
 
 /**
  * Constants used throughout the pagination system
@@ -2268,7 +2659,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
@@ -2295,12 +2686,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.
@@ -2395,33 +2841,78 @@ 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
-     * @returns Promise resolving to an array of {@link ElementStats}
+     * @param request - Process scope + time range to aggregate over
+     * @returns Promise resolving to an array of {@link ElementStats}
+     * @example
+     * ```typescript
+     * // 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(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
-     * // Get element metrics for a case
-     * const elements = await cases.getElementStats(
-     *   '<processKey>',
-     *   '<packageId>',
+     * // 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(),
-     *   '1.0.1'
+     *   caseItem.packageVersions[0]
      * );
-     *
-     * // 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}`);
-     * }
      * ```
      */
-    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));
-        return data ?? [];
+    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
@@ -2454,6 +2945,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);
@@ -2463,243 +2957,9 @@ __decorate([
 __decorate([
     track('Cases.GetElementStats')
 ], CasesService.prototype, "getElementStats", null);
-
-/**
- * Process Incident Status
- */
-var ProcessIncidentStatus;
-(function (ProcessIncidentStatus) {
-    ProcessIncidentStatus["Open"] = "Open";
-    ProcessIncidentStatus["Closed"] = "Closed";
-})(ProcessIncidentStatus || (ProcessIncidentStatus = {}));
-/**
- * Process Incident Type
- */
-var ProcessIncidentType;
-(function (ProcessIncidentType) {
-    ProcessIncidentType["System"] = "System";
-    ProcessIncidentType["User"] = "User";
-    ProcessIncidentType["Deployment"] = "Deployment";
-})(ProcessIncidentType || (ProcessIncidentType = {}));
-/**
- * Process Incident Severity
- */
-var ProcessIncidentSeverity;
-(function (ProcessIncidentSeverity) {
-    ProcessIncidentSeverity["Error"] = "Error";
-    ProcessIncidentSeverity["Warning"] = "Warning";
-})(ProcessIncidentSeverity || (ProcessIncidentSeverity = {}));
-/**
- * Process Incident Debug Mode
- */
-var DebugMode;
-(function (DebugMode) {
-    DebugMode["None"] = "None";
-    DebugMode["Default"] = "Default";
-    DebugMode["StepByStep"] = "StepByStep";
-    DebugMode["SingleStep"] = "SingleStep";
-})(DebugMode || (DebugMode = {}));
-
-/**
- * Case Instance Types
- * Types and interfaces for Maestro case instance management
- */
-/**
- * SLA status for a case instance
- */
-exports.SlaSummaryStatus = void 0;
-(function (SlaSummaryStatus) {
-    /** Case is within SLA deadline */
-    SlaSummaryStatus["ON_TRACK"] = "On Track";
-    /** Case is approaching SLA deadline based on at-risk percentage threshold */
-    SlaSummaryStatus["AT_RISK"] = "At Risk";
-    /** Case has exceeded SLA deadline */
-    SlaSummaryStatus["OVERDUE"] = "Overdue";
-    /** Case instance has completed */
-    SlaSummaryStatus["COMPLETED"] = "Completed";
-    /** SLA status cannot be determined (no SLA deadline defined) */
-    SlaSummaryStatus["UNKNOWN"] = "Unknown";
-})(exports.SlaSummaryStatus || (exports.SlaSummaryStatus = {}));
-/**
- * Instance status values for case instances and process instances
- */
-exports.InstanceStatus = void 0;
-(function (InstanceStatus) {
-    /** Instance status not yet populated by the backend */
-    InstanceStatus["UNKNOWN"] = "";
-    InstanceStatus["CANCELLED"] = "Cancelled";
-    InstanceStatus["CANCELING"] = "Canceling";
-    InstanceStatus["COMPLETED"] = "Completed";
-    InstanceStatus["FAULTED"] = "Faulted";
-    InstanceStatus["PAUSED"] = "Paused";
-    InstanceStatus["PAUSING"] = "Pausing";
-    InstanceStatus["PENDING"] = "Pending";
-    InstanceStatus["RESUMING"] = "Resuming";
-    InstanceStatus["RETRYING"] = "Retrying";
-    InstanceStatus["RUNNING"] = "Running";
-    InstanceStatus["UPGRADING"] = "Upgrading";
-})(exports.InstanceStatus || (exports.InstanceStatus = {}));
-/**
- * Case stage task type
- */
-exports.StageTaskType = void 0;
-(function (StageTaskType) {
-    StageTaskType["EXTERNAL_AGENT"] = "external-agent";
-    StageTaskType["RPA"] = "rpa";
-    StageTaskType["AGENTIC_PROCESS"] = "process";
-    StageTaskType["AGENT"] = "agent";
-    StageTaskType["ACTION"] = "action";
-    StageTaskType["API_WORKFLOW"] = "api-workflow";
-})(exports.StageTaskType || (exports.StageTaskType = {}));
-/**
- * Escalation recipient scope
- */
-exports.EscalationRecipientScope = void 0;
-(function (EscalationRecipientScope) {
-    EscalationRecipientScope["USER"] = "user";
-    EscalationRecipientScope["USER_GROUP"] = "usergroup";
-})(exports.EscalationRecipientScope || (exports.EscalationRecipientScope = {}));
-/**
- * Escalation action type
- */
-exports.EscalationActionType = void 0;
-(function (EscalationActionType) {
-    EscalationActionType["NOTIFICATION"] = "notification";
-})(exports.EscalationActionType || (exports.EscalationActionType = {}));
-/**
- * Escalation rule trigger type
- */
-exports.EscalationTriggerType = void 0;
-(function (EscalationTriggerType) {
-    EscalationTriggerType["SLA_BREACHED"] = "sla-breached";
-    EscalationTriggerType["AT_RISK"] = "at-risk";
-    /** Default value when no escalation rule is defined */
-    EscalationTriggerType["NONE"] = "None";
-})(exports.EscalationTriggerType || (exports.EscalationTriggerType = {}));
-/**
- * SLA duration unit
- */
-exports.SLADurationUnit = void 0;
-(function (SLADurationUnit) {
-    SLADurationUnit["HOURS"] = "h";
-    SLADurationUnit["DAYS"] = "d";
-    SLADurationUnit["WEEKS"] = "w";
-    SLADurationUnit["MONTHS"] = "m";
-})(exports.SLADurationUnit || (exports.SLADurationUnit = {}));
-
-/**
- * Creates methods for a case instance
- *
- * @param instanceData - The case instance data (response from API)
- * @param service - The case instance service instance
- * @returns Object containing case instance methods
- */
-function createCaseInstanceMethods(instanceData, service) {
-    return {
-        async close(options) {
-            if (!instanceData.instanceId)
-                throw new Error('Case instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Case instance folder key is undefined');
-            return service.close(instanceData.instanceId, instanceData.folderKey, options);
-        },
-        async pause(options) {
-            if (!instanceData.instanceId)
-                throw new Error('Case instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Case instance folder key is undefined');
-            return service.pause(instanceData.instanceId, instanceData.folderKey, options);
-        },
-        async reopen(options) {
-            if (!instanceData.instanceId)
-                throw new Error('Case instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Case instance folder key is undefined');
-            return service.reopen(instanceData.instanceId, instanceData.folderKey, options);
-        },
-        async resume(options) {
-            if (!instanceData.instanceId)
-                throw new Error('Case instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Case instance folder key is undefined');
-            return service.resume(instanceData.instanceId, instanceData.folderKey, options);
-        },
-        async getExecutionHistory() {
-            if (!instanceData.instanceId)
-                throw new Error('Case instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Case instance folder key is undefined');
-            return service.getExecutionHistory(instanceData.instanceId, instanceData.folderKey);
-        },
-        async getStages() {
-            if (!instanceData.instanceId)
-                throw new Error('Case instance ID is undefined');
-            if (!instanceData.folderKey)
-                throw new Error('Case instance folder key is undefined');
-            return service.getStages(instanceData.instanceId, instanceData.folderKey);
-        },
-        async getActionTasks(options) {
-            if (!instanceData.instanceId)
-                throw new Error('Case instance ID is undefined');
-            return service.getActionTasks(instanceData.instanceId, options);
-        },
-        async getSlaSummary(options) {
-            if (!instanceData.instanceId)
-                throw new Error('Case instance ID is undefined');
-            return service.getSlaSummary({ ...options, caseInstanceId: instanceData.instanceId });
-        },
-        async getStagesSlaSummary() {
-            if (!instanceData.instanceId)
-                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);
-}
-
-/**
- * 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 = {}));
+__decorate([
+    track('Cases.GetInstanceStats')
+], CasesService.prototype, "getInstanceStats", null);
 
 /**
  * Maps fields for Case Instance entities to ensure consistent naming
@@ -3123,6 +3383,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,
@@ -3139,7 +3403,7 @@ class TaskService extends BaseService {
                     countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM // OData OFFSET parameter
                 }
             }
-        }, options);
+        }, apiOptions);
     }
     /**
      * Gets a task by ID
@@ -3175,9 +3439,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