@uipath/uipath-typescript 1.2.0 → 1.2.2

package/dist/tasks/index.mjs

@@ -43,31 +43,43 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 /**
- * Type guards for error response types
+ * Base error class for all UiPath SDK errors
+ * Extends Error for standard error handling compatibility
  */
-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';
+class UiPathError extends Error {
+    constructor(type, params) {
+        super(params.message);
+        this.name = type;
+        this.type = type;
+        this.statusCode = params.statusCode;
+        this.requestId = params.requestId;
+        this.timestamp = new Date();
+        // Maintains proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * 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
+        };
+    }
 }
 
 /**
@@ -131,196 +143,6 @@ const ErrorMessages = {
 const ErrorNames = {
     ABORT_ERROR: 'AbortError'};
 
-/**
- * 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();
-
-/**
- * Base error class for all UiPath SDK errors
- * Extends Error for standard error handling compatibility
- */
-class UiPathError extends Error {
-    constructor(type, params) {
-        super(params.message);
-        this.name = type;
-        this.type = type;
-        this.statusCode = params.statusCode;
-        this.requestId = params.requestId;
-        this.timestamp = new Date();
-        // Maintains proper stack trace for where our error was thrown
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
-    }
-    /**
-     * 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
-        };
-    }
-}
-
 /**
  * Error thrown when authentication fails (401 errors)
  * Common scenarios:
@@ -449,414 +271,469 @@ class NetworkError extends UiPathError {
 }
 
 /**
- * Factory for creating typed errors based on HTTP status codes
- * Follows the Factory pattern for clean error instantiation
+ * SDK Telemetry constants
  */
-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
-                });
+// 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.2.2";
+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 });
         }
     }
-    /**
-     * 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;
+    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
             }
-            else if (error.message.includes('timeout')) {
-                message = ErrorMessages.REQUEST_TIMEOUT;
+        };
+        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;
             }
-            else {
-                message = error.message;
+            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}`);
             }
         }
-        return new NetworkError({ message });
+        catch (error) {
+            console.debug('Error sending event telemetry to Application Insights:', error);
+        }
+    }
+    extractIngestionEndpoint() {
+        const match = this.connectionString.match(/IngestionEndpoint=([^;]+)/);
+        return match ? match[1] : '';
     }
 }
-
-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
+ * Singleton telemetry client
  */
