@uipath/uipath-typescript 1.4.2 → 1.5.0

package/dist/cases/index.mjs

@@ -42,6 +42,299 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+/**
+ * Maps API field names (countOf*) to SDK field names (*Count) for InstanceStats,
+ * aligning naming with ElementStats and other count-suffixed conventions.
+ */
+const InstanceStatsMap = {
+    countOfAllInstances: 'totalCount',
+    countOfRunning: 'runningCount',
+    countOfTransitioning: 'transitioningCount',
+    countOfPaused: 'pausedCount',
+    countOfFaulted: 'faultedCount',
+    countOfCompleted: 'completedCount',
+    countOfCancelled: 'cancelledCount',
+    countOfDeleted: 'deletedCount'
+};
+
+/**
+ * Converts a UTC timestamp string (e.g., "5/8/2026 11:20:17 AM") to ISO 8601 UTC format.
+ * Returns the original value if parsing fails.
+ */
+function toISOUtc(value) {
+    const date = new Date(value + ' UTC');
+    return isNaN(date.getTime()) ? value : date.toISOString();
+}
+/**
+ * Transforms data by renaming each key in `data` exactly once, using the
+ * mapping (`sourceField → targetField`). Keys not present in the mapping
+ * pass through unchanged. The original (pre-rename) key is dropped — the
+ * result contains only the renamed key.
+ *
+ * Each rename is independent. If the mapping happens to contain chained
+ * entries (`a → b` and `b → c`), they do NOT compose: a field named `a`
+ * in `data` becomes `b` (not `c`), because the renames are applied based
+ * on the original data's keys, not the running result.
+ *
+ * @param data The source data to transform
+ * @param fieldMapping Object mapping source field names to target field names
+ * @returns Transformed data with mapped field names
+ *
+ * @example
+ * ```typescript
+ * // Single object transformation
+ * const data = { id: '123', userName: 'john' };
+ * const mapping = { id: 'userId', userName: 'name' };
+ * const result = transformData(data, mapping);
+ * // result = { userId: '123', name: 'john' }
+ *
+ * // Array transformation
+ * const dataArray = [
+ *   { id: '123', userName: 'john' },
+ *   { id: '456', userName: 'jane' }
+ * ];
+ * const result = transformData(dataArray, mapping);
+ * // result = [
+ * //   { userId: '123', name: 'john' },
+ * //   { userId: '456', name: 'jane' }
+ * // ]
+ *
+ * // No chaining — `a → b` does not become `a → c` even if the map has `b → c`.
+ * transformData({ a: 1 }, { a: 'b', b: 'c' });
+ * // result = { b: 1 }
+ * ```
+ */
+function transformData(data, fieldMapping) {
+    // Pass null/undefined through unchanged — callers (e.g. AttachmentService.getById)
+    // may invoke this on optional fields that an OData `select` excluded.
+    if (data == null) {
+        return data;
+    }
+    // Handle array of objects
+    if (Array.isArray(data)) {
+        return data.map(item => transformData(item, fieldMapping));
+    }
+    // Walk the ORIGINAL data's keys, look up each in the mapping. One rename
+    // per data key — no mutation of an in-progress result, so chains can't form.
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const renamedKey = fieldMapping[key] ?? key;
+        result[renamedKey] = value;
+    }
+    return result;
+}
+/**
+ * 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'
+ * ```
+ */
+function camelToPascalCase(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * 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 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;
+}
+/**
+ * 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;
+}
+
 /**
  * Internal types for Maestro Cases
  * These types are used internally by the cases service
@@ -134,6 +427,8 @@ 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`,
     },
@@ -157,7 +452,26 @@ 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,
+            });
         }
     };
 }
@@ -220,24 +534,21 @@ async function fetchInstanceStatusTimeline(postFn, startTime, endTime, isCaseMan
     return response.data ?? [];
 }
 /**
- * Builds the request body for the ElementCountByStatus endpoint.
+ * Builds the commonParams request body for Insights RTM endpoints
+ * that filter by process key, package, time range, and version.
  *
- * @param processKey - Process key to filter by
- * @param packageId - Package identifier
- * @param startTime - Start of the time range to query
- * @param endTime - End of the time range to query
- * @param packageVersion - Package version to filter by
- * @returns Request body for the ElementCountByStatus endpoint
+ * @param request - Process scope + time range to aggregate over
+ * @returns Request body with commonParams
  * @internal
  */
-function buildElementCountByStatusBody(processKey, packageId, startTime, endTime, packageVersion) {
+function buildInsightsCommonBody(request) {
     return {
         commonParams: {
-            processKey,
-            packageId,
-            startTime: startTime.getTime(),
-            endTime: endTime.getTime(),
-            version: packageVersion
+            processKey: request.processKey,
+            packageId: request.packageId,
+            startTime: request.startTime.getTime(),
+            endTime: request.endTime.getTime(),
+            version: request.packageVersion
         }
     };
 }
@@ -933,539 +1244,277 @@ function processODataArrayResponse(oDataResponse, successData) {
  * Utility functions for platform detection
  */
 /**
- * Checks if code is running in a browser environment
- */
-const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-isBrowser && window.self != window.top && window.location.href.includes('source=ActionCenter');
-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)
+ * Checks if code is running in a browser environment
  */
-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'
-};
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+isBrowser && window.self != window.top && window.location.href.includes('source=ActionCenter');
+const _params = isBrowser ? new URLSearchParams(window.location.search) : null;
 /**
- * Bucket TOKEN pagination parameter names
+ * 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 BUCKET_TOKEN_PARAMS = {
-    /** Bucket page size parameter name */
-    PAGE_SIZE_PARAM: 'takeHint',
-    /** Bucket token parameter name */
-    TOKEN_PARAM: 'continuationToken'
-};
+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);
-        });
-    }
-    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);
+class PaginationManager {
+    /**
+     * Create a pagination cursor for subsequent page requests
+     */
+    static createCursor({ pageInfo, type }) {
+        if (!pageInfo.hasMore) {
+            return undefined;
         }
-        else {
-            result[transformedKey] = value;
+        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;
     }
-    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
@@ -2393,34 +2442,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
@@ -2461,6 +2555,9 @@ __decorate([
 __decorate([
     track('Cases.GetElementStats')
 ], CasesService.prototype, "getElementStats", null);
+__decorate([
+    track('Cases.GetInstanceStats')
+], CasesService.prototype, "getInstanceStats", null);
 
 /**
  * Process Incident Status