@uipath/uipath-typescript 1.0.0-beta.18 → 1.0.0

package/dist/cases/index.mjs

@@ -0,0 +1,3487 @@
+import { BatchLogRecordProcessor, LoggerProvider } from '@opentelemetry/sdk-logs';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * 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 error class for all UiPath SDK errors
+ * Pure TypeScript class with clean interface
+ */
+class UiPathError {
+    constructor(type, params) {
+        this.type = type;
+        this.message = params.message;
+        this.statusCode = params.statusCode;
+        this.requestId = params.requestId;
+        this.timestamp = new Date();
+        // Capture stack trace for debugging
+        this.stack = (new Error()).stack;
+    }
+    /**
+     * Returns a clean JSON representation of the error
+     */
+    toJSON() {
+        return {
+            type: this.type,
+            message: this.message,
+            statusCode: this.statusCode,
+            requestId: this.requestId,
+            timestamp: this.timestamp
+        };
+    }
+    /**
+     * Returns detailed debug information including stack trace
+     */
+    getDebugInfo() {
+        return {
+            ...this.toJSON(),
+            stack: this.stack
+        };
+    }
+}
+
+/**
+ * HTTP status code constants for error handling
+ */
+const HttpStatus = {
+    // Client errors (4xx)
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    TOO_MANY_REQUESTS: 429,
+    // Server errors (5xx)
+    INTERNAL_SERVER_ERROR: 500,
+    BAD_GATEWAY: 502,
+    SERVICE_UNAVAILABLE: 503,
+    GATEWAY_TIMEOUT: 504
+};
+/**
+ * Error type constants for consistent error identification
+ */
+const ErrorType = {
+    AUTHENTICATION: 'AuthenticationError',
+    AUTHORIZATION: 'AuthorizationError',
+    VALIDATION: 'ValidationError',
+    NOT_FOUND: 'NotFoundError',
+    RATE_LIMIT: 'RateLimitError',
+    SERVER: 'ServerError',
+    NETWORK: 'NetworkError'
+};
+/**
+ * HTTP header constants for error handling
+ */
+const HttpHeaders = {
+    X_REQUEST_ID: 'x-request-id'
+};
+/**
+ * Standard error message constants
+ */
+const ErrorMessages = {
+    // Authentication errors
+    AUTHENTICATION_FAILED: 'Authentication failed',
+    // Authorization errors  
+    ACCESS_DENIED: 'Access denied',
+    // Validation errors
+    VALIDATION_FAILED: 'Validation failed',
+    // Not found errors
+    RESOURCE_NOT_FOUND: 'Resource not found',
+    // Rate limit errors
+    RATE_LIMIT_EXCEEDED: 'Rate limit exceeded',
+    // Server errors
+    INTERNAL_SERVER_ERROR: 'Internal Server error occurred',
+    // Network errors
+    NETWORK_ERROR: 'Network error occurred',
+    REQUEST_TIMEOUT: 'Request timed out',
+    REQUEST_ABORTED: 'Request was aborted',
+};
+/**
+ * Error name constants for network error identification
+ */
+const ErrorNames = {
+    ABORT_ERROR: 'AbortError'};
+
+/**
+ * Error thrown when authentication fails (401 errors)
+ * Common scenarios:
+ * - Invalid credentials
+ * - Expired token
+ * - Missing authentication
+ */
+class AuthenticationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.AUTHENTICATION, {
+            message: params.message || ErrorMessages.AUTHENTICATION_FAILED,
+            statusCode: params.statusCode ?? HttpStatus.UNAUTHORIZED,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when authorization fails (403 errors)
+ * Common scenarios:
+ * - Insufficient permissions
+ * - Access denied to resource
+ * - Invalid scope
+ */
+class AuthorizationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.AUTHORIZATION, {
+            message: params.message || ErrorMessages.ACCESS_DENIED,
+            statusCode: params.statusCode ?? HttpStatus.FORBIDDEN,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when validation fails (400 errors or client-side validation)
+ * Common scenarios:
+ * - Invalid input parameters
+ * - Missing required fields
+ * - Invalid data format
+ */
+class ValidationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.VALIDATION, {
+            message: params.message || ErrorMessages.VALIDATION_FAILED,
+            statusCode: params.statusCode ?? HttpStatus.BAD_REQUEST,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when a resource is not found (404 errors)
+ * Common scenarios:
+ * - Resource doesn't exist
+ * - Invalid ID provided
+ * - Resource deleted
+ */
+class NotFoundError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.NOT_FOUND, {
+            message: params.message || ErrorMessages.RESOURCE_NOT_FOUND,
+            statusCode: params.statusCode ?? HttpStatus.NOT_FOUND,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when rate limit is exceeded (429 errors)
+ * Common scenarios:
+ * - Too many requests in a time window
+ * - API throttling
+ */
+class RateLimitError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.RATE_LIMIT, {
+            message: params.message || ErrorMessages.RATE_LIMIT_EXCEEDED,
+            statusCode: params.statusCode ?? HttpStatus.TOO_MANY_REQUESTS,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when server encounters an error (5xx errors)
+ * Common scenarios:
+ * - Internal server error
+ * - Service unavailable
+ * - Gateway timeout
+ */
+class ServerError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.SERVER, {
+            message: params.message || ErrorMessages.INTERNAL_SERVER_ERROR,
+            statusCode: params.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR,
+            requestId: params.requestId
+        });
+    }
+    /**
+     * Checks if this is a temporary error that might succeed on retry
+     */
+    get isRetryable() {
+        return this.statusCode === HttpStatus.BAD_GATEWAY ||
+            this.statusCode === HttpStatus.SERVICE_UNAVAILABLE ||
+            this.statusCode === HttpStatus.GATEWAY_TIMEOUT;
+    }
+}
+
+/**
+ * Error thrown when network/connection issues occur
+ * Common scenarios:
+ * - Connection timeout
+ * - DNS resolution failure
+ * - Network unreachable
+ * - Request aborted
+ */
+class NetworkError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.NETWORK, {
+            message: params.message || ErrorMessages.NETWORK_ERROR,
+            statusCode: params.statusCode, // Network errors typically don't have HTTP status codes
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * 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) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'error' in error &&
+        typeof error.error === 'string';
+}
+function isPimsError(error) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'type' in error &&
+        'title' in error &&
+        'status' in error &&
+        typeof error.type === 'string' &&
+        typeof error.title === 'string' &&
+        typeof error.status === 'number';
+}
+
+/**
+ * Parser for Orchestrator/Task error format
+ */
+class OrchestratorErrorParser {
+    canParse(errorBody) {
+        return isOrchestratorError(errorBody);
+    }
+    parse(errorBody, response) {
+        const error = errorBody;
+        return {
+            message: error.message,
+            code: response?.status?.toString(),
+            details: {
+                errorCode: error.errorCode,
+                traceId: error.traceId,
+                originalResponse: error
+            },
+            requestId: error.traceId
+        };
+    }
+}
+/**
+ * Parser for Entity (Data Fabric) error format
+ */
+class EntityErrorParser {
+    canParse(errorBody) {
+        return isEntityError(errorBody);
+    }
+    parse(errorBody, response) {
+        const error = errorBody;
+        return {
+            message: error.error,
+            code: response?.status?.toString(),
+            details: {
+                error: error.error,
+                traceId: error.traceId,
+                originalResponse: error
+            },
+            requestId: error.traceId
+        };
+    }
+}
+/**
+ * Parser for PIMS error format
+ */
+class PimsErrorParser {
+    canParse(errorBody) {
+        return isPimsError(errorBody);
+    }
+    parse(errorBody, response) {
+        const error = errorBody;
+        let message = error.title;
+        // If there are validation errors, append them to the message for better visibility
+        if (error.errors && Object.keys(error.errors).length > 0) {
+            const errorMessages = Object.entries(error.errors)
+                .map(([field, messages]) => `${field}: ${messages.join(', ')}`)
+                .join('; ');
+            message += `. Validation errors: ${errorMessages}`;
+        }
+        return {
+            message,
+            code: response?.status?.toString(),
+            details: {
+                type: error.type,
+                title: error.title,
+                status: error.status,
+                errors: error.errors,
+                traceId: error.traceId,
+                originalResponse: error
+            },
+            requestId: error.traceId
+        };
+    }
+}
+/**
+ * Fallback parser for unrecognized formats
+ */
+class GenericErrorParser {
+    canParse(_errorBody) {
+        return true; // Always can parse as last resort
+    }
+    parse(errorBody, response) {
+        // For unknown error formats, just pass through the raw error with fallback message
+        const message = response?.statusText || 'An error occurred';
+        return {
+            message,
+            code: response?.status?.toString(),
+            details: {
+                originalResponse: errorBody
+            },
+        };
+    }
+}
+/**
+ * Main error response parser using Chain of Responsibility pattern
+ *
+ * This parser standardizes error responses from different UiPath services into a
+ * consistent format, regardless of the original error structure.
+ *
+ * Supported formats:
+ * 1. Orchestrator/Task: { message, errorCode, traceId }
+ * 2. Entity (Data Fabric): { error, traceId }
+ * 3. PIMS/Maestro: { type, title, status, errors?, traceId? }
+ * 4. Generic: Fallback for any other format
+ *
+ * @example
+ * const parser = new ErrorResponseParser();
+ * const errorInfo = await parser.parse(response);
+ * // errorInfo will have consistent structure regardless of service
+ */
+class ErrorResponseParser {
+    constructor() {
+        this.strategies = [
+            new OrchestratorErrorParser(),
+            new EntityErrorParser(),
+            new PimsErrorParser(),
+            new GenericErrorParser() // Must be last
+        ];
+    }
+    /**
+     * Parses error response body into standardized format
+     * @param response - The HTTP response object
+     * @returns Standardized error information
+     */
+    async parse(response) {
+        try {
+            const errorBody = await response.json();
+            // Find the first strategy that can parse this error format
+            const strategy = this.strategies.find(s => s.canParse(errorBody));
+            // GenericErrorParser always returns true, so this will never be null
+            return strategy.parse(errorBody, response);
+        }
+        catch {
+            // Handle non-JSON responses
+            const responseText = await response.text().catch(() => '');
+            return {
+                message: response.statusText,
+                code: response.status.toString(),
+                details: {
+                    parseError: 'Failed to parse error response as JSON',
+                    responseText
+                },
+                requestId: response.headers.get(HttpHeaders.X_REQUEST_ID) || undefined
+            };
+        }
+    }
+}
+// Export singleton instance
+const errorResponseParser = new ErrorResponseParser();
+
+/**
+ * Factory for creating typed errors based on HTTP status codes
+ * Follows the Factory pattern for clean error instantiation
+ */
+class ErrorFactory {
+    /**
+     * Creates appropriate error instance based on HTTP status code
+     */
+    static createFromHttpStatus(statusCode, errorInfo) {
+        const { message, requestId } = errorInfo;
+        // Map status codes to error types
+        switch (statusCode) {
+            case HttpStatus.BAD_REQUEST:
+                return new ValidationError({ message, statusCode, requestId });
+            case HttpStatus.UNAUTHORIZED:
+                return new AuthenticationError({ message, statusCode, requestId });
+            case HttpStatus.FORBIDDEN:
+                return new AuthorizationError({ message, statusCode, requestId });
+            case HttpStatus.NOT_FOUND:
+                return new NotFoundError({ message, statusCode, requestId });
+            case HttpStatus.TOO_MANY_REQUESTS:
+                return new RateLimitError({ message, statusCode, requestId });
+            default:
+                // For 5xx errors or any other status code
+                if (statusCode >= HttpStatus.INTERNAL_SERVER_ERROR) {
+                    return new ServerError({ message, statusCode, requestId });
+                }
+                // For unknown client errors, treat as validation error
+                return new ValidationError({
+                    message: `${message} (HTTP ${statusCode})`,
+                    statusCode,
+                    requestId
+                });
+        }
+    }
+    /**
+     * Creates a NetworkError from a fetch/network error
+     */
+    static createNetworkError(error) {
+        let message = ErrorMessages.NETWORK_ERROR;
+        if (error instanceof Error) {
+            if (error.name === ErrorNames.ABORT_ERROR) {
+                message = ErrorMessages.REQUEST_ABORTED;
+            }
+            else if (error.message.includes('timeout')) {
+                message = ErrorMessages.REQUEST_TIMEOUT;
+            }
+            else {
+                message = error.message;
+            }
+        }
+        return new NetworkError({ message });
+    }
+}
+
+const FOLDER_KEY = 'X-UIPATH-FolderKey';
+const FOLDER_ID = 'X-UIPATH-OrganizationUnitId';
+/**
+ * Content type constants for HTTP requests/responses
+ */
+const CONTENT_TYPES = {
+    JSON: 'application/json',
+    XML: 'application/xml',
+    OCTET_STREAM: 'application/octet-stream'
+};
+/**
+ * Response type constants for HTTP requests
+ */
+const RESPONSE_TYPES = {
+    JSON: 'json',
+    TEXT: 'text',
+    BLOB: 'blob',
+    ARRAYBUFFER: 'arraybuffer'
+};
+
+class ApiClient {
+    constructor(config, executionContext, tokenManager, clientConfig = {}) {
+        this.defaultHeaders = {};
+        this.config = config;
+        this.executionContext = executionContext;
+        this.clientConfig = clientConfig;
+        this.tokenManager = tokenManager;
+    }
+    setDefaultHeaders(headers) {
+        this.defaultHeaders = { ...this.defaultHeaders, ...headers };
+    }
+    /**
+     * Gets a valid authentication token, refreshing if necessary.
+     * Used internally for API requests and exposed for services that need manual auth headers.
+     *
+     * @returns The valid token
+     * @throws AuthenticationError if no token available or refresh fails
+     */
+    async getValidToken() {
+        // Try to get token info from context
+        const tokenInfo = this.executionContext.get('tokenInfo');
+        if (!tokenInfo) {
+            throw new AuthenticationError({ message: 'No authentication token available. Make sure to initialize the SDK first.' });
+        }
+        // For secret-based tokens, they never expire
+        if (tokenInfo.type === 'secret') {
+            return tokenInfo.token;
+        }
+        // If token is not expired, return it
+        if (!this.tokenManager.isTokenExpired(tokenInfo)) {
+            return tokenInfo.token;
+        }
+        try {
+            const newToken = await this.tokenManager.refreshAccessToken();
+            return newToken.access_token;
+        }
+        catch (error) {
+            throw new AuthenticationError({
+                message: `Token refresh failed: ${error.message}. Please re-authenticate.`,
+                statusCode: HttpStatus.UNAUTHORIZED
+            });
+        }
+    }
+    async getDefaultHeaders() {
+        // Get headers from execution context first
+        const contextHeaders = this.executionContext.getHeaders();
+        // If Authorization header is already set in context, use that
+        if (contextHeaders['Authorization']) {
+            return {
+                ...contextHeaders,
+                'Content-Type': CONTENT_TYPES.JSON,
+                ...this.defaultHeaders,
+                ...this.clientConfig.headers
+            };
+        }
+        const token = await this.getValidToken();
+        return {
+            ...contextHeaders,
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': CONTENT_TYPES.JSON,
+            ...this.defaultHeaders,
+            ...this.clientConfig.headers
+        };
+    }
+    async request(method, path, options = {}) {
+        // Ensure path starts with a forward slash
+        const normalizedPath = path.startsWith('/') ? path.substring(1) : path;
+        // Construct URL with org and tenant names
+        const url = new URL(`${this.config.orgName}/${this.config.tenantName}/${normalizedPath}`, this.config.baseUrl).toString();
+        const headers = {
+            ...await this.getDefaultHeaders(),
+            ...options.headers
+        };
+        // Convert params to URLSearchParams
+        const searchParams = new URLSearchParams();
+        if (options.params) {
+            Object.entries(options.params).forEach(([key, value]) => {
+                searchParams.append(key, value.toString());
+            });
+        }
+        const fullUrl = searchParams.toString() ? `${url}?${searchParams.toString()}` : url;
+        try {
+            const response = await fetch(fullUrl, {
+                method,
+                headers,
+                body: options.body ? JSON.stringify(options.body) : undefined,
+                signal: options.signal
+            });
+            if (!response.ok) {
+                const errorInfo = await errorResponseParser.parse(response);
+                throw ErrorFactory.createFromHttpStatus(response.status, errorInfo);
+            }
+            if (response.status === 204) {
+                return undefined;
+            }
+            // Handle blob response type for binary data (e.g., file downloads)
+            if (options.responseType === RESPONSE_TYPES.BLOB) {
+                const blob = await response.blob();
+                return blob;
+            }
+            // Check if we're expecting XML
+            const acceptHeader = headers['Accept'] || headers['accept'];
+            if (acceptHeader === CONTENT_TYPES.XML) {
+                const text = await response.text();
+                return text;
+            }
+            return response.json();
+        }
+        catch (error) {
+            // If it's already one of our errors, re-throw it
+            if (error.type && error.type.includes('Error')) {
+                throw error;
+            }
+            // Otherwise, it's likely a network error
+            throw ErrorFactory.createNetworkError(error);
+        }
+    }
+    async get(path, options = {}) {
+        return this.request('GET', path, options);
+    }
+    async post(path, data, options = {}) {
+        return this.request('POST', path, { ...options, body: data });
+    }
+    async put(path, data, options = {}) {
+        return this.request('PUT', path, { ...options, body: data });
+    }
+    async patch(path, data, options = {}) {
+        return this.request('PATCH', path, { ...options, body: data });
+    }
+    async delete(path, options = {}) {
+        return this.request('DELETE', path, options);
+    }
+}
+
+/**
+ * Pagination types supported by the SDK
+ */
+var PaginationType;
+(function (PaginationType) {
+    PaginationType["OFFSET"] = "offset";
+    PaginationType["TOKEN"] = "token";
+})(PaginationType || (PaginationType = {}));
+
+/**
+ * Collection of utility functions for working with objects
+ */
+/**
+ * Filters out undefined values from an object
+ * @param obj The source object
+ * @returns A new object without undefined values
+ *
+ * @example
+ * ```typescript
+ * // Object with undefined values
+ * const options = {
+ *   name: 'test',
+ *   count: 5,
+ *   prefix: undefined,
+ *   suffix: null
+ * };
+ * const result = filterUndefined(options);
+ * // result = { name: 'test', count: 5, suffix: null }
+ * ```
+ */
+function filterUndefined(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value !== undefined) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Helper function for OData responses that ALWAYS return 200 with array indication
+ * Empty array = success, Non-empty array = error
+ * Used for task assignment APIs that don't use HTTP status codes for errors
+ */
+function processODataArrayResponse(oDataResponse, successData) {
+    // Empty array = success
+    if (oDataResponse.value.length === 0) {
+        return {
+            success: true,
+            data: successData
+        };
+    }
+    // Non-empty array = error details
+    return {
+        success: false,
+        data: oDataResponse.value
+    };
+}
+
+/**
+ * Utility functions for platform detection
+ */
+/**
+ * Checks if code is running in a browser environment
+ */
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+
+/**
+ * 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'
+};
+/**
+ * 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'
+};
+
+/**
+ * Transforms data by mapping fields according to the provided field mapping
+ * @param data The source data to transform
+ * @param fieldMapping Object mapping source field names to target field names
+ * @returns Transformed data with mapped field names
+ *
+ * @example
+ * ```typescript
+ * // Single object transformation
+ * const data = { id: '123', userName: 'john' };
+ * const mapping = { id: 'userId', userName: 'name' };
+ * const result = transformData(data, mapping);
+ * // result = { userId: '123', name: 'john' }
+ *
+ * // Array transformation
+ * const dataArray = [
+ *   { id: '123', userName: 'john' },
+ *   { id: '456', userName: 'jane' }
+ * ];
+ * const result = transformData(dataArray, mapping);
+ * // result = [
+ * //   { userId: '123', name: 'john' },
+ * //   { userId: '456', name: 'jane' }
+ * // ]
+ * ```
+ */
+function transformData(data, fieldMapping) {
+    // Handle array of objects
+    if (Array.isArray(data)) {
+        return data.map(item => transformData(item, fieldMapping));
+    }
+    // Handle single object
+    const result = { ...data };
+    for (const [sourceField, targetField] of Object.entries(fieldMapping)) {
+        if (sourceField in result) {
+            const value = result[sourceField];
+            delete result[sourceField];
+            result[targetField] = value;
+        }
+    }
+    return result;
+}
+/**
+ * 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;
+}
+
+/**
+ * Constants used throughout the pagination system
+ */
+/** Maximum number of items that can be requested in a single page */
+const MAX_PAGE_SIZE = 1000;
+/** Default page size when jumpToPage is used without specifying pageSize */
+const DEFAULT_PAGE_SIZE = 50;
+/** Default field name for items in a paginated response */
+const DEFAULT_ITEMS_FIELD = 'value';
+/** Default field name for total count in a paginated response */
+const DEFAULT_TOTAL_COUNT_FIELD = '@odata.count';
+/**
+ * Limits the page size to the maximum allowed value
+ * @param pageSize - Requested page size
+ * @returns Limited page size value
+ */
+function getLimitedPageSize(pageSize) {
+    if (pageSize === undefined || pageSize === null) {
+        return DEFAULT_PAGE_SIZE;
+    }
+    return Math.max(1, Math.min(pageSize, MAX_PAGE_SIZE));
+}
+
+/**
+ * Helper functions for pagination that can be used across services
+ */
+class PaginationHelpers {
+    /**
+     * Checks if any pagination parameters are provided
+     *
+     * @param options - The options object to check
+     * @returns True if any pagination parameter is defined, false otherwise
+     */
+    static hasPaginationParameters(options = {}) {
+        const { cursor, pageSize, jumpToPage } = options;
+        return cursor !== undefined || pageSize !== undefined || jumpToPage !== undefined;
+    }
+    /**
+     * Parse a pagination cursor string into cursor data
+     */
+    static parseCursor(cursorString) {
+        try {
+            const cursorData = JSON.parse(decodeBase64(cursorString));
+            return cursorData;
+        }
+        catch {
+            throw new Error('Invalid pagination cursor');
+        }
+    }
+    /**
+     * Validates cursor format and structure
+     *
+     * @param paginationOptions - The pagination options containing the cursor
+     * @param paginationType - Optional pagination type to validate against
+     */
+    static validateCursor(paginationOptions, paginationType) {
+        if (paginationOptions.cursor !== undefined) {
+            if (!paginationOptions.cursor || typeof paginationOptions.cursor.value !== 'string' || !paginationOptions.cursor.value) {
+                throw new Error('cursor must contain a valid cursor string');
+            }
+            try {
+                // Try to parse the cursor to validate it
+                const cursorData = PaginationHelpers.parseCursor(paginationOptions.cursor.value);
+                // If type is provided, validate cursor contains expected type information
+                if (paginationType) {
+                    if (!cursorData.type) {
+                        throw new Error('Invalid cursor: missing pagination type');
+                    }
+                    // Check pagination type compatibility
+                    if (cursorData.type !== paginationType) {
+                        throw new Error(`Pagination type mismatch: cursor is for ${cursorData.type} but service uses ${paginationType}`);
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    // If it's already our error with specific message, pass it through
+                    if (error.message.startsWith('Invalid cursor') ||
+                        error.message.startsWith('Pagination type mismatch')) {
+                        throw error;
+                    }
+                }
+                throw new Error('Invalid pagination cursor format');
+            }
+        }
+    }
+    /**
+     * Comprehensive validation for pagination options
+     *
+     * @param options - The pagination options to validate
+     * @param paginationType - The pagination type these options will be used with
+     * @returns Processed pagination parameters ready for use
+     */
+    static validatePaginationOptions(options, paginationType) {
+        // Validate pageSize
+        if (options.pageSize !== undefined && options.pageSize <= 0) {
+            throw new Error('pageSize must be a positive number');
+        }
+        // Validate jumpToPage
+        if (options.jumpToPage !== undefined && options.jumpToPage <= 0) {
+            throw new Error('jumpToPage must be a positive number');
+        }
+        // Validate cursor
+        PaginationHelpers.validateCursor(options, paginationType);
+        // Validate service compatibility
+        if (options.jumpToPage !== undefined && paginationType === PaginationType.TOKEN) {
+            throw new Error('jumpToPage is not supported for token-based pagination. Use cursor-based navigation instead.');
+        }
+        // Get processed parameters
+        return PaginationHelpers.getRequestParameters(options, paginationType);
+    }
+    /**
+     * Convert a unified pagination options to service-specific parameters
+     */
+    static getRequestParameters(options, paginationType) {
+        // Handle jumpToPage
+        if (options.jumpToPage !== undefined) {
+            const jumpToPageOptions = {
+                pageSize: options.pageSize,
+                pageNumber: options.jumpToPage
+            };
+            return filterUndefined(jumpToPageOptions);
+        }
+        // If no cursor is provided, it's a first page request
+        if (!options.cursor) {
+            const firstPageOptions = {
+                pageSize: options.pageSize,
+                // Only set pageNumber for OFFSET pagination
+                pageNumber: paginationType === PaginationType.OFFSET ? 1 : undefined
+            };
+            return filterUndefined(firstPageOptions);
+        }
+        // Parse the cursor
+        try {
+            const cursorData = PaginationHelpers.parseCursor(options.cursor.value);
+            const cursorBasedOptions = {
+                pageSize: cursorData.pageSize || options.pageSize,
+                pageNumber: cursorData.pageNumber,
+                continuationToken: cursorData.continuationToken,
+                type: cursorData.type,
+            };
+            return filterUndefined(cursorBasedOptions);
+        }
+        catch {
+            throw new Error('Invalid pagination cursor');
+        }
+    }
+    /**
+     * Helper method for paginated resource retrieval
+     *
+     * @param params - Parameters for pagination
+     * @returns Promise resolving to a paginated result
+     */
+    static async getAllPaginated(params) {
+        const { serviceAccess, getEndpoint, folderId, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        const endpoint = getEndpoint(folderId);
+        const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+        const paginatedResponse = await serviceAccess.requestWithPagination(method, endpoint, paginationParams, {
+            headers,
+            params: additionalParams,
+            pagination: {
+                paginationType: options.paginationType || PaginationType.OFFSET,
+                itemsField: options.itemsField || DEFAULT_ITEMS_FIELD,
+                totalCountField: options.totalCountField || DEFAULT_TOTAL_COUNT_FIELD,
+                continuationTokenField: options.continuationTokenField,
+                paginationParams: options.paginationParams
+            }
+        });
+        // Parse items - automatically handle JSON string responses
+        const rawItems = paginatedResponse.items;
+        const parsedItems = typeof rawItems === 'string' ? JSON.parse(rawItems) : (rawItems || []);
+        const transformedItems = transformFn ? parsedItems.map(transformFn) : parsedItems;
+        return {
+            ...paginatedResponse,
+            items: transformedItems
+        };
+    }
+    /**
+     * Helper method for non-paginated resource retrieval
+     *
+     * @param params - Parameters for non-paginated resource retrieval
+     * @returns Promise resolving to an object with data and totalCount
+     */
+    static async getAllNonPaginated(params) {
+        const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        // Set default field names
+        const itemsField = options.itemsField || DEFAULT_ITEMS_FIELD;
+        const totalCountField = options.totalCountField || DEFAULT_TOTAL_COUNT_FIELD;
+        // Determine endpoint and headers based on folderId
+        const endpoint = folderId ? getByFolderEndpoint : getAllEndpoint;
+        const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+        // Make the API call based on method
+        let response;
+        if (method === HTTP_METHODS.POST) {
+            response = await serviceAccess.post(endpoint, additionalParams, { headers });
+        }
+        else {
+            response = await serviceAccess.get(endpoint, {
+                params: additionalParams,
+                headers
+            });
+        }
+        // Extract and transform items from response
+        const rawItems = response.data?.[itemsField];
+        const totalCount = response.data?.[totalCountField];
+        // Parse items - automatically handle JSON string responses
+        const parsedItems = typeof rawItems === 'string' ? JSON.parse(rawItems) : (rawItems || []);
+        const items = transformFn ? parsedItems.map(transformFn) : parsedItems;
+        return {
+            items,
+            totalCount
+        };
+    }
+    /**
+     * Centralized getAll implementation that handles both paginated and non-paginated requests
+     *
+     * @param config - Configuration for the getAll operation
+     * @param options - Request options including pagination parameters
+     * @returns Promise resolving to either paginated or non-paginated response based on options
+     */
+    static async getAll(config, options) {
+        const optionsWithDefaults = options || {};
+        const { folderId, ...restOptions } = optionsWithDefaults;
+        const cursor = options?.cursor;
+        const pageSize = options?.pageSize;
+        const jumpToPage = options?.jumpToPage;
+        // Determine if pagination is requested
+        const isPaginationRequested = PaginationHelpers.hasPaginationParameters(options || {});
+        // Process parameters (custom processing if provided, otherwise default)
+        let processedOptions = restOptions;
+        if (config.processParametersFn) {
+            processedOptions = config.processParametersFn(restOptions, folderId);
+        }
+        // Apply ODATA prefix to keys (excluding specified keys)
+        const excludeKeys = config.excludeFromPrefix || [];
+        const keysToPrefix = Object.keys(processedOptions).filter(k => !excludeKeys.includes(k));
+        const prefixedOptions = addPrefixToKeys(processedOptions, ODATA_PREFIX, keysToPrefix);
+        // Default pagination options
+        const paginationOptions = {
+            paginationType: PaginationType.OFFSET,
+            itemsField: DEFAULT_ITEMS_FIELD,
+            totalCountField: DEFAULT_TOTAL_COUNT_FIELD,
+            ...config.pagination
+        };
+        // Paginated flow
+        if (isPaginationRequested) {
+            return PaginationHelpers.getAllPaginated({
+                serviceAccess: config.serviceAccess,
+                getEndpoint: config.getEndpoint,
+                folderId,
+                paginationParams: cursor ? { cursor, pageSize } : jumpToPage ? { jumpToPage, pageSize } : { pageSize },
+                additionalParams: prefixedOptions,
+                transformFn: config.transformFn,
+                method: config.method,
+                options: {
+                    ...paginationOptions,
+                    paginationParams: config.pagination?.paginationParams
+                }
+            }); // Type assertion needed due to conditional return
+        }
+        // Non-paginated flow
+        const byFolderEndpoint = config.getByFolderEndpoint || config.getEndpoint(folderId);
+        return PaginationHelpers.getAllNonPaginated({
+            serviceAccess: config.serviceAccess,
+            getAllEndpoint: config.getEndpoint(),
+            getByFolderEndpoint: byFolderEndpoint,
+            folderId,
+            additionalParams: prefixedOptions,
+            transformFn: config.transformFn,
+            method: config.method,
+            options: {
+                itemsField: paginationOptions.itemsField,
+                totalCountField: paginationOptions.totalCountField
+            }
+        });
+    }
+}
+
+/**
+ * SDK Internals Registry - Internal registry for SDK instances
+ *
+ * This class is NOT exported in the public API.
+ * It provides a secure way to share SDK internals between
+ * the UiPath class and service classes without exposing them publicly.
+ *
+ * @internal
+ */
+// Global symbol key to ensure WeakMap is shared across module instances
+// This prevents issues when core and service modules are bundled separately
+const REGISTRY_KEY = Symbol.for('@uipath/sdk-internals-registry');
+// Get or create the global WeakMap store
+const getGlobalStore = () => {
+    const globalObj = globalThis;
+    if (!globalObj[REGISTRY_KEY]) {
+        globalObj[REGISTRY_KEY] = new WeakMap();
+    }
+    return globalObj[REGISTRY_KEY];
+};
+/**
+ * Internal registry for SDK private components.
+ * Uses WeakMap to prevent memory leaks - entries are automatically
+ * garbage collected when the SDK instance is no longer referenced.
+ *
+ * Uses a global singleton pattern to ensure the same WeakMap is shared
+ * across separately bundled modules (core, entities, tasks, etc.).
+ *
+ * @internal - Not exported in public API
+ */
+class SDKInternalsRegistry {
+    // Use global store to ensure sharing across module bundles
+    static get store() {
+        return getGlobalStore();
+    }
+    /**
+     * Register SDK instance internals
+     * Called by UiPath constructor
+     */
+    static set(instance, internals) {
+        this.store.set(instance, internals);
+    }
+    /**
+     * Retrieve SDK instance internals
+     * Called by BaseService constructor
+     */
+    static get(instance) {
+        const internals = this.store.get(instance);
+        if (!internals) {
+            throw new Error('Invalid SDK instance. Make sure to pass a valid UiPath instance to the service constructor.');
+        }
+        return internals;
+    }
+}
+
+var _BaseService_apiClient;
+/**
+ * Base class for all UiPath SDK services.
+ *
+ * Provides common functionality for authentication, configuration, and API communication.
+ * All service classes extend this base to inherit dependency injection and HTTP client access.
+ *
+ * This class implements the dependency injection pattern where services receive a configured
+ * UiPath instance. The ApiClient is created internally and handles all HTTP operations
+ * including authentication token management.
+ *
+ * @remarks
+ * Service classes should extend this base and call `super(uiPath)` in their constructor.
+ * Protected HTTP methods (get, post, put, patch, delete) are available to all subclasses.
+ *
+ */
+class BaseService {
+    /**
+     * Creates a base service instance with dependency injection.
+     *
+     * Extracts configuration, execution context, and token manager from the UiPath instance
+     * to initialize an authenticated API client. The ApiClient handles all HTTP operations
+     * and token management internally.
+     *
+     * @param instance - UiPath SDK instance providing authentication and configuration.
+     *                    Services receive this via dependency injection in the modular pattern.
+     *
+     * @example
+     * ```typescript
+     * // Services automatically call this via super()
+     * export class EntityService extends BaseService {
+     *   constructor(instance: IUiPath) {
+     *     super(instance); // Initializes the internal ApiClient
+     *   }
+     * }
+     *
+     * // Usage in modular pattern
+     * import { UiPath } from '@uipath/uipath-typescript/core';
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const sdk = new UiPath(config);
+     * await sdk.initialize();
+     * const entities = new Entities(sdk);
+     * ```
+     */
+    constructor(instance) {
+        // Private field - not visible via Object.keys() or any reflection
+        _BaseService_apiClient.set(this, void 0);
+        const { config, context, tokenManager } = SDKInternalsRegistry.get(instance);
+        __classPrivateFieldSet(this, _BaseService_apiClient, new ApiClient(config, context, tokenManager), "f");
+    }
+    /**
+     * Gets a valid authentication token, refreshing if necessary.
+     * Use this when you need to manually add Authorization headers (e.g., direct uploads).
+     *
+     * @returns Promise resolving to a valid access token string
+     * @throws AuthenticationError if no token is available or refresh fails
+     */
+    async getValidAuthToken() {
+        return __classPrivateFieldGet(this, _BaseService_apiClient, "f").getValidToken();
+    }
+    /**
+     * Creates a service accessor for pagination helpers
+     * This allows pagination helpers to access protected methods without making them public
+     */
+    createPaginationServiceAccess() {
+        return {
+            get: (path, options) => this.get(path, options || {}),
+            post: (path, body, options) => this.post(path, body, options || {}),
+            requestWithPagination: (method, path, paginationOptions, options) => this.requestWithPagination(method, path, paginationOptions, options)
+        };
+    }
+    async request(method, path, options = {}) {
+        switch (method.toUpperCase()) {
+            case 'GET':
+                return this.get(path, options);
+            case 'POST':
+                return this.post(path, options.body, options);
+            case 'PUT':
+                return this.put(path, options.body, options);
+            case 'PATCH':
+                return this.patch(path, options.body, options);
+            case 'DELETE':
+                return this.delete(path, options);
+            default:
+                throw new Error(`Unsupported HTTP method: ${method}`);
+        }
+    }
+    async requestWithSpec(spec) {
+        if (!spec.method || !spec.url) {
+            throw new Error('Request spec must include method and url');
+        }
+        return this.request(spec.method, spec.url, spec);
+    }
+    async get(path, options = {}) {
+        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").get(path, options);
+        return { data: response };
+    }
+    async post(path, data, options = {}) {
+        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").post(path, data, options);
+        return { data: response };
+    }
+    async put(path, data, options = {}) {
+        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").put(path, data, options);
+        return { data: response };
+    }
+    async patch(path, data, options = {}) {
+        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").patch(path, data, options);
+        return { data: response };
+    }
+    async delete(path, options = {}) {
+        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").delete(path, options);
+        return { data: response };
+    }
+    /**
+     * Execute a request with cursor-based pagination
+     */
+    async requestWithPagination(method, path, paginationOptions, options) {
+        const paginationType = options.pagination.paginationType;
+        // Validate and prepare pagination parameters
+        const params = this.validateAndPreparePaginationParams(paginationType, paginationOptions);
+        // Prepare request parameters based on pagination type
+        const requestParams = this.preparePaginationRequestParams(paginationType, params, options.pagination);
+        // For POST requests, merge pagination params into body; for GET, use query params
+        if (method.toUpperCase() === 'POST') {
+            const existingBody = (options.body && typeof options.body === 'object') ? options.body : {};
+            options.body = {
+                ...existingBody,
+                ...options.params,
+                ...requestParams
+            };
+        }
+        else {
+            // Merge pagination parameters with existing parameters
+            options.params = {
+                ...options.params,
+                ...requestParams
+            };
+        }
+        // Make the request
+        const response = await this.request(method, path, options);
+        // Extract data from the response and create page result
+        return this.createPaginatedResponseFromResponse(response, params, paginationType, {
+            itemsField: options.pagination.itemsField,
+            totalCountField: options.pagination.totalCountField,
+            continuationTokenField: options.pagination.continuationTokenField
+        });
+    }
+    /**
+     * Validates and prepares pagination parameters from options
+     */
+    validateAndPreparePaginationParams(paginationType, paginationOptions) {
+        return PaginationHelpers.validatePaginationOptions(paginationOptions, paginationType);
+    }
+    /**
+     * Prepares request parameters for pagination based on pagination type
+     */
+    preparePaginationRequestParams(paginationType, params, paginationConfig) {
+        const requestParams = {};
+        let limitedPageSize;
+        const paginationParams = paginationConfig?.paginationParams;
+        switch (paginationType) {
+            case PaginationType.OFFSET:
+                limitedPageSize = getLimitedPageSize(params.pageSize);
+                const pageSizeParam = paginationParams?.pageSizeParam || ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM;
+                const offsetParam = paginationParams?.offsetParam || ODATA_OFFSET_PARAMS.OFFSET_PARAM;
+                const countParam = paginationParams?.countParam || ODATA_OFFSET_PARAMS.COUNT_PARAM;
+                requestParams[pageSizeParam] = limitedPageSize;
+                if (params.pageNumber && params.pageNumber > 1) {
+                    requestParams[offsetParam] = (params.pageNumber - 1) * limitedPageSize;
+                }
+                // Include total count for ODATA APIs
+                {
+                    requestParams[countParam] = true;
+                }
+                break;
+            case PaginationType.TOKEN:
+                const tokenPageSizeParam = paginationParams?.pageSizeParam || BUCKET_TOKEN_PARAMS.PAGE_SIZE_PARAM;
+                const tokenParam = paginationParams?.tokenParam || BUCKET_TOKEN_PARAMS.TOKEN_PARAM;
+                if (params.pageSize) {
+                    requestParams[tokenPageSizeParam] = getLimitedPageSize(params.pageSize);
+                }
+                if (params.continuationToken) {
+                    requestParams[tokenParam] = params.continuationToken;
+                }
+                break;
+        }
+        return requestParams;
+    }
+    /**
+     * Creates a paginated response from API response
+     */
+    createPaginatedResponseFromResponse(response, params, paginationType, fields) {
+        // Extract fields from response
+        const itemsField = fields.itemsField ||
+            (paginationType === PaginationType.TOKEN ? 'items' : 'value');
+        const totalCountField = fields.totalCountField || 'totalRecordCount';
+        const continuationTokenField = fields.continuationTokenField || 'continuationToken';
+        // Extract items and metadata
+        const items = response.data[itemsField] || [];
+        const totalCount = response.data[totalCountField];
+        const continuationToken = response.data[continuationTokenField];
+        // Determine if there are more pages
+        const hasMore = this.determineHasMorePages(paginationType, {
+            totalCount,
+            pageSize: params.pageSize,
+            currentPage: params.pageNumber || 1,
+            itemsCount: items.length,
+            continuationToken
+        });
+        // Create and return the page result
+        return PaginationManager.createPaginatedResponse({
+            pageInfo: {
+                hasMore,
+                totalCount,
+                currentPage: params.pageNumber,
+                pageSize: params.pageSize,
+                continuationToken
+            },
+            type: paginationType,
+        }, items);
+    }
+    /**
+     * Determines if there are more pages based on pagination type and metadata
+     */
+    determineHasMorePages(paginationType, info) {
+        switch (paginationType) {
+            case PaginationType.OFFSET:
+                const effectivePageSize = info.pageSize ?? DEFAULT_PAGE_SIZE;
+                // If totalCount is available, use it for precise calculation
+                if (info.totalCount !== undefined) {
+                    return (info.currentPage * effectivePageSize) < info.totalCount;
+                }
+                // Fallback when totalCount is not available
+                // NOTE: This code path should rarely be executed as the APIs typically return totalCount
+                return info.itemsCount === effectivePageSize;
+            case PaginationType.TOKEN:
+                return !!info.continuationToken;
+            default:
+                return false;
+        }
+    }
+}
+_BaseService_apiClient = new WeakMap();
+
+/**
+ * API Endpoint Constants
+ * Centralized location for all API endpoints used throughout the SDK
+ */
+/**
+ * Base path constants for different services
+ */
+const ORCHESTRATOR_BASE = 'orchestrator_';
+const PIMS_BASE = 'pims_';
+/**
+ * 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_EXECUTION_HISTORY: (instanceId) => `${PIMS_BASE}/api/v1/spans/${instanceId}`,
+        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`,
+    },
+    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`,
+    },
+};
+/**
+ * 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`,
+};
+
+/**
+ * SDK Telemetry constants
+ */
+// Connection string placeholder that will be replaced during build
+const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
+// SDK Version placeholder 
+const SDK_VERSION = "1.0.0";
+const VERSION = "Version";
+const SERVICE = "Service";
+const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
+const CLOUD_TENANT_NAME = "CloudTenantName";
+const CLOUD_URL = "CloudUrl";
+const CLOUD_CLIENT_ID = "CloudClientId";
+const CLOUD_REDIRECT_URI = "CloudRedirectUri";
+const APP_NAME = "ApplicationName";
+const CLOUD_ROLE_NAME = "uipath-ts-sdk";
+// Service and logger names
+const SDK_SERVICE_NAME = "UiPath.TypeScript.Sdk";
+const SDK_LOGGER_NAME = "uipath-ts-sdk-telemetry";
+// Event names
+const SDK_RUN_EVENT = "Sdk.Run";
+// Default value for unknown/empty attributes
+const UNKNOWN = "";
+
+/**
+ * Log exporter that sends ALL logs as Application Insights custom events
+ */
+class ApplicationInsightsEventExporter {
+    constructor(connectionString) {
+        this.connectionString = connectionString;
+    }
+    export(logs, resultCallback) {
+        try {
+            logs.forEach(logRecord => {
+                this.sendAsCustomEvent(logRecord);
+            });
+            resultCallback({ code: 0 });
+        }
+        catch (error) {
+            console.debug('Failed to export logs to Application Insights:', error);
+            resultCallback({ code: 2, error });
+        }
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+    sendAsCustomEvent(logRecord) {
+        // Get event name from body or attributes
+        const eventName = logRecord.body || SDK_RUN_EVENT;
+        const payload = {
+            name: 'Microsoft.ApplicationInsights.Event',
+            time: new Date().toISOString(),
+            iKey: this.extractInstrumentationKey(),
+            data: {
+                baseType: 'EventData',
+                baseData: {
+                    ver: 2,
+                    name: eventName,
+                    properties: this.convertAttributesToProperties(logRecord.attributes || {})
+                }
+            },
+            tags: {
+                'ai.cloud.role': CLOUD_ROLE_NAME,
+                'ai.cloud.roleInstance': SDK_VERSION
+            }
+        };
+        this.sendToApplicationInsights(payload);
+    }
+    extractInstrumentationKey() {
+        const match = this.connectionString.match(/InstrumentationKey=([^;]+)/);
+        return match ? match[1] : '';
+    }
+    convertAttributesToProperties(attributes) {
+        const properties = {};
+        Object.entries(attributes || {}).forEach(([key, value]) => {
+            properties[key] = String(value);
+        });
+        return properties;
+    }
+    async sendToApplicationInsights(payload) {
+        try {
+            const ingestionEndpoint = this.extractIngestionEndpoint();
+            if (!ingestionEndpoint) {
+                console.debug('No ingestion endpoint found in connection string');
+                return;
+            }
+            const url = `${ingestionEndpoint}/v2/track`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload)
+            });
+            if (!response.ok) {
+                console.debug(`Failed to send event telemetry: ${response.status} ${response.statusText}`);
+            }
+        }
+        catch (error) {
+            console.debug('Error sending event telemetry to Application Insights:', error);
+        }
+    }
+    extractIngestionEndpoint() {
+        const match = this.connectionString.match(/IngestionEndpoint=([^;]+)/);
+        return match ? match[1] : '';
+    }
+}
+/**
+ * Singleton telemetry client
+ */
+class TelemetryClient {
+    constructor() {
+        this.isInitialized = false;
+    }
+    static getInstance() {
+        if (!TelemetryClient.instance) {
+            TelemetryClient.instance = new TelemetryClient();
+        }
+        return TelemetryClient.instance;
+    }
+    /**
+     * Initialize telemetry
+     */
+    initialize(config) {
+        if (this.isInitialized) {
+            return;
+        }
+        this.isInitialized = true;
+        if (config) {
+            this.telemetryContext = config;
+        }
+        try {
+            const connectionString = this.getConnectionString();
+            if (!connectionString) {
+                return;
+            }
+            this.setupTelemetryProvider(connectionString);
+        }
+        catch (error) {
+            // Silent failure - telemetry errors shouldn't break functionality
+            console.debug('Failed to initialize OpenTelemetry:', error);
+        }
+    }
+    getConnectionString() {
+        const connectionString = CONNECTION_STRING;
+        return connectionString;
+    }
+    setupTelemetryProvider(connectionString) {
+        const exporter = new ApplicationInsightsEventExporter(connectionString);
+        const processor = new BatchLogRecordProcessor(exporter);
+        this.logProvider = new LoggerProvider({
+            processors: [processor]
+        });
+        this.logger = this.logProvider.getLogger(SDK_LOGGER_NAME);
+    }
+    /**
+     * Track a telemetry event
+     */
+    track(eventName, name, extraAttributes = {}) {
+        try {
+            // Skip if logger not initialized
+            if (!this.logger) {
+                return;
+            }
+            const finalDisplayName = name || eventName;
+            const attributes = this.getEnrichedAttributes(extraAttributes, eventName);
+            // Emit as log 
+            this.logger.emit({
+                body: finalDisplayName,
+                attributes: attributes,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            // Silent failure
+            console.debug('Failed to track telemetry event:', error);
+        }
+    }
+    /**
+     * Get enriched attributes for telemetry events
+     */
+    getEnrichedAttributes(extraAttributes, eventName) {
+        const attributes = {
+            ...extraAttributes,
+            [APP_NAME]: SDK_SERVICE_NAME,
+            [VERSION]: SDK_VERSION,
+            [SERVICE]: eventName,
+            [CLOUD_URL]: this.createCloudUrl(),
+            [CLOUD_ORGANIZATION_NAME]: this.telemetryContext?.orgName || UNKNOWN,
+            [CLOUD_TENANT_NAME]: this.telemetryContext?.tenantName || UNKNOWN,
+            [CLOUD_REDIRECT_URI]: this.telemetryContext?.redirectUri || UNKNOWN,
+            [CLOUD_CLIENT_ID]: this.telemetryContext?.clientId || UNKNOWN,
+        };
+        return attributes;
+    }
+    /**
+     * Create cloud URL from base URL, organization ID, and tenant ID
+     */
+    createCloudUrl() {
+        const baseUrl = this.telemetryContext?.baseUrl;
+        const orgId = this.telemetryContext?.orgName;
+        const tenantId = this.telemetryContext?.tenantName;
+        if (!baseUrl || !orgId || !tenantId) {
+            return UNKNOWN;
+        }
+        return `${baseUrl}/${orgId}/${tenantId}`;
+    }
+}
+// Export singleton instance
+const telemetryClient = TelemetryClient.getInstance();
+
+/**
+ * SDK Track decorator and function for telemetry
+ */
+/**
+ * Common tracking logic shared between method and function decorators
+ */
+function createTrackedFunction(originalFunction, nameOrOptions, fallbackName, opts) {
+    return function (...args) {
+        // Determine if we should track this call
+        let shouldTrack = true;
+        if (opts.condition !== undefined) {
+            if (typeof opts.condition === 'function') {
+                shouldTrack = opts.condition.apply(this, args);
+            }
+            else {
+                shouldTrack = opts.condition;
+            }
+        }
+        // Track the event if enabled
+        if (shouldTrack) {
+            // Use the full name provided in the decorator (e.g., "Queue.GetAll")
+            const serviceMethod = typeof nameOrOptions === 'string'
+                ? nameOrOptions
+                : fallbackName;
+            // Use 'Sdk.Run' as the name and serviceMethod as the service
+            telemetryClient.track(serviceMethod, SDK_RUN_EVENT, opts.attributes);
+        }
+        // Execute the original function
+        return originalFunction.apply(this, args);
+    };
+}
+/**
+ * Track decorator that can be used to automatically track function calls
+ *
+ * Usage:
+ * @track("Service.Method")
+ * function myFunction() { ... }
+ *
+ * @track("Queue.GetAll")
+ * async getAll() { ... }
+ *
+ * @track("Tasks.Create")
+ * async create() { ... }
+ *
+ * @track("Assets.Update", { condition: false })
+ * function myFunction() { ... }
+ *
+ * @track("Processes.Start", { attributes: { customProp: "value" } })
+ * function myFunction() { ... }
+ */
+function track(nameOrOptions, options) {
+    return function decorator(_target, propertyKey, descriptor) {
+        const opts = typeof nameOrOptions === 'object' ? nameOrOptions : {};
+        if (descriptor && typeof descriptor.value === 'function') {
+            // Method decorator
+            descriptor.value = createTrackedFunction(descriptor.value, nameOrOptions, propertyKey || 'unknown_method', opts);
+            return descriptor;
+        }
+        // Function decorator
+        return (originalFunction) => createTrackedFunction(originalFunction, nameOrOptions, originalFunction.name || 'unknown_function', opts);
+    };
+}
+
+/**
+ * Creates query parameters object from key-value pairs, filtering out undefined values
+ * @param paramsObj - Object containing parameter key-value pairs
+ * @returns Parameters object with undefined values filtered out
+ *
+ * @example
+ * ```typescript
+ * // Entity service parameters
+ * const params = createParams({
+ *   start: 0,
+ *   limit: 10,
+ *   expansionLevel: 1
+ * });
+ *
+ * // With optional/undefined values (automatically filtered)
+ * const params = createParams({
+ *   start: options.start,        // Could be undefined
+ *   limit: options.limit,        // Could be undefined
+ *   expansionLevel: options.expansionLevel  // Could be undefined
+ * });
+ *
+ * // Empty params
+ * const params = createParams();
+ * ```
+ */
+function createParams(paramsObj = {}) {
+    const params = {};
+    for (const [key, value] of Object.entries(paramsObj)) {
+        if (value !== undefined && value !== null) {
+            params[key] = value;
+        }
+    }
+    return params;
+}
+
+/**
+ * Service for interacting with UiPath Maestro Cases
+ */
+class CasesService extends BaseService {
+    /**
+     * Get all case management processes with their instance statistics
+     * @returns Promise resolving to array of Case objects
+     *
+     * @example
+     * ```typescript
+     * import { Cases } from '@uipath/uipath-typescript/cases';
+     *
+     * const cases = new Cases(sdk);
+     * const allCases = await cases.getAll();
+     *
+     * // Access case information
+     * for (const caseProcess of allCases) {
+     *   console.log(`Case Process: ${caseProcess.processKey}`);
+     *   console.log(`Running instances: ${caseProcess.runningCount}`);
+     *   console.log(`Completed instances: ${caseProcess.completedCount}`);
+     * }
+     * ```
+     */
+    async getAll() {
+        const params = createParams({
+            processType: ProcessType.CaseManagement
+        });
+        const response = await this.get(MAESTRO_ENDPOINTS.PROCESSES.GET_ALL, { params });
+        // Extract processes array from response data and add name field
+        const cases = response.data?.processes || [];
+        return cases.map(caseItem => ({
+            ...caseItem,
+            name: this.extractCaseName(caseItem.packageId)
+        }));
+    }
+    /**
+     * Extract a readable case name from the packageId
+     * @param packageId - The full package identifier
+     * @returns A human-readable case name
+     * @private
+     */
+    extractCaseName(packageId) {
+        // Check if packageId contains "CaseManagement."
+        const caseManagementIndex = packageId.indexOf('CaseManagement.');
+        if (caseManagementIndex !== -1) {
+            // Extract everything after "CaseManagement."
+            const afterCaseManagement = packageId.substring(caseManagementIndex + 'CaseManagement.'.length);
+            // Replace hyphens with spaces for better readability
+            return afterCaseManagement.replace(/-/g, ' ');
+        }
+        // If no "CaseManagement.", return the whole packageId
+        return packageId;
+    }
+}
+__decorate([
+    track('Cases.GetAll')
+], CasesService.prototype, "getAll", 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
+ */
+/**
+ * Case stage task type
+ */
+var StageTaskType;
+(function (StageTaskType) {
+    StageTaskType["EXTERNAL_AGENT"] = "external-agent";
+    StageTaskType["RPA"] = "rpa";
+    StageTaskType["AGENTIC_PROCESS"] = "process";
+    StageTaskType["AGENT"] = "agent";
+    StageTaskType["ACTION"] = "action";
+    StageTaskType["API_WORKFLOW"] = "api-workflow";
+})(StageTaskType || (StageTaskType = {}));
+/**
+ * Escalation recipient scope
+ */
+var EscalationRecipientScope;
+(function (EscalationRecipientScope) {
+    EscalationRecipientScope["USER"] = "user";
+    EscalationRecipientScope["USER_GROUP"] = "usergroup";
+})(EscalationRecipientScope || (EscalationRecipientScope = {}));
+/**
+ * Escalation action type
+ */
+var EscalationActionType;
+(function (EscalationActionType) {
+    EscalationActionType["NOTIFICATION"] = "notification";
+})(EscalationActionType || (EscalationActionType = {}));
+/**
+ * Escalation rule trigger type
+ */
+var EscalationTriggerType;
+(function (EscalationTriggerType) {
+    EscalationTriggerType["SLA_BREACHED"] = "sla-breached";
+    EscalationTriggerType["AT_RISK"] = "at-risk";
+})(EscalationTriggerType || (EscalationTriggerType = {}));
+/**
+ * SLA duration unit
+ */
+var SLADurationUnit;
+(function (SLADurationUnit) {
+    SLADurationUnit["HOURS"] = "h";
+    SLADurationUnit["DAYS"] = "d";
+    SLADurationUnit["WEEKS"] = "w";
+    SLADurationUnit["MONTHS"] = "m";
+})(SLADurationUnit || (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);
+        }
+    };
+}
+/**
+ * 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);
+}
+
+/**
+ * Maps fields for Case Instance entities to ensure consistent naming
+ */
+const CaseInstanceMap = {
+    startedTimeUtc: 'startedTime',
+    completedTimeUtc: 'completedTime',
+    expiryTimeUtc: 'expiredTime',
+    createdAt: 'createdTime',
+    updatedAt: 'updatedTime',
+    externalId: 'caseId',
+};
+/**
+ * Maps fields for Case App Config
+ */
+const CaseAppConfigMap = {
+    sections: 'overview',
+};
+/**
+ * Maps fields for Stage SLA configuration
+ */
+const StageSLAMap = {
+    count: 'length',
+    unit: 'duration',
+};
+/**
+ * Maps UTC time fields to simpler field names
+ * Used for transforming execution history responses
+ */
+const TimeFieldTransformMap = {
+    startedTimeUtc: 'startedTime',
+    completedTimeUtc: 'completedTime',
+};
+/**
+ * Constants for case instance stage processing
+ */
+const CASE_STAGE_CONSTANTS = {
+    TRIGGER_NODE_TYPE: 'case-management:Trigger',
+    UNDEFINED_VALUE: 'Undefined',
+    NOT_STARTED_STATUS: 'Not Started'
+};
+/**
+ * Function to generate case instance task filter by case instance ID
+ */
+const CASE_INSTANCE_TASK_FILTER = (caseInstanceId) => `Tags/any(tags:tags/DisplayName eq '${caseInstanceId}') and (IsDeleted eq false)`;
+/**
+ * Default expand parameters for case instance tasks
+ */
+const CASE_INSTANCE_TASK_EXPAND = 'AssignedToUser,Activities';
+
+var TaskType;
+(function (TaskType) {
+    TaskType["Form"] = "FormTask";
+    TaskType["External"] = "ExternalTask";
+    TaskType["App"] = "AppTask";
+})(TaskType || (TaskType = {}));
+var TaskPriority;
+(function (TaskPriority) {
+    TaskPriority["Low"] = "Low";
+    TaskPriority["Medium"] = "Medium";
+    TaskPriority["High"] = "High";
+    TaskPriority["Critical"] = "Critical";
+})(TaskPriority || (TaskPriority = {}));
+var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["Unassigned"] = "Unassigned";
+    TaskStatus["Pending"] = "Pending";
+    TaskStatus["Completed"] = "Completed";
+})(TaskStatus || (TaskStatus = {}));
+var TaskSlaCriteria;
+(function (TaskSlaCriteria) {
+    TaskSlaCriteria["TaskCreated"] = "TaskCreated";
+    TaskSlaCriteria["TaskAssigned"] = "TaskAssigned";
+    TaskSlaCriteria["TaskCompleted"] = "TaskCompleted";
+})(TaskSlaCriteria || (TaskSlaCriteria = {}));
+var TaskSlaStatus;
+(function (TaskSlaStatus) {
+    TaskSlaStatus["OverdueLater"] = "OverdueLater";
+    TaskSlaStatus["OverdueSoon"] = "OverdueSoon";
+    TaskSlaStatus["Overdue"] = "Overdue";
+    TaskSlaStatus["CompletedInTime"] = "CompletedInTime";
+})(TaskSlaStatus || (TaskSlaStatus = {}));
+var TaskSourceName;
+(function (TaskSourceName) {
+    TaskSourceName["Agent"] = "Agent";
+    TaskSourceName["Workflow"] = "Workflow";
+    TaskSourceName["Maestro"] = "Maestro";
+    TaskSourceName["Default"] = "Default";
+})(TaskSourceName || (TaskSourceName = {}));
+/**
+ * Task activity types
+ */
+var TaskActivityType;
+(function (TaskActivityType) {
+    TaskActivityType["Created"] = "Created";
+    TaskActivityType["Assigned"] = "Assigned";
+    TaskActivityType["Reassigned"] = "Reassigned";
+    TaskActivityType["Unassigned"] = "Unassigned";
+    TaskActivityType["Saved"] = "Saved";
+    TaskActivityType["Forwarded"] = "Forwarded";
+    TaskActivityType["Completed"] = "Completed";
+    TaskActivityType["Commented"] = "Commented";
+    TaskActivityType["Deleted"] = "Deleted";
+    TaskActivityType["BulkSaved"] = "BulkSaved";
+    TaskActivityType["BulkCompleted"] = "BulkCompleted";
+    TaskActivityType["FirstOpened"] = "FirstOpened";
+})(TaskActivityType || (TaskActivityType = {}));
+
+/**
+ * Creates methods for a task
+ *
+ * @param taskData - The task data (response from API)
+ * @param service - The task service instance
+ * @returns Object containing task methods
+ */
+function createTaskMethods(taskData, service) {
+    return {
+        async assign(options) {
+            if (!taskData.id)
+                throw new Error('Task ID is undefined');
+            const assignmentOptions = 'userId' in options && options.userId !== undefined
+                ? { taskId: taskData.id, userId: options.userId }
+                : { taskId: taskData.id, userNameOrEmail: options.userNameOrEmail };
+            return service.assign(assignmentOptions);
+        },
+        async reassign(options) {
+            if (!taskData.id)
+                throw new Error('Task ID is undefined');
+            const assignmentOptions = 'userId' in options && options.userId !== undefined
+                ? { taskId: taskData.id, userId: options.userId }
+                : { taskId: taskData.id, userNameOrEmail: options.userNameOrEmail };
+            return service.reassign(assignmentOptions);
+        },
+        async unassign() {
+            if (!taskData.id)
+                throw new Error('Task ID is undefined');
+            return service.unassign(taskData.id);
+        },
+        async complete(options) {
+            if (!taskData.id)
+                throw new Error('Task ID is undefined');
+            const folderId = taskData.folderId;
+            if (!folderId)
+                throw new Error('Folder ID is required');
+            return service.complete({
+                type: options.type,
+                taskId: taskData.id,
+                data: options.data,
+                action: options.action
+            }, folderId);
+        }
+    };
+}
+/**
+ * Creates an actionable task by combining API task data with operational methods.
+ *
+ * @param taskData - The task data from API
+ * @param service - The task service instance
+ * @returns A task object with added methods
+ */
+function createTaskWithMethods(taskData, service) {
+    const methods = createTaskMethods(taskData, service);
+    return Object.assign({}, taskData, methods);
+}
+
+/**
+ * Maps numeric TaskStatus values (from API) to TaskStatus enum values.
+ * Extend this file with additional field mappings as needed.
+ */
+const TaskStatusMap = {
+    0: TaskStatus.Unassigned,
+    1: TaskStatus.Pending,
+    2: TaskStatus.Completed,
+};
+// Field mapping for time-related fields to ensure consistent naming
+const TaskMap = {
+    completionTime: 'completedTime',
+    deletionTime: 'deletedTime',
+    lastModificationTime: 'lastModifiedTime',
+    creationTime: 'createdTime',
+    organizationUnitId: 'folderId'
+};
+/**
+ * Default expand parameters
+ */
+const DEFAULT_TASK_EXPAND = 'AssignedToUser,CreatorUser,LastModifierUser';
+
+/**
+ * Service for interacting with UiPath Tasks API
+ */
+class TaskService extends BaseService {
+    constructor() {
+        super(...arguments);
+        /**
+         * Process parameters for task queries with folder filtering
+         * @param options - The REST API options to process
+         * @param folderId - Optional folder ID to filter by
+         * @returns Processed options with folder filtering applied if needed
+         * @private
+         */
+        this.processTaskParameters = (options, folderId) => {
+            // Add default expand parameters
+            const processedOptions = this.addDefaultExpand(options);
+            if (folderId) {
+                // Create or add to existing filter for folder-specific queries
+                if (processedOptions.filter) {
+                    processedOptions.filter = `${processedOptions.filter} and organizationUnitId eq ${folderId}`;
+                }
+                else {
+                    processedOptions.filter = `organizationUnitId eq ${folderId}`;
+                }
+            }
+            return processedOptions;
+        };
+    }
+    /**
+     * Creates a new task
+     * @param task - The task to be created
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to the created task
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     * const task = await tasks.create({
+     *   title: "My Task",
+     *   priority: TaskPriority.Medium,
+     *   data: { key: "value" }
+     * }, 123); // folderId is required
+     * ```
+     */
+    async create(task, folderId) {
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        const externalTask = {
+            ...task,
+            type: TaskType.External //currently only external task is supported
+        };
+        const response = await this.post(TASK_ENDPOINTS.CREATE_GENERIC_TASK, externalTask, { headers });
+        // Transform time fields for consistency
+        const normalizedData = transformData(response.data, TaskMap);
+        const transformedData = applyDataTransforms(normalizedData, { field: 'status', valueMap: TaskStatusMap });
+        return createTaskWithMethods(transformedData, this);
+    }
+    /**
+     * Gets users in the given folder who have Tasks.View and Tasks.Edit permissions
+     *
+     * The method returns either:
+     * - An array of users (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param folderId - The folder ID to get users from
+     * @param options - Optional query and pagination parameters
+     * @returns Promise resolving to an array of users or paginated result
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Standard array return
+     * const users = await tasks.getUsers(123);
+     *
+     * // Get users with filtering
+     * const users = await tasks.getUsers(123, {
+     *   filter: "name eq 'abc'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await tasks.getUsers(123, { pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await tasks.getUsers(123, { cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await tasks.getUsers(123, {
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    async getUsers(folderId, options) {
+        // Transformation function for users
+        const transformUserResponse = (user) => pascalToCamelCaseKeys(user);
+        // Add folderId to options so the centralized helper can handle it properly
+        const optionsWithFolder = { ...options, folderId };
+        return PaginationHelpers.getAll({
+            serviceAccess: this.createPaginationServiceAccess(),
+            getEndpoint: (folderId) => TASK_ENDPOINTS.GET_TASK_USERS(folderId), // Use folderId from centralized helper
+            getByFolderEndpoint: TASK_ENDPOINTS.GET_TASK_USERS(folderId), // Use the passed folderId
+            transformFn: transformUserResponse,
+            pagination: {
+                paginationType: PaginationType.OFFSET,
+                itemsField: ODATA_PAGINATION.ITEMS_FIELD,
+                totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
+                paginationParams: {
+                    pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+                    offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
+                    countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
+                }
+            }
+        }, optionsWithFolder);
+    }
+    /**
+     * Gets tasks across folders with optional filtering and folder scoping
+     *
+     * The method returns either:
+     * - An array of tasks (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options - Query options including optional folderId, asTaskAdmin flag and pagination options
+     * @returns Promise resolving to an array of tasks or paginated result
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Standard array return
+     * const allTasks = await tasks.getAll();
+     *
+     * // Get tasks within a specific folder
+     * const folderTasks = await tasks.getAll({
+     *   folderId: 123
+     * });
+     *
+     * // Get tasks with admin permissions
+     * const adminTasks = await tasks.getAll({
+     *   asTaskAdmin: true
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await tasks.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await tasks.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await tasks.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    async getAll(options) {
+        // Determine which endpoint to use based on asTaskAdmin flag
+        const endpoint = options?.asTaskAdmin
+            ? TASK_ENDPOINTS.GET_TASKS_ACROSS_FOLDERS_ADMIN
+            : TASK_ENDPOINTS.GET_TASKS_ACROSS_FOLDERS;
+        // Transformation function for tasks
+        const transformTaskResponse = (task) => {
+            const transformedTask = transformData(pascalToCamelCaseKeys(task), TaskMap);
+            return createTaskWithMethods(applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }), this);
+        };
+        return PaginationHelpers.getAll({
+            serviceAccess: this.createPaginationServiceAccess(),
+            getEndpoint: () => endpoint,
+            transformFn: transformTaskResponse,
+            processParametersFn: this.processTaskParameters,
+            excludeFromPrefix: ['event'], // Exclude 'event' key from ODATA prefix transformation
+            pagination: {
+                paginationType: PaginationType.OFFSET,
+                itemsField: ODATA_PAGINATION.ITEMS_FIELD,
+                totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
+                paginationParams: {
+                    pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM, // OData OFFSET parameter
+                    offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM, // OData OFFSET parameter
+                    countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM // OData OFFSET parameter
+                }
+            }
+        }, options);
+    }
+    /**
+     * Gets a task by ID
+     * IMPORTANT: For form tasks, folderId must be provided.
+     *
+     * @param id - The ID of the task to retrieve
+     * @param options - Optional query parameters
+     * @param folderId - Optional folder ID (REQUIRED for form tasks)
+     * @returns Promise resolving to the task (form tasks will return form-specific data)
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Get task by ID
+     * const task = await tasks.getById(123);
+     *
+     * // If the task is a form task, it will automatically return form-specific data
+     * ```
+     */
+    async getById(id, options = {}, folderId) {
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        // Add default expand parameters
+        const modifiedOptions = this.addDefaultExpand(options);
+        // prefix all keys in options
+        const keysToPrefix = Object.keys(modifiedOptions);
+        const apiOptions = addPrefixToKeys(modifiedOptions, ODATA_PREFIX, keysToPrefix);
+        const response = await this.get(TASK_ENDPOINTS.GET_BY_ID(id), {
+            params: apiOptions,
+            headers
+        });
+        // Transform response from PascalCase to camelCase and normalize time fields
+        const transformedTask = transformData(pascalToCamelCaseKeys(response.data), TaskMap);
+        // Check if this is a form task and get form-specific data if it is
+        if (transformedTask.type === TaskType.Form) {
+            const formOptions = { expandOnFormLayout: true };
+            return this.getFormTaskById(id, folderId || transformedTask.folderId, formOptions);
+        }
+        return createTaskWithMethods(applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }), this);
+    }
+    /**
+     * Assigns tasks to users
+     *
+     * @param taskAssignments - Single task assignment or array of task assignments
+     * @returns Promise resolving to array of task assignment results
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Assign a single task to a user by ID
+     * const result = await tasks.assign({
+     *   taskId: 123,
+     *   userId: 456
+     * });
+     *
+     * // Assign a single task to a user by email
+     * const result = await tasks.assign({
+     *   taskId: 123,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Assign multiple tasks
+     * const result = await tasks.assign([
+     *   {
+     *     taskId: 123,
+     *     userId: 456
+     *   },
+     *   {
+     *     taskId: 789,
+     *     userNameOrEmail: "user@example.com"
+     *   }
+     * ]);
+     * ```
+     */
+    async assign(taskAssignments) {
+        // Normalize input to array
+        const assignmentArray = Array.isArray(taskAssignments) ? taskAssignments : [taskAssignments];
+        const options = {
+            taskAssignments: assignmentArray
+        };
+        // Convert options to PascalCase for API
+        const pascalOptions = camelToPascalCaseKeys(options);
+        const response = await this.post(TASK_ENDPOINTS.ASSIGN_TASKS, pascalOptions);
+        // Transform response from PascalCase to camelCase
+        const transformedResponse = pascalToCamelCaseKeys(response.data);
+        // Process OData array response - empty array = success, non-empty = error
+        return processODataArrayResponse(transformedResponse, assignmentArray);
+    }
+    /**
+     * Reassigns tasks to new users
+     *
+     * @param taskAssignments - Single task assignment or array of task assignments
+     * @returns Promise resolving to array of task assignment results
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Reassign a single task to a user by ID
+     * const result = await tasks.reassign({
+     *   taskId: 123,
+     *   userId: 456
+     * });
+     *
+     * // Reassign a single task to a user by email
+     * const result = await tasks.reassign({
+     *   taskId: 123,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Reassign multiple tasks
+     * const result = await tasks.reassign([
+     *   {
+     *     taskId: 123,
+     *     userId: 456
+     *   },
+     *   {
+     *     taskId: 789,
+     *     userNameOrEmail: "user@example.com"
+     *   }
+     * ]);
+     * ```
+     */
+    async reassign(taskAssignments) {
+        // Normalize input to array
+        const assignmentArray = Array.isArray(taskAssignments) ? taskAssignments : [taskAssignments];
+        const options = {
+            taskAssignments: assignmentArray
+        };
+        // Convert options to PascalCase for API
+        const pascalOptions = camelToPascalCaseKeys(options);
+        const response = await this.post(TASK_ENDPOINTS.REASSIGN_TASKS, pascalOptions);
+        // Transform response from PascalCase to camelCase
+        const transformedResponse = pascalToCamelCaseKeys(response.data);
+        // Process OData array response - empty array = success, non-empty = error
+        return processODataArrayResponse(transformedResponse, assignmentArray);
+    }
+    /**
+     * Unassigns tasks (removes current assignees)
+     *
+     * @param taskIds - Single task ID or array of task IDs to unassign
+     * @returns Promise resolving to array of task assignment results
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Unassign a single task
+     * const result = await tasks.unassign(123);
+     *
+     * // Unassign multiple tasks
+     * const result = await tasks.unassign([123, 456, 789]);
+     * ```
+     */
+    async unassign(taskIds) {
+        // Normalize input to array
+        const taskIdArray = Array.isArray(taskIds) ? taskIds : [taskIds];
+        const options = {
+            taskIds: taskIdArray
+        };
+        const response = await this.post(TASK_ENDPOINTS.UNASSIGN_TASKS, options);
+        // Transform response from PascalCase to camelCase
+        const transformedResponse = pascalToCamelCaseKeys(response.data);
+        // Process OData array response - empty array = success, non-empty = error
+        // Return the task IDs that were unassigned
+        return processODataArrayResponse(transformedResponse, taskIdArray.map(id => ({ taskId: id })));
+    }
+    /**
+     * Completes a task with the specified type and data
+     *
+     * @param options - The completion options including task type, taskId, data, and action
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to completion result
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Complete an app task
+     * await tasks.complete({
+     *   type: TaskType.App,
+     *   taskId: 456,
+     *   data: {},
+     *   action: "submit"
+     * }, 123); // folderId is required
+     *
+     * // Complete an external task
+     * await tasks.complete({
+     *   type: TaskType.External,
+     *   taskId: 789
+     * }, 123); // folderId is required
+     * ```
+     */
+    async complete(options, folderId) {
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        let endpoint;
+        switch (options.type) {
+            case TaskType.Form:
+                endpoint = TASK_ENDPOINTS.COMPLETE_FORM_TASK;
+                break;
+            case TaskType.App:
+                endpoint = TASK_ENDPOINTS.COMPLETE_APP_TASK;
+                break;
+            default:
+                endpoint = TASK_ENDPOINTS.COMPLETE_GENERIC_TASK;
+                break;
+        }
+        // CompleteAppTask returns 204 no content
+        await this.post(endpoint, options, { headers });
+        // Return success with the request context data
+        return {
+            success: true,
+            data: options
+        };
+    }
+    /**
+     * Gets a form task by ID (private method)
+     *
+     * @param id - The ID of the form task to retrieve
+     * @param folderId - Required folder ID
+     * @param options - Optional query parameters
+     * @returns Promise resolving to the form task
+     */
+    async getFormTaskById(id, folderId, options = {}) {
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        const response = await this.get(TASK_ENDPOINTS.GET_TASK_FORM_BY_ID, {
+            params: {
+                taskId: id,
+                ...options
+            },
+            headers
+        });
+        const transformedFormTask = transformData(response.data, TaskMap);
+        return createTaskWithMethods(applyDataTransforms(transformedFormTask, { field: 'status', valueMap: TaskStatusMap }), this);
+    }
+    /**
+     * Adds default expand parameters to options
+     * @param options - The options object to add default expand to
+     * @returns Options with default expand parameters added
+     * @private
+     */
+    addDefaultExpand(options) {
+        const processedOptions = { ...options };
+        processedOptions.expand = processedOptions.expand
+            ? `${DEFAULT_TASK_EXPAND},${processedOptions.expand}`
+            : DEFAULT_TASK_EXPAND;
+        return processedOptions;
+    }
+}
+__decorate([
+    track('Tasks.Create')
+], TaskService.prototype, "create", null);
+__decorate([
+    track('Tasks.GetUsers')
+], TaskService.prototype, "getUsers", null);
+__decorate([
+    track('Tasks.GetAll')
+], TaskService.prototype, "getAll", null);
+__decorate([
+    track('Tasks.GetById')
+], TaskService.prototype, "getById", null);
+__decorate([
+    track('Tasks.Assign')
+], TaskService.prototype, "assign", null);
+__decorate([
+    track('Tasks.Reassign')
+], TaskService.prototype, "reassign", null);
+__decorate([
+    track('Tasks.Unassign')
+], TaskService.prototype, "unassign", null);
+__decorate([
+    track('Tasks.Complete')
+], TaskService.prototype, "complete", null);
+
+class CaseInstancesService extends BaseService {
+    /**
+     * Creates an instance of the Case Instances service.
+     *
+     * @param instance - UiPath SDK instance providing authentication and configuration
+     */
+    constructor(instance) {
+        super(instance);
+        this.taskService = new TaskService(instance);
+    }
+    /**
+     * Get all case instances with optional filtering and pagination
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options -Query parameters for filtering instances and pagination
+     * @returns Promise resolving to case instances or paginated result
+     *
+     * @example
+     * ```typescript
+     * import { CaseInstances } from '@uipath/uipath-typescript/cases';
+     *
+     * const caseInstances = new CaseInstances(sdk);
+     *
+     * // Get all case instances (non-paginated)
+     * const instances = await caseInstances.getAll();
+     *
+     * // Close faulted instances using methods directly on instances
+     * for (const instance of instances.items) {
+     *   if (instance.latestRunStatus === 'Faulted') {
+     *     await instance.close({ comment: 'Closing faulted case instance' });
+     *   }
+     * }
+     *
+     * // With filtering
+     * const filtered = await caseInstances.getAll({
+     *   processKey: 'MyCaseProcess'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await caseInstances.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await caseInstances.getAll({ cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    async getAll(options) {
+        // Add processType filter to only get case management instances
+        const enhancedOptions = {
+            ...options,
+            processType: ProcessType.CaseManagement
+        };
+        // Base transformation function for case instances (synchronous)
+        const transformCaseInstance = (item) => {
+            const rawInstance = transformData(item, CaseInstanceMap);
+            return createCaseInstanceWithMethods(rawInstance, this);
+        };
+        // Get the paginated result with basic transformation
+        const result = await PaginationHelpers.getAll({
+            serviceAccess: this.createPaginationServiceAccess(),
+            getEndpoint: () => MAESTRO_ENDPOINTS.INSTANCES.GET_ALL,
+            transformFn: transformCaseInstance,
+            pagination: {
+                paginationType: PaginationType.TOKEN,
+                itemsField: PROCESS_INSTANCE_PAGINATION.ITEMS_FIELD,
+                continuationTokenField: PROCESS_INSTANCE_PAGINATION.CONTINUATION_TOKEN_FIELD,
+                paginationParams: {
+                    pageSizeParam: PROCESS_INSTANCE_TOKEN_PARAMS.PAGE_SIZE_PARAM,
+                    tokenParam: PROCESS_INSTANCE_TOKEN_PARAMS.TOKEN_PARAM
+                }
+            },
+            excludeFromPrefix: Object.keys(enhancedOptions || {})
+        }, enhancedOptions);
+        // Enhance instances with case JSON data if requested
+        if (result.items && result.items.length > 0) {
+            const enhancedItems = await this.enhanceInstancesWithCaseJson(result.items);
+            return {
+                ...result,
+                items: enhancedItems
+            };
+        }
+        return result;
+    }
+    /**
+     * Get a case instance by ID with operation methods (close, pause, resume, reopen)
+     * @param instanceId - The ID of the instance to retrieve
+     * @param folderKey - Required folder key
+     * @returns Promise<CaseInstanceGetResponse>
+     */
+    async getById(instanceId, folderKey) {
+        const response = await this.get(MAESTRO_ENDPOINTS.INSTANCES.GET_BY_ID(instanceId), {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        const transformedInstance = transformData(response.data, CaseInstanceMap);
+        const instanceWithMethods = createCaseInstanceWithMethods(transformedInstance, this);
+        // Enhance with case JSON data
+        return this.enhanceInstanceWithCaseJson(instanceWithMethods);
+    }
+    /**
+     * Enhance a single case instance with case JSON data
+     * @param instance - The case instance to enhance
+     * @returns Promise resolving to enhanced instance
+     * @private
+     */
+    async enhanceInstanceWithCaseJson(instance) {
+        if (!instance.folderKey) {
+            return instance;
+        }
+        try {
+            const caseJson = await this.getCaseJson(instance.instanceId, instance.folderKey);
+            if (caseJson && caseJson.root) {
+                // Transform caseAppConfig
+                const transformedCaseAppConfig = caseJson.root.caseAppConfig ? (() => {
+                    const transformed = transformData(caseJson.root.caseAppConfig, CaseAppConfigMap);
+                    // Remove id field from each overview item
+                    if (transformed.overview) {
+                        transformed.overview = transformed.overview.map(({ id: _, ...rest }) => rest);
+                    }
+                    return transformed;
+                })() : undefined;
+                return {
+                    ...instance,
+                    ...(transformedCaseAppConfig && { caseAppConfig: transformedCaseAppConfig }),
+                    ...(caseJson.root.name && { caseType: caseJson.root.name }),
+                    ...(caseJson.root.description && { caseTitle: caseJson.root.description })
+                };
+            }
+        }
+        catch (error) {
+            console.debug(`Failed to fetch case JSON for instance ${instance.instanceId}:`, error);
+        }
+        return instance;
+    }
+    /**
+     * Enhance multiple case instances with case JSON data
+     * @param instances - Array of case instances to enhance
+     * @returns Promise resolving to array of enhanced instances
+     * @private
+     */
+    async enhanceInstancesWithCaseJson(instances) {
+        return Promise.all(instances.map(instance => this.enhanceInstanceWithCaseJson(instance)));
+    }
+    /**
+     * Get case JSON for a specific instance
+     * @param instanceId - The case instance ID
+     * @param folderKey - Required folder key
+     * @returns Promise resolving to case JSON data
+     * @private
+     */
+    async getCaseJson(instanceId, folderKey) {
+        try {
+            const response = await this.get(MAESTRO_ENDPOINTS.CASES.GET_CASE_JSON(instanceId), {
+                headers: createHeaders({ [FOLDER_KEY]: folderKey })
+            });
+            return response.data;
+        }
+        catch {
+            // Return null if the case JSON is not available
+            return null;
+        }
+    }
+    /**
+     * Close a case instance
+     * @param instanceId - The ID of the instance to cancel
+     * @param folderKey - Required folder key
+     * @param options - Optional cancellation options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    async close(instanceId, folderKey, options) {
+        const response = await this.post(MAESTRO_ENDPOINTS.INSTANCES.CANCEL(instanceId), options || {}, {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        return {
+            success: true,
+            data: response.data
+        };
+    }
+    /**
+     * Pause a case instance
+     * @param instanceId - The ID of the instance to pause
+     * @param folderKey - Required folder key
+     * @param options - Optional pause options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    async pause(instanceId, folderKey, options) {
+        const response = await this.post(MAESTRO_ENDPOINTS.INSTANCES.PAUSE(instanceId), options || {}, {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        return {
+            success: true,
+            data: response.data
+        };
+    }
+    /**
+     * Reopen a case instance from a specified element
+     * @param instanceId - The ID of the case instance to reopen
+     * @param folderKey - Required folder key
+     * @param options - Reopen options containing stageId (the stage ID to resume from) and an optional comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    async reopen(instanceId, folderKey, options) {
+        // Transform SDK options to API request format
+        const requestBody = {
+            StartElementId: options.stageId,
+            ...(options.comment && { Comment: options.comment })
+        };
+        const response = await this.post(MAESTRO_ENDPOINTS.CASES.REOPEN(instanceId), requestBody, {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        return {
+            success: true,
+            data: response.data
+        };
+    }
+    /**
+     * Resume a case instance
+     * @param instanceId - The ID of the instance to resume
+     * @param folderKey - Required folder key
+     * @param options - Optional resume options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    async resume(instanceId, folderKey, options) {
+        const response = await this.post(MAESTRO_ENDPOINTS.INSTANCES.RESUME(instanceId), options || {}, {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        return {
+            success: true,
+            data: response.data
+        };
+    }
+    /**
+     * Get execution history for a case instance
+     * @param instanceId - The ID of the case instance
+     * @param folderKey - Required folder key
+     * @returns Promise resolving to instance execution history
+     * @example
+     * ```typescript
+     * import { CaseInstances } from '@uipath/uipath-typescript/cases';
+     *
+     * const caseInstances = new CaseInstances(sdk);
+     * const history = await caseInstances.getExecutionHistory(
+     *   'instance-id',
+     *   'folder-key'
+     * );
+     * ```
+     */
+    async getExecutionHistory(instanceId, folderKey) {
+        const response = await this.get(MAESTRO_ENDPOINTS.CASES.GET_ELEMENT_EXECUTIONS(instanceId), {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        // Transform the main response
+        const transformedResponse = transformData(response.data, TimeFieldTransformMap);
+        // Transform each element execution and its nested element runs
+        if (transformedResponse.elementExecutions && Array.isArray(transformedResponse.elementExecutions)) {
+            transformedResponse.elementExecutions = transformedResponse.elementExecutions.map((execution) => {
+                // Transform the element execution itself
+                const transformedExecution = transformData(execution, TimeFieldTransformMap);
+                // Transform nested element runs if they exist
+                if (transformedExecution.elementRuns && Array.isArray(transformedExecution.elementRuns)) {
+                    transformedExecution.elementRuns = transformedExecution.elementRuns.map((run) => transformData(run, TimeFieldTransformMap));
+                }
+                return transformedExecution;
+            });
+        }
+        return transformedResponse;
+    }
+    /**
+     * Get case stages with their associated tasks and execution status
+     * @param caseInstanceId - The ID of the case instance
+     * @param folderKey - Required folder key
+     * @returns Promise resolving to an array of case stages, each containing their tasks with execution details
+     */
+    async getStages(caseInstanceId, folderKey) {
+        // Fetch both execution history and case JSON in parallel, but handle execution failures gracefully
+        const [executionHistoryResponse, caseJsonResponse] = await Promise.allSettled([
+            this.getExecutionHistory(caseInstanceId, folderKey),
+            this.getCaseJson(caseInstanceId, folderKey)
+        ]);
+        // Extract execution history if successful, otherwise use null
+        const executionHistory = executionHistoryResponse.status === 'fulfilled'
+            ? executionHistoryResponse.value
+            : null;
+        // Extract case JSON - the null check below will handle failures
+        const caseJson = caseJsonResponse.status === 'fulfilled'
+            ? caseJsonResponse.value
+            : null;
+        if (!caseJson || !caseJson.nodes) {
+            return [];
+        }
+        // Create lookup maps for efficient data access
+        const executionMap = this.createExecutionMap(executionHistory);
+        const bindingsMap = this.createBindingsMap(caseJson);
+        // Process nodes to extract stages (exclude triggers)
+        const stages = caseJson.nodes
+            .filter((node) => node.type !== CASE_STAGE_CONSTANTS.TRIGGER_NODE_TYPE)
+            .map((node) => this.createStageFromNode(node, executionMap, bindingsMap));
+        return stages;
+    }
+    /**
+     * Create a map of element ID to execution data
+     * @param executionHistory - The execution history response
+     * @returns Map of elementId to execution metadata
+     * @private
+     */
+    createExecutionMap(executionHistory) {
+        const executionMap = new Map();
+        if (executionHistory?.elementExecutions) {
+            for (const execution of executionHistory.elementExecutions) {
+                executionMap.set(execution.elementId, execution);
+            }
+        }
+        return executionMap;
+    }
+    /**
+     * Create a map of binding IDs to their values
+     * @param caseJsonResponse - The case JSON response
+     * @returns Map of binding ID to binding object
+     * @private
+     */
+    createBindingsMap(caseJsonResponse) {
+        const bindingsMap = new Map();
+        if (caseJsonResponse?.root?.data?.uipath?.bindings) {
+            for (const binding of caseJsonResponse.root.data.uipath.bindings) {
+                if (binding.id) {
+                    bindingsMap.set(binding.id, binding);
+                }
+            }
+        }
+        return bindingsMap;
+    }
+    /**
+     * Resolve binding values from binding expressions
+     * @param value - The value that may contain binding references
+     * @param bindingsMap - Map of binding IDs to binding objects
+     * @returns Resolved value
+     * @private
+     */
+    resolveBinding(value, bindingsMap) {
+        if (typeof value === 'string' && value.startsWith('=bindings.')) {
+            const bindingId = value.substring('=bindings.'.length);
+            const binding = bindingsMap.get(bindingId);
+            return binding?.default || binding?.name || value;
+        }
+        return value;
+    }
+    /**
+     * Process tasks for a stage node
+     * @param node - The stage node containing tasks
+     * @param executionMap - Map of element IDs to execution data
+     * @param bindingsMap - Map of binding IDs to binding objects
+     * @returns Processed tasks array
+     * @private
+     */
+    processTasks(node, executionMap, bindingsMap) {
+        if (!node.data?.tasks || !Array.isArray(node.data.tasks)) {
+            return [];
+        }
+        return node.data.tasks.map((taskGroup) => {
+            if (Array.isArray(taskGroup)) {
+                return taskGroup.map((task) => {
+                    const taskId = task.id;
+                    // Find the execution data using the task's id
+                    const taskExecution = taskId ? executionMap.get(taskId) : undefined;
+                    // Resolve task name from bindings
+                    let taskName = task.displayName;
+                    if (!taskName && task.data?.name) {
+                        taskName = this.resolveBinding(task.data.name, bindingsMap);
+                    }
+                    const stageTask = {
+                        id: taskId || task.elementId || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE,
+                        name: taskName || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE,
+                        completedTime: taskExecution?.completedTime || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE,
+                        startedTime: taskExecution?.startedTime || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE,
+                        status: taskExecution?.status || CASE_STAGE_CONSTANTS.NOT_STARTED_STATUS,
+                        type: task.type || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE
+                    };
+                    return stageTask;
+                });
+            }
+            return [];
+        });
+    }
+    /**
+     * Create a stage from a case node
+     * @param node - The case node to process
+     * @param executionMap - Map of element IDs to execution data
+     * @param bindingsMap - Map of binding IDs to binding objects
+     * @returns CaseGetStageResponse object
+     * @private
+     */
+    createStageFromNode(node, executionMap, bindingsMap) {
+        const execution = executionMap.get(node.id);
+        const stage = {
+            id: node.id,
+            name: node.data?.label || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE,
+            sla: node.data?.sla ? transformData(node.data.sla, StageSLAMap) : undefined,
+            status: execution?.status || CASE_STAGE_CONSTANTS.NOT_STARTED_STATUS,
+            tasks: this.processTasks(node, executionMap, bindingsMap)
+        };
+        return stage;
+    }
+    /**
+     * Get human in the loop tasks associated with a case instance
+     * @param caseInstanceId - The ID of the case instance
+     * @param options - Optional filtering and pagination options
+     * @returns Promise resolving to human in the loop tasks associated with the case instance
+     */
+    async getActionTasks(caseInstanceId, options) {
+        // Build filter to match tasks by case instance ID using tags
+        const tagFilter = CASE_INSTANCE_TASK_FILTER(caseInstanceId);
+        // Combine with any existing filter
+        const filter = options?.filter
+            ? `(${tagFilter}) and (${options.filter})`
+            : tagFilter;
+        // Add expand to include AssignedToUser and Activities
+        const expand = CASE_INSTANCE_TASK_EXPAND;
+        // Prepare the enhanced options with proper typing
+        const enhancedOptions = {
+            ...options,
+            filter,
+            expand
+        };
+        return await this.taskService.getAll(enhancedOptions);
+    }
+}
+__decorate([
+    track('CaseInstances.GetAll')
+], CaseInstancesService.prototype, "getAll", null);
+__decorate([
+    track('CaseInstances.GetById')
+], CaseInstancesService.prototype, "getById", null);
+__decorate([
+    track('CaseInstances.Close')
+], CaseInstancesService.prototype, "close", null);
+__decorate([
+    track('CaseInstances.Pause')
+], CaseInstancesService.prototype, "pause", null);
+__decorate([
+    track('CaseInstances.Reopen')
+], CaseInstancesService.prototype, "reopen", null);
+__decorate([
+    track('CaseInstances.Resume')
+], CaseInstancesService.prototype, "resume", null);
+__decorate([
+    track('CaseInstances.GetExecutionHistory')
+], CaseInstancesService.prototype, "getExecutionHistory", null);
+__decorate([
+    track('CaseInstances.GetStages')
+], CaseInstancesService.prototype, "getStages", null);
+__decorate([
+    track('CaseInstances.GetActionTasks')
+], CaseInstancesService.prototype, "getActionTasks", null);
+
+export { CaseInstancesService as CaseInstances, CaseInstancesService, CasesService as Cases, CasesService, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, SLADurationUnit, StageTaskType, createCaseInstanceWithMethods };