-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;
+class TelemetryClient {
+    constructor() {
+        this.isInitialized = false;
     }
-    setDefaultHeaders(headers) {
-        this.defaultHeaders = { ...this.defaultHeaders, ...headers };
+    static getInstance() {
+        if (!TelemetryClient.instance) {
+            TelemetryClient.instance = new TelemetryClient();
+        }
+        return TelemetryClient.instance;
     }
     /**
-     * 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
+     * Initialize telemetry
      */
-    async getValidToken() {
-        return this.tokenManager.getValidToken();
-    }
-    async getDefaultHeaders() {
-        const token = await this.getValidToken();
-        return {
-            '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 isFormData = options.body instanceof FormData;
-        const defaultHeaders = await this.getDefaultHeaders();
-        if (isFormData) {
-            delete defaultHeaders['Content-Type'];
-        }
-        const headers = {
-            ...defaultHeaders,
-            ...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());
-            });
+    initialize(config) {
+        if (this.isInitialized) {
+            return;
         }
-        const fullUrl = searchParams.toString() ? `${url}?${searchParams.toString()}` : url;
-        let body = undefined;
-        if (options.body) {
-            body = isFormData ? options.body : JSON.stringify(options.body);
+        this.isInitialized = true;
+        if (config) {
+            this.telemetryContext = config;
         }
         try {
-            const response = await fetch(fullUrl, {
-                method,
-                headers,
-                body,
-                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;
+            const connectionString = this.getConnectionString();
+            if (!connectionString) {
+                return;
             }
-            return response.json();
+            this.setupTelemetryProvider(connectionString);
         }
         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);
+            // Silent failure - telemetry errors shouldn't break functionality
+            console.debug('Failed to initialize OpenTelemetry:', error);
         }
     }
-    async get(path, options = {}) {
-        return this.request('GET', path, options);
+    getConnectionString() {
+        const connectionString = CONNECTION_STRING;
+        return connectionString;
     }
-    async post(path, data, options = {}) {
-        return this.request('POST', path, { ...options, body: data });
+    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);
     }
-    async put(path, data, options = {}) {
-        return this.request('PUT', path, { ...options, body: data });
+    /**
+     * 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);
+        }
     }
-    async patch(path, data, options = {}) {
-        return this.request('PATCH', path, { ...options, body: data });
+    /**
+     * Get enriched attributes for telemetry events
+     */
+    getEnrichedAttributes(extraAttributes, eventName) {
+        const attributes = {
+            [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,
+            ...extraAttributes,
+        };
+        return attributes;
     }
-    async delete(path, options = {}) {
-        return this.request('DELETE', path, options);
+    /**
+     * 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();
 
 /**
- * Pagination types supported by the SDK
+ * SDK Track decorator and function for telemetry
  */
-var PaginationType;
-(function (PaginationType) {
-    PaginationType["OFFSET"] = "offset";
-    PaginationType["TOKEN"] = "token";
-})(PaginationType || (PaginationType = {}));
-
 /**
- * Collection of utility functions for working with objects
+ * 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);
+    };
+}
 /**
- * Filters out undefined values from an object
- * @param obj The source object
- * @returns A new object without undefined values
+ * Track decorator that can be used to automatically track function calls
  *
- * @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 }
- * ```
+ * 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 filterUndefined(obj) {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (value !== undefined) {
-            result[key] = value;
+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;
         }
-    }
-    return result;
+        // Function decorator
+        return (originalFunction) => createTrackedFunction(originalFunction, nameOrOptions, originalFunction.name || 'unknown_function', opts);
+    };
 }
+
 /**
- * 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
+ * Types of tasks available in Action Center.
+ * Each type determines the task's behavior, UI rendering, and completion requirements.
  */
-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
-    };
-}
+var TaskType;
+(function (TaskType) {
+    /** A form-based task that renders a UiPath form layout for user input */
+    TaskType["Form"] = "FormTask";
+    /** An externally managed task handled outside of Action Center */
+    TaskType["External"] = "ExternalTask";
+    /** A task powered by a UiPath App */
+    TaskType["App"] = "AppTask";
+    /** A document validation task for reviewing and correcting extracted document data */
+    TaskType["DocumentValidation"] = "DocumentValidationTask";
+    /** A document classification task for categorizing documents */
+    TaskType["DocumentClassification"] = "DocumentClassificationTask";
+    /** A data labeling task for annotating training data */
+    TaskType["DataLabeling"] = "DataLabelingTask";
+})(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 = {}));
 
 /**
- * Utility functions for platform detection
+ * 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'
+};
 /**
- * Checks if code is running in a browser environment
+ * Default expand parameters
  */
-const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-isBrowser && window.self != window.top && window.location.href.includes('source=ActionCenter');
+const DEFAULT_TASK_EXPAND = 'AssignedToUser,CreatorUser,LastModifierUser';
 
 /**
- * Base64 encoding/decoding
+ * Base path constants for different services
  */
+const ORCHESTRATOR_BASE = 'orchestrator_';
+
 /**
- * Encodes a string to base64
- * @param str - The string to encode
- * @returns Base64 encoded string
+ * Orchestrator Service Endpoints
  */
-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
+ * Task Service (Action Center) Endpoints
  */
-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);
-}
+const TASK_ENDPOINTS = {
+    CREATE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CreateTask`,
+    GET_TASK_USERS: (folderId) => `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTaskUsers(organizationUnitId=${folderId})`,
+    GET_TASKS_ACROSS_FOLDERS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFolders`,
+    GET_TASKS_ACROSS_FOLDERS_ADMIN: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFoldersForAdmin`,
+    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Tasks(${id})`,
+    ASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks`,
+    REASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.ReassignTasks`,
+    UNASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.UnassignTasks`,
+    COMPLETE_FORM_TASK: `${ORCHESTRATOR_BASE}/forms/TaskForms/CompleteTask`,
+    COMPLETE_APP_TASK: `${ORCHESTRATOR_BASE}/tasks/AppTasks/CompleteAppTask`,
+    COMPLETE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CompleteTask`,
+    GET_TASK_FORM_BY_ID: `${ORCHESTRATOR_BASE}/forms/TaskForms/GetTaskFormById`,
+    GET_GENERIC_TASK_BY_ID: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/GetTaskDataById`,
+    GET_APP_TASK_BY_ID: `${ORCHESTRATOR_BASE}/tasks/AppTasks/GetAppTaskById`,
+};
+
+const TASK_TYPE_ENDPOINTS = {
+    [TaskType.Form]: TASK_ENDPOINTS.GET_TASK_FORM_BY_ID,
+    [TaskType.App]: TASK_ENDPOINTS.GET_APP_TASK_BY_ID,
+    [TaskType.DocumentValidation]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
+    [TaskType.DocumentClassification]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
+    [TaskType.External]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
+    [TaskType.DataLabeling]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
+};
+var ActionCenterEventNames;
+(function (ActionCenterEventNames) {
+    ActionCenterEventNames["TOKENREFRESHED"] = "AC.tokenRefreshed";
+    ActionCenterEventNames["REFRESHTOKEN"] = "AC.refreshToken";
+})(ActionCenterEventNames || (ActionCenterEventNames = {}));
 
 /**
- * PaginationManager handles the conversion between uniform cursor-based pagination
- * and the specific pagination type for each service
+ * Creates methods for a task
+ *
+ * @param taskData - The task data (response from API)
+ * @param service - The task service instance
+ * @returns Object containing task methods
  */
-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);
+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);
         }
-        // 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
- * });
+ * Creates an actionable task by combining API task data with operational methods.
  *
- * // Empty headers
- * const headers = createHeaders();
- * ```
+ * @param taskData - The task data from API
+ * @param service - The task service instance
+ * @returns A task object with added methods
  */
-function createHeaders(headersObj) {
-    const headers = {};
-    for (const [key, value] of Object.entries(headersObj)) {
-        if (value !== undefined && value !== null) {
-            headers[key] = value.toString();
-        }
-    }
-    return headers;
+function createTaskWithMethods(taskData, service) {
+    const methods = createTaskMethods(taskData, service);
+    return Object.assign({}, taskData, methods);
 }
 
 /**
@@ -902,38 +779,154 @@ const BUCKET_TOKEN_PARAMS = {
     TOKEN_PARAM: 'continuationToken'
 };
 
+const FOLDER_ID = 'X-UIPATH-OrganizationUnitId';
 /**
- * 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
+ * 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'
+};
+
+/**
+ * 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 object transformation
- * const data = { id: '123', userName: 'john' };
- * const mapping = { id: 'userId', userName: 'name' };
- * const result = transformData(data, mapping);
- * // result = { userId: '123', name: 'john' }
+ * // Single header
+ * const headers = createHeaders({ 'X-UIPATH-FolderKey': '1234567890' });
  *
- * // 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
+ * // 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;
+}
+
+/**
+ * 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
+    };
+}
+
+/**
+ * Pagination types supported by the SDK
+ */
+var PaginationType;
+(function (PaginationType) {
+    PaginationType["OFFSET"] = "offset";
+    PaginationType["TOKEN"] = "token";
+})(PaginationType || (PaginationType = {}));
+
+/**
+ * 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) {
@@ -1179,6 +1172,63 @@ function getLimitedPageSize(pageSize) {
     return Math.max(1, Math.min(pageSize, MAX_PAGE_SIZE));
 }
 
+/**
+ * Utility functions for platform detection
+ */
+/**
+ * Checks if code is running in a browser environment
+ */
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+isBrowser && window.self != window.top && window.location.href.includes('source=ActionCenter');
+
+/**
+ * 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);
+}
+
 /**
  * Helper functions for pagination that can be used across services
  */
@@ -1432,741 +1482,720 @@ class PaginationHelpers {
 }
 
 /**
- * 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
+ * Type guards for error response types
  */
-// 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];
-};
+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';
+}
+
 /**
- * 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
+ * Parser for Orchestrator/Task error format
  */
-class SDKInternalsRegistry {
-    // Use global store to ensure sharing across module bundles
-    static get store() {
-        return getGlobalStore();
+class OrchestratorErrorParser {
+    canParse(errorBody) {
+        return isOrchestratorError(errorBody);
     }
-    /**
-     * 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;
+    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
+        };
     }
 }
-
-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.
- *
+ * Parser for Entity (Data Fabric) error format
  */
-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();
+class EntityErrorParser {
+    canParse(errorBody) {
+        return isEntityError(errorBody);
     }
-    /**
-     * Creates a service accessor for pagination helpers
-     * This allows pagination helpers to access protected methods without making them public
-     */
-    createPaginationServiceAccess() {
+    parse(errorBody, response) {
+        const error = errorBody;
         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)
+            message: error.error,
+            code: response?.status?.toString(),
+            details: {
+                error: error.error,
+                traceId: error.traceId,
+                originalResponse: error
+            },
+            requestId: error.traceId
         };
     }
-    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}`);
-        }
+}
+/**
+ * Parser for PIMS error format
+ */
+class PimsErrorParser {
+    canParse(errorBody) {
+        return isPimsError(errorBody);
     }
-    async requestWithSpec(spec) {
-        if (!spec.method || !spec.url) {
-            throw new Error('Request spec must include method and url');
+    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 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 };
+        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
+        };
     }
-    async put(path, data, options = {}) {
-        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").put(path, data, options);
-        return { data: response };
+}
+/**
+ * Fallback parser for unrecognized formats
+ */
+class GenericErrorParser {
+    canParse(_errorBody) {
+        return true; // Always can parse as last resort
     }
-    async patch(path, data, options = {}) {
-        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").patch(path, data, options);
-        return { data: response };
+    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
+            },
+        };
     }
-    async delete(path, options = {}) {
-        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").delete(path, options);
-        return { data: response };
+}
+/**
+ * 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
+        ];
     }
     /**
-     * Execute a request with cursor-based pagination
+     * Parses error response body into standardized format
+     * @param response - The HTTP response object
+     * @returns Standardized error information
      */
-    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
-            };
+    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);
         }
-        else {
-            // Merge pagination parameters with existing parameters
-            options.params = {
-                ...options.params,
-                ...requestParams
+        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
             };
         }
-        // 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
-        });
     }
+}
+// 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 {
     /**
-     * Validates and prepares pagination parameters from options
-     */
-    validateAndPreparePaginationParams(paginationType, paginationOptions) {
-        return PaginationHelpers.validatePaginationOptions(paginationOptions, paginationType);
-    }
-    /**
-     * Prepares request parameters for pagination based on pagination type
+     * Creates appropriate error instance based on HTTP status code
      */
-    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;
+    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 });
                 }
-                break;
+                // For unknown client errors, treat as validation error
+                return new ValidationError({
+                    message: `${message} (HTTP ${statusCode})`,
+                    statusCode,
+                    requestId
+                });
         }
-        return requestParams;
     }
     /**
-     * Creates a paginated response from API response
+     * Creates a NetworkError from a fetch/network error
      */
-    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);
+    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 });
+    }
+}
+
+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 };
     }
     /**
-     * Determines if there are more pages based on pagination type and metadata
+     * 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
      */
-    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;
+    async getValidToken() {
+        return this.tokenManager.getValidToken();
+    }
+    async getDefaultHeaders() {
+        const token = await this.getValidToken();
+        return {
+            '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 isFormData = options.body instanceof FormData;
+        const defaultHeaders = await this.getDefaultHeaders();
+        if (isFormData) {
+            delete defaultHeaders['Content-Type'];
+        }
+        const headers = {
+            ...defaultHeaders,
+            ...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;
+        let body = undefined;
+        if (options.body) {
+            body = isFormData ? options.body : JSON.stringify(options.body);
+        }
+        try {
+            const response = await fetch(fullUrl, {
+                method,
+                headers,
+                body,
+                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);
     }
 }
-_BaseService_apiClient = new WeakMap();
-
-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
+ * PaginationManager handles the conversion between uniform cursor-based pagination
+ * and the specific pagination type for each service
  */
-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);
+class PaginationManager {
+    /**
+     * Create a pagination cursor for subsequent page requests
+     */
+    static createCursor({ pageInfo, type }) {
+        if (!pageInfo.hasMore) {
+            return undefined;
         }
-    };
-}
-/**
- * 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';
-
-/**
- * Base path constants for different services
- */
-const ORCHESTRATOR_BASE = 'orchestrator_';
-
-/**
- * Orchestrator Service Endpoints
- */
-/**
- * Task Service (Action Center) Endpoints
- */
-const TASK_ENDPOINTS = {
-    CREATE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CreateTask`,
-    GET_TASK_USERS: (folderId) => `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTaskUsers(organizationUnitId=${folderId})`,
-    GET_TASKS_ACROSS_FOLDERS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFolders`,
-    GET_TASKS_ACROSS_FOLDERS_ADMIN: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFoldersForAdmin`,
-    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Tasks(${id})`,
-    ASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks`,
-    REASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.ReassignTasks`,
-    UNASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.UnassignTasks`,
-    COMPLETE_FORM_TASK: `${ORCHESTRATOR_BASE}/forms/TaskForms/CompleteTask`,
-    COMPLETE_APP_TASK: `${ORCHESTRATOR_BASE}/tasks/AppTasks/CompleteAppTask`,
-    COMPLETE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CompleteTask`,
-    GET_TASK_FORM_BY_ID: `${ORCHESTRATOR_BASE}/forms/TaskForms/GetTaskFormById`,
-};
-
-/**
- * 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.2.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;
+        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))
+        };
     }
-    export(logs, resultCallback) {
-        try {
-            logs.forEach(logRecord => {
-                this.sendAsCustomEvent(logRecord);
-            });
-            resultCallback({ code: 0 });
+    /**
+     * 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))
+            };
         }
-        catch (error) {
-            console.debug('Failed to export logs to Application Insights:', error);
-            resultCallback({ code: 2, error });
+        // 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;
     }
-    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);
+}
+
+/**
+ * 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();
     }
-    extractInstrumentationKey() {
-        const match = this.connectionString.match(/InstrumentationKey=([^;]+)/);
-        return match ? match[1] : '';
+    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();
     }
-    convertAttributesToProperties(attributes) {
-        const properties = {};
-        Object.entries(attributes || {}).forEach(([key, value]) => {
-            properties[key] = String(value);
-        });
-        return properties;
+    /**
+     * Register SDK instance internals
+     * Called by UiPath constructor
+     */
+    static set(instance, internals) {
+        this.store.set(instance, internals);
     }
-    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);
+    /**
+     * 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.');
         }
-    }
-    extractIngestionEndpoint() {
-        const match = this.connectionString.match(/IngestionEndpoint=([^;]+)/);
-        return match ? match[1] : '';
+        return internals;
     }
 }
+
+var _BaseService_apiClient;
 /**
- * Singleton telemetry client
+ * 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 TelemetryClient {
-    constructor() {
-        this.isInitialized = false;
+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");
     }
-    static getInstance() {
-        if (!TelemetryClient.instance) {
-            TelemetryClient.instance = new TelemetryClient();
-        }
-        return TelemetryClient.instance;
+    /**
+     * 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();
     }
     /**
-     * Initialize telemetry
+     * Creates a service accessor for pagination helpers
+     * This allows pagination helpers to access protected methods without making them public
      */
-    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);
+    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}`);
         }
-        catch (error) {
-            // Silent failure - telemetry errors shouldn't break functionality
-            console.debug('Failed to initialize OpenTelemetry:', error);
+    }
+    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 };
     }
-    getConnectionString() {
-        const connectionString = CONNECTION_STRING;
-        return connectionString;
+    async post(path, data, options = {}) {
+        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").post(path, data, options);
+        return { data: response };
     }
-    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);
+    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 };
     }
     /**
-     * Track a telemetry event
+     * Execute a request with cursor-based pagination
      */
-    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(),
-            });
+    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
+            };
         }
-        catch (error) {
-            // Silent failure
-            console.debug('Failed to track telemetry event:', error);
+        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
+        });
     }
     /**
-     * Get enriched attributes for telemetry events
+     * Validates and prepares pagination parameters from options
      */
-    getEnrichedAttributes(extraAttributes, eventName) {
-        const attributes = {
-            [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,
-            ...extraAttributes,
-        };
-        return attributes;
+    validateAndPreparePaginationParams(paginationType, paginationOptions) {
+        return PaginationHelpers.validatePaginationOptions(paginationOptions, paginationType);
     }
     /**
-     * Create cloud URL from base URL, organization ID, and tenant ID
+     * Prepares request parameters for pagination based on pagination type
      */
-    createCloudUrl() {
-        const baseUrl = this.telemetryContext?.baseUrl;
-        const orgId = this.telemetryContext?.orgName;
-        const tenantId = this.telemetryContext?.tenantName;
-        if (!baseUrl || !orgId || !tenantId) {
-            return UNKNOWN;
+    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 `${baseUrl}/${orgId}/${tenantId}`;
+        return requestParams;
     }
-}
-// 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;
+    /**
+     * 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;
         }
-        // Function decorator
-        return (originalFunction) => createTrackedFunction(originalFunction, nameOrOptions, originalFunction.name || 'unknown_function', opts);
-    };
+    }
 }
+_BaseService_apiClient = new WeakMap();
 
 /**
  * Service for interacting with UiPath Tasks API
@@ -2362,29 +2391,38 @@ class TaskService extends BaseService {
     }
     /**
      * 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)
-     *
+     * @param options - Optional query parameters including taskType for faster retrieval {@link TaskGetByIdOptions}
+     * @param folderId - Optional folder ID (REQUIRED when options.taskType is provided)
+     * @returns Promise resolving to the task
+     * {@link TaskGetResponse}
      * @example
      * ```typescript
-     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     * // Get a task by ID
+     * const task = await tasks.getById(<taskId>);
      *
-     * const tasks = new Tasks(sdk);
+     * // Get a form task by ID
+     * const formTask = await tasks.getById(<taskId>, {}, <folderId>);
      *
-     * // Get task by ID
-     * const task = await tasks.getById(123);
+     * // Access form task properties
+     * console.log(formTask.formLayout);
      *
-     * // If the task is a form task, it will automatically return form-specific data
+     * // Get a document validation task by ID (faster with taskType provided in the options)
+     * const dvTask = await tasks.getById(<taskId>, { taskType: TaskType.DocumentValidation }, <folderId>);
      * ```
      */
     async getById(id, options = {}, folderId) {
+        const { taskType, ...restOptions } = options;
+        // If taskType is provided, skip the generic GET_BY_ID call and go directly to the type-specific endpoint
+        if (taskType && taskType in TASK_TYPE_ENDPOINTS) {
+            if (!folderId) {
+                throw new ValidationError({ message: 'folderId is required when taskType is provided' });
+            }
+            return this.getByTaskType(id, folderId, taskType, restOptions);
+        }
         const headers = createHeaders({ [FOLDER_ID]: folderId });
         // Add default expand parameters
-        const modifiedOptions = this.addDefaultExpand(options);
+        const modifiedOptions = this.addDefaultExpand(restOptions);
         // prefix all keys in options
         const keysToPrefix = Object.keys(modifiedOptions);
         const apiOptions = addPrefixToKeys(modifiedOptions, ODATA_PREFIX, keysToPrefix);
@@ -2394,10 +2432,10 @@ class TaskService extends BaseService {
         });
         // 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);
+        // Get task type from response and fetch type-specific data
+        const resolvedFolderId = folderId || transformedTask.folderId;
+        if (transformedTask.type in TASK_TYPE_ENDPOINTS) {
+            return this.getByTaskType(id, resolvedFolderId, transformedTask.type, restOptions);
         }
         return createTaskWithMethods(applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }), this);
     }
@@ -2586,24 +2624,33 @@ class TaskService extends BaseService {
         };
     }
     /**
-     * Gets a form task by ID (private method)
+     * Routes to the type-specific endpoint based on task type.
+     */
+    getByTaskType(id, folderId, taskType, options = {}) {
+        const endpoint = TASK_TYPE_ENDPOINTS[taskType];
+        const extraParams = taskType === TaskType.Form ? { expandOnFormLayout: true, ...options } : options;
+        return this.getTaskByTypeEndpoint(id, folderId, endpoint, extraParams);
+    }
+    /**
+     * Fetches a task from a type-specific endpoint.
      *
-     * @param id - The ID of the form task to retrieve
+     * @param id - The task ID
      * @param folderId - Required folder ID
-     * @param options - Optional query parameters
-     * @returns Promise resolving to the form task
+     * @param endpoint - The type-specific endpoint to call
+     * @param extraParams - Additional query parameters (e.g. form options)
+     * @returns Promise resolving to the task
      */
-    async getFormTaskById(id, folderId, options = {}) {
+    async getTaskByTypeEndpoint(id, folderId, endpoint, extraParams = {}) {
         const headers = createHeaders({ [FOLDER_ID]: folderId });
-        const response = await this.get(TASK_ENDPOINTS.GET_TASK_FORM_BY_ID, {
+        const response = await this.get(endpoint, {
             params: {
                 taskId: id,
-                ...options
+                ...extraParams
             },
             headers
         });
-        const transformedFormTask = transformData(response.data, TaskMap);
-        return createTaskWithMethods(applyDataTransforms(transformedFormTask, { field: 'status', valueMap: TaskStatusMap }), this);
+        const transformedTask = transformData(response.data, TaskMap);
+        return createTaskWithMethods(applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }), this);
     }
     /**
      * Adds default expand parameters to options