@uipath/uipath-typescript 1.4.0 → 1.4.2

package/dist/orchestrator-du-module/index.cjs

@@ -0,0 +1,1788 @@
+'use strict';
+
+var coreTelemetry = require('@uipath/core-telemetry');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * SDK Telemetry constants.
+ *
+ * Only the SDK's identity (version, service name, role name, …) lives
+ * here. The Application Insights connection string is injected into
+ * `@uipath/core-telemetry` itself at publish time, and the generic attribute
+ * keys (`Version`, `Service`, `CloudOrganizationName`, …) are owned by
+ * `@uipath/core-telemetry` and consumed there — they are not part of the
+ * SDK's public API.
+ */
+/** SDK version placeholder — patched by the SDK publish workflow. */
+const CLOUD_ROLE_NAME = 'uipath-ts-sdk';
+
+/**
+ * UiPath TypeScript SDK Telemetry
+ *
+ * Constructs the SDK's own `TelemetryClient` and binds the SDK-local
+ * `track` / `trackEvent` to it. Each consumer of `@uipath/core-telemetry`
+ * does this independently, so events carry their own consumer's identity
+ * and tenant context.
+ */
+// Keyed by `CLOUD_ROLE_NAME` so every SDK subpath bundle resolves to the
+// same `TelemetryClient` instance at runtime. A single `initialize(...)`
+// from the `UiPath` constructor therefore wires up `@track` decorators
+// across every subpath bundle (`assets`, `feedback`, `tasks`, …).
+const sdkClient = coreTelemetry.getOrCreateClient(CLOUD_ROLE_NAME);
+const track = coreTelemetry.createTrack(sdkClient);
+coreTelemetry.createTrackEvent(sdkClient);
+
+/**
+ * Base path constants for different services
+ */
+const ORCHESTRATOR_BASE = 'orchestrator_';
+
+/**
+ * Orchestrator Service Endpoints
+ */
+/**
+ * Orchestrator DU Module Endpoints (validation flows)
+ */
+const ORCHESTRATOR_DU_MODULE_ENDPOINTS = {
+    SUBMIT_EXCEPTION_REPORT: `${ORCHESTRATOR_BASE}/doc-understanding/DocumentModule/SubmitExceptionReport`,
+    PROCESS_EXTRACTED_DATA: `${ORCHESTRATOR_BASE}/doc-understanding/DocumentModule/ProcessExtractedData`,
+};
+
+/**
+ * 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
+        };
+    }
+}
+
+/**
+ * HTTP status code constants for error handling
+ */
+const HttpStatus = {
+    // Client errors (4xx)
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    TOO_MANY_REQUESTS: 429,
+    // Server errors (5xx)
+    INTERNAL_SERVER_ERROR: 500,
+    BAD_GATEWAY: 502,
+    SERVICE_UNAVAILABLE: 503,
+    GATEWAY_TIMEOUT: 504
+};
+/**
+ * Error type constants for consistent error identification
+ */
+const ErrorType = {
+    AUTHENTICATION: 'AuthenticationError',
+    AUTHORIZATION: 'AuthorizationError',
+    VALIDATION: 'ValidationError',
+    NOT_FOUND: 'NotFoundError',
+    RATE_LIMIT: 'RateLimitError',
+    SERVER: 'ServerError',
+    NETWORK: 'NetworkError'
+};
+/**
+ * HTTP header constants for error handling
+ */
+const HttpHeaders = {
+    X_REQUEST_ID: 'x-request-id'
+};
+/**
+ * Standard error message constants
+ */
+const ErrorMessages = {
+    // Authentication errors
+    AUTHENTICATION_FAILED: 'Authentication failed',
+    // Authorization errors  
+    ACCESS_DENIED: 'Access denied',
+    // Validation errors
+    VALIDATION_FAILED: 'Validation failed',
+    // Not found errors
+    RESOURCE_NOT_FOUND: 'Resource not found',
+    // Rate limit errors
+    RATE_LIMIT_EXCEEDED: 'Rate limit exceeded',
+    // Server errors
+    INTERNAL_SERVER_ERROR: 'Internal Server error occurred',
+    // Network errors
+    NETWORK_ERROR: 'Network error occurred',
+    REQUEST_TIMEOUT: 'Request timed out',
+    REQUEST_ABORTED: 'Request was aborted',
+};
+/**
+ * Error name constants for network error identification
+ */
+const ErrorNames = {
+    ABORT_ERROR: 'AbortError'};
+
+/**
+ * Error thrown when authentication fails (401 errors)
+ * Common scenarios:
+ * - Invalid credentials
+ * - Expired token
+ * - Missing authentication
+ */
+class AuthenticationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.AUTHENTICATION, {
+            message: params.message || ErrorMessages.AUTHENTICATION_FAILED,
+            statusCode: params.statusCode ?? HttpStatus.UNAUTHORIZED,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when authorization fails (403 errors)
+ * Common scenarios:
+ * - Insufficient permissions
+ * - Access denied to resource
+ * - Invalid scope
+ */
+class AuthorizationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.AUTHORIZATION, {
+            message: params.message || ErrorMessages.ACCESS_DENIED,
+            statusCode: params.statusCode ?? HttpStatus.FORBIDDEN,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when validation fails (400 errors or client-side validation)
+ * Common scenarios:
+ * - Invalid input parameters
+ * - Missing required fields
+ * - Invalid data format
+ */
+class ValidationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.VALIDATION, {
+            message: params.message || ErrorMessages.VALIDATION_FAILED,
+            statusCode: params.statusCode ?? HttpStatus.BAD_REQUEST,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when a resource is not found (404 errors)
+ * Common scenarios:
+ * - Resource doesn't exist
+ * - Invalid ID provided
+ * - Resource deleted
+ */
+class NotFoundError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.NOT_FOUND, {
+            message: params.message || ErrorMessages.RESOURCE_NOT_FOUND,
+            statusCode: params.statusCode ?? HttpStatus.NOT_FOUND,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when rate limit is exceeded (429 errors)
+ * Common scenarios:
+ * - Too many requests in a time window
+ * - API throttling
+ */
+class RateLimitError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.RATE_LIMIT, {
+            message: params.message || ErrorMessages.RATE_LIMIT_EXCEEDED,
+            statusCode: params.statusCode ?? HttpStatus.TOO_MANY_REQUESTS,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when server encounters an error (5xx errors)
+ * Common scenarios:
+ * - Internal server error
+ * - Service unavailable
+ * - Gateway timeout
+ */
+class ServerError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.SERVER, {
+            message: params.message || ErrorMessages.INTERNAL_SERVER_ERROR,
+            statusCode: params.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR,
+            requestId: params.requestId
+        });
+    }
+    /**
+     * Checks if this is a temporary error that might succeed on retry
+     */
+    get isRetryable() {
+        return this.statusCode === HttpStatus.BAD_GATEWAY ||
+            this.statusCode === HttpStatus.SERVICE_UNAVAILABLE ||
+            this.statusCode === HttpStatus.GATEWAY_TIMEOUT;
+    }
+}
+
+/**
+ * Error thrown when network/connection issues occur
+ * Common scenarios:
+ * - Connection timeout
+ * - DNS resolution failure
+ * - Network unreachable
+ * - Request aborted
+ */
+class NetworkError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.NETWORK, {
+            message: params.message || ErrorMessages.NETWORK_ERROR,
+            statusCode: params.statusCode, // Network errors typically don't have HTTP status codes
+            requestId: params.requestId
+        });
+    }
+}
+
+const FOLDER_KEY = 'X-UIPATH-FolderKey';
+const FOLDER_PATH_ENCODED = 'X-UIPATH-FolderPath-Encoded';
+const FOLDER_ID = 'X-UIPATH-OrganizationUnitId';
+const TRACEPARENT = 'traceparent';
+const UIPATH_TRACEPARENT_ID = 'x-uipath-traceparent-id';
+/**
+ * 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 header
+ * const headers = createHeaders({ 'X-UIPATH-FolderKey': '1234567890' });
+ *
+ * // Multiple headers
+ * const headers = createHeaders({
+ *   'X-UIPATH-FolderKey': '1234567890',
+ *   'X-UIPATH-OrganizationUnitId': 123,
+ *   'Accept': 'application/json'
+ * });
+ *
+ * // Using constants
+ * import { FOLDER_KEY, FOLDER_ID } from '../constants/headers';
+ * const headers = createHeaders({
+ *   [FOLDER_KEY]: 'abc-123',
+ *   [FOLDER_ID]: 456
+ * });
+ *
+ * // Empty headers
+ * const headers = createHeaders();
+ * ```
+ */
+function createHeaders(headersObj) {
+    const headers = {};
+    for (const [key, value] of Object.entries(headersObj)) {
+        if (value !== undefined && value !== null) {
+            headers[key] = value.toString();
+        }
+    }
+    return headers;
+}
+
+/**
+ * Encodes a folder path for the `X-UIPATH-FolderPath-Encoded` header.
+ *
+ * Orchestrator decodes this header as **base64-encoded UTF-16 LE bytes**
+ * (see `HttpHeadersProviderExtensions.GetDecoded` + `OrganizationUnitProvider`
+ * in the Orchestrator repo, which call `Encoding.Unicode.GetString(...)`).
+ * URL-encoding is NOT what the server expects — it must be base64-of-UTF-16-LE
+ * bytes.
+ *
+ * @param folderPath - The folder path (e.g. 'Shared/Finance')
+ * @returns Base64 string suitable for the `X-UIPATH-FolderPath-Encoded` header
+ */
+function encodeFolderPathHeader(folderPath) {
+    // Force little-endian regardless of host byte order. `Uint16Array` viewed
+    // as `Uint8Array` would use the host's native order — correct on LE hosts
+    // (x86/ARM-LE) but wrong on BE hosts. `DataView.setUint16(..., true)`
+    // pins LE.
+    const buf = new ArrayBuffer(folderPath.length * 2);
+    const view = new DataView(buf);
+    for (let i = 0; i < folderPath.length; i++) {
+        view.setUint16(i * 2, folderPath.charCodeAt(i), true);
+    }
+    const bytes = new Uint8Array(buf);
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    // btoa is browser-native; Node 16+ also has it as a global
+    return btoa(binary);
+}
+
+/**
+ * Resolves folder context into the appropriate Orchestrator folder headers.
+ *
+ * Centralized so all folder-scoped methods (e.g. `assets.getByName`,
+ * `processes.getByName`, future Queues/Buckets/Jobs) share one implementation.
+ *
+ * Each input field maps directly to its header — no auto-detection or type
+ * coercion. When multiple fields are supplied, all corresponding headers
+ * are forwarded and the server resolves precedence.
+ *
+ * Routing:
+ * - `folderId` → `X-UIPATH-OrganizationUnitId`
+ * - `folderKey` → `X-UIPATH-FolderKey`
+ * - `folderPath` → `X-UIPATH-FolderPath-Encoded`
+ * - none set + `fallbackFolderKey` → fallback used as `X-UIPATH-FolderKey`
+ * - none set + no fallback → `ValidationError`
+ *
+ * @throws ValidationError when no folder context can be resolved.
+ */
+function resolveFolderHeaders(input) {
+    const { folderId, folderKey, folderPath, resourceType, fallbackFolderKey } = input;
+    const trimmedKey = folderKey?.trim();
+    const trimmedPath = folderPath?.trim();
+    const headers = {};
+    if (folderId !== undefined) {
+        headers[FOLDER_ID] = folderId;
+    }
+    if (trimmedKey) {
+        headers[FOLDER_KEY] = trimmedKey;
+    }
+    if (trimmedPath) {
+        headers[FOLDER_PATH_ENCODED] = encodeFolderPathHeader(trimmedPath);
+    }
+    // No explicit folder context → meta-tag fallback or error.
+    if (Object.keys(headers).length === 0) {
+        if (!fallbackFolderKey) {
+            throw new ValidationError({
+                message: `${resourceType} requires folder context: pass \`folderId\`, \`folderKey\`, or \`folderPath\`, or initialize the SDK with a folder context.`,
+            });
+        }
+        headers[FOLDER_KEY] = fallbackFolderKey;
+    }
+    return createHeaders(headers);
+}
+
+/**
+ * Type guards for error response types
+ */
+function isOrchestratorError(error) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        'errorCode' in error &&
+        typeof error.message === 'string' &&
+        typeof error.errorCode === 'number';
+}
+function isEntityError(error) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'error' in error &&
+        typeof error.error === 'string';
+}
+function isPimsError(error) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'type' in error &&
+        'title' in error &&
+        'status' in error &&
+        typeof error.type === 'string' &&
+        typeof error.title === 'string' &&
+        typeof error.status === 'number';
+}
+
+/**
+ * Parser for Orchestrator/Task error format
+ */
+class OrchestratorErrorParser {
+    canParse(errorBody) {
+        return isOrchestratorError(errorBody);
+    }
+    parse(errorBody, response) {
+        const error = errorBody;
+        return {
+            message: error.message,
+            code: response?.status?.toString(),
+            details: {
+                errorCode: error.errorCode,
+                traceId: error.traceId,
+                originalResponse: error
+            },
+            requestId: error.traceId
+        };
+    }
+}
+/**
+ * Parser for Entity (Data Fabric) error format
+ */
+class EntityErrorParser {
+    canParse(errorBody) {
+        return isEntityError(errorBody);
+    }
+    parse(errorBody, response) {
+        const error = errorBody;
+        return {
+            message: error.error,
+            code: response?.status?.toString(),
+            details: {
+                error: error.error,
+                traceId: error.traceId,
+                originalResponse: error
+            },
+            requestId: error.traceId
+        };
+    }
+}
+/**
+ * Parser for PIMS error format
+ */
+class PimsErrorParser {
+    canParse(errorBody) {
+        return isPimsError(errorBody);
+    }
+    parse(errorBody, response) {
+        const error = errorBody;
+        let message = error.title;
+        // If there are validation errors, append them to the message for better visibility
+        if (error.errors && Object.keys(error.errors).length > 0) {
+            const errorMessages = Object.entries(error.errors)
+                .map(([field, messages]) => `${field}: ${messages.join(', ')}`)
+                .join('; ');
+            message += `. Validation errors: ${errorMessages}`;
+        }
+        return {
+            message,
+            code: response?.status?.toString(),
+            details: {
+                type: error.type,
+                title: error.title,
+                status: error.status,
+                errors: error.errors,
+                traceId: error.traceId,
+                originalResponse: error
+            },
+            requestId: error.traceId
+        };
+    }
+}
+/**
+ * Fallback parser for unrecognized formats
+ */
+class GenericErrorParser {
+    canParse(_errorBody) {
+        return true; // Always can parse as last resort
+    }
+    parse(errorBody, response) {
+        // For unknown error formats, just pass through the raw error with fallback message
+        const message = response?.statusText || 'An error occurred';
+        return {
+            message,
+            code: response?.status?.toString(),
+            details: {
+                originalResponse: errorBody
+            },
+        };
+    }
+}
+/**
+ * Main error response parser using Chain of Responsibility pattern
+ *
+ * This parser standardizes error responses from different UiPath services into a
+ * consistent format, regardless of the original error structure.
+ *
+ * Supported formats:
+ * 1. Orchestrator/Task: { message, errorCode, traceId }
+ * 2. Entity (Data Fabric): { error, traceId }
+ * 3. PIMS/Maestro: { type, title, status, errors?, traceId? }
+ * 4. Generic: Fallback for any other format
+ *
+ * @example
+ * const parser = new ErrorResponseParser();
+ * const errorInfo = await parser.parse(response);
+ * // errorInfo will have consistent structure regardless of service
+ */
+class ErrorResponseParser {
+    constructor() {
+        this.strategies = [
+            new OrchestratorErrorParser(),
+            new EntityErrorParser(),
+            new PimsErrorParser(),
+            new GenericErrorParser() // Must be last
+        ];
+    }
+    /**
+     * Parses error response body into standardized format
+     * @param response - The HTTP response object
+     * @returns Standardized error information
+     */
+    async parse(response) {
+        try {
+            const errorBody = await response.json();
+            // Find the first strategy that can parse this error format
+            const strategy = this.strategies.find(s => s.canParse(errorBody));
+            // GenericErrorParser always returns true, so this will never be null
+            return strategy.parse(errorBody, response);
+        }
+        catch {
+            // Handle non-JSON responses
+            const responseText = await response.text().catch(() => '');
+            return {
+                message: response.statusText,
+                code: response.status.toString(),
+                details: {
+                    parseError: 'Failed to parse error response as JSON',
+                    responseText
+                },
+                requestId: response.headers.get(HttpHeaders.X_REQUEST_ID) || undefined
+            };
+        }
+    }
+}
+// Export singleton instance
+const errorResponseParser = new ErrorResponseParser();
+
+/**
+ * Factory for creating typed errors based on HTTP status codes
+ * Follows the Factory pattern for clean error instantiation
+ */
+class ErrorFactory {
+    /**
+     * Creates appropriate error instance based on HTTP status code
+     */
+    static createFromHttpStatus(statusCode, errorInfo) {
+        const { message, requestId } = errorInfo;
+        // Map status codes to error types
+        switch (statusCode) {
+            case HttpStatus.BAD_REQUEST:
+                return new ValidationError({ message, statusCode, requestId });
+            case HttpStatus.UNAUTHORIZED:
+                return new AuthenticationError({ message, statusCode, requestId });
+            case HttpStatus.FORBIDDEN:
+                return new AuthorizationError({ message, statusCode, requestId });
+            case HttpStatus.NOT_FOUND:
+                return new NotFoundError({ message, statusCode, requestId });
+            case HttpStatus.TOO_MANY_REQUESTS:
+                return new RateLimitError({ message, statusCode, requestId });
+            default:
+                // For 5xx errors or any other status code
+                if (statusCode >= HttpStatus.INTERNAL_SERVER_ERROR) {
+                    return new ServerError({ message, statusCode, requestId });
+                }
+                // For unknown client errors, treat as validation error
+                return new ValidationError({
+                    message: `${message} (HTTP ${statusCode})`,
+                    statusCode,
+                    requestId
+                });
+        }
+    }
+    /**
+     * Creates a NetworkError from a fetch/network error
+     */
+    static createNetworkError(error) {
+        let message = ErrorMessages.NETWORK_ERROR;
+        if (error instanceof Error) {
+            if (error.name === ErrorNames.ABORT_ERROR) {
+                message = ErrorMessages.REQUEST_ABORTED;
+            }
+            else if (error.message.includes('timeout')) {
+                message = ErrorMessages.REQUEST_TIMEOUT;
+            }
+            else {
+                message = error.message;
+            }
+        }
+        return new NetworkError({ message });
+    }
+}
+
+class ApiClient {
+    constructor(config, executionContext, tokenManager, clientConfig = {}) {
+        this.config = config;
+        this.executionContext = executionContext;
+        this.clientConfig = clientConfig;
+        this.tokenManager = tokenManager;
+    }
+    /**
+     * Gets a valid authentication token, refreshing if necessary.
+     * Used internally for API requests and exposed for services that need manual auth headers.
+     *
+     * @returns The valid token
+     * @throws AuthenticationError if no token available or refresh fails
+     */
+    async getValidToken() {
+        return this.tokenManager.getValidToken();
+    }
+    async getDefaultHeaders() {
+        const token = await this.getValidToken();
+        return {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': CONTENT_TYPES.JSON,
+            ...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 traceId = crypto.randomUUID().replace(/-/g, '');
+        const spanId = crypto.randomUUID().replace(/-/g, '').slice(0, 16);
+        const traceparentValue = `00-${traceId}-${spanId}-01`;
+        const headers = {
+            ...defaultHeaders,
+            [TRACEPARENT]: traceparentValue,
+            [UIPATH_TRACEPARENT_ID]: traceparentValue,
+            ...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;
+            }
+            const text = await response.text();
+            if (!text) {
+                return undefined;
+            }
+            try {
+                return JSON.parse(text);
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    throw new ServerError({
+                        message: `Server returned non-JSON response (${response.status} ${response.url}): ${error.message}`,
+                        statusCode: response.status,
+                    });
+                }
+                throw error;
+            }
+        }
+        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 a genuine network/fetch failure
+            throw ErrorFactory.createNetworkError(error);
+        }
+    }
+    async get(path, options = {}) {
+        return this.request('GET', path, options);
+    }
+    async post(path, data, options = {}) {
+        return this.request('POST', path, { ...options, body: data });
+    }
+    async put(path, data, options = {}) {
+        return this.request('PUT', path, { ...options, body: data });
+    }
+    async patch(path, data, options = {}) {
+        return this.request('PATCH', path, { ...options, body: data });
+    }
+    async delete(path, options = {}) {
+        return this.request('DELETE', path, options);
+    }
+}
+
+/**
+ * Pagination types supported by the SDK
+ */
+var PaginationType;
+(function (PaginationType) {
+    PaginationType["OFFSET"] = "offset";
+    PaginationType["TOKEN"] = "token";
+})(PaginationType || (PaginationType = {}));
+
+/**
+ * Collection of utility functions for working with objects
+ */
+/**
+ * Resolves a field value from an object, supporting both direct keys (e.g., '@odata.count')
+ * and dot-separated nested paths (e.g., 'pagination.totalCount').
+ * Direct key match takes priority over nested traversal.
+ */
+function resolveNestedField(data, fieldPath) {
+    if (!data) {
+        return undefined;
+    }
+    if (fieldPath in data) {
+        return data[fieldPath];
+    }
+    if (!fieldPath.includes('.')) {
+        return undefined;
+    }
+    let value = data;
+    for (const part of fieldPath.split('.')) {
+        value = value?.[part];
+    }
+    return value;
+}
+/**
+ * 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;
+}
+
+/**
+ * Utility functions for platform detection
+ */
+/**
+ * Checks if code is running in a browser environment
+ */
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+isBrowser && window.self != window.top && window.location.href.includes('source=ActionCenter');
+const _params = isBrowser ? new URLSearchParams(window.location.search) : null;
+/**
+ * True when the coded app has been loaded inside a host frame that explicitly
+ * opted into token delegation by adding `?host=embed` to the iframe src URL.
+ */
+const isHostEmbedded = isBrowser && window.self !== window.top && _params?.get('host') === 'embed';
+/**
+ * The validated parent origin, read from the `?basedomain=` query param set
+ * by the embedding host in the iframe src URL.
+ * Mirrors the same mechanism used by ActionCenterTokenManager.
+ * Non-null only when `?host=embed` is present and `?basedomain=` is a valid URL.
+ */
+(() => {
+    if (!isHostEmbedded)
+        return null;
+    const basedomain = _params?.get('basedomain');
+    if (!basedomain)
+        return null;
+    try {
+        return new URL(basedomain).origin;
+    }
+    catch {
+        console.warn('embeddingOrigin: basedomain query param is not a valid URL', basedomain);
+        return null;
+    }
+})();
+
+/**
+ * Base64 encoding/decoding
+ */
+/**
+ * Encodes a string to base64
+ * @param str - The string to encode
+ * @returns Base64 encoded string
+ */
+function encodeBase64(str) {
+    // TextEncoder for UTF-8 encoding (works in both browser and Node.js)
+    const encoder = new TextEncoder();
+    const data = encoder.encode(str);
+    // Convert Uint8Array to base64
+    if (isBrowser) {
+        // Browser environment
+        // Convert Uint8Array to binary string then to base64
+        const binaryString = Array.from(data, byte => String.fromCharCode(byte)).join('');
+        return btoa(binaryString);
+    }
+    else {
+        // Node.js environment
+        return Buffer.from(data).toString('base64');
+    }
+}
+/**
+ * Decodes a base64 string
+ * @param base64 - The base64 string to decode
+ * @returns Decoded string
+ */
+function decodeBase64(base64) {
+    let bytes;
+    if (isBrowser) {
+        // Browser environment
+        const binaryString = atob(base64);
+        bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+    }
+    else {
+        // Node.js environment
+        bytes = new Uint8Array(Buffer.from(base64, 'base64'));
+    }
+    // TextDecoder for UTF-8 decoding (works in both browser and Node.js)
+    const decoder = new TextDecoder();
+    return decoder.decode(bytes);
+}
+
+/**
+ * PaginationManager handles the conversion between uniform cursor-based pagination
+ * and the specific pagination type for each service
+ */
+class PaginationManager {
+    /**
+     * Create a pagination cursor for subsequent page requests
+     */
+    static createCursor({ pageInfo, type }) {
+        if (!pageInfo.hasMore) {
+            return undefined;
+        }
+        const cursorData = {
+            type,
+            pageSize: pageInfo.pageSize,
+        };
+        switch (type) {
+            case PaginationType.OFFSET:
+                if (pageInfo.currentPage) {
+                    cursorData.pageNumber = pageInfo.currentPage + 1;
+                }
+                break;
+            case PaginationType.TOKEN:
+                if (pageInfo.continuationToken) {
+                    cursorData.continuationToken = pageInfo.continuationToken;
+                }
+                else {
+                    return undefined; // No continuation token, can't continue
+                }
+                break;
+        }
+        return {
+            value: encodeBase64(JSON.stringify(cursorData))
+        };
+    }
+    /**
+     * Create a paginated response with navigation cursors
+     */
+    static createPaginatedResponse({ pageInfo, type }, items) {
+        const nextCursor = PaginationManager.createCursor({ pageInfo, type });
+        // Create previous page cursor if applicable
+        let previousCursor = undefined;
+        if (pageInfo.currentPage && pageInfo.currentPage > 1) {
+            const prevCursorData = {
+                type,
+                pageNumber: pageInfo.currentPage - 1,
+                pageSize: pageInfo.pageSize,
+            };
+            previousCursor = {
+                value: encodeBase64(JSON.stringify(prevCursorData))
+            };
+        }
+        // Calculate total pages if we have totalCount and pageSize
+        let totalPages = undefined;
+        if (pageInfo.totalCount !== undefined && pageInfo.pageSize) {
+            totalPages = Math.ceil(pageInfo.totalCount / pageInfo.pageSize);
+        }
+        // Determine if this pagination type supports page jumping
+        const supportsPageJump = type === PaginationType.OFFSET;
+        // Create the result object with all fields, then filter out undefined values
+        const result = filterUndefined({
+            items,
+            totalCount: pageInfo.totalCount,
+            hasNextPage: pageInfo.hasMore,
+            nextCursor: nextCursor,
+            previousCursor: previousCursor,
+            currentPage: pageInfo.currentPage,
+            totalPages,
+            supportsPageJump
+        });
+        return result;
+    }
+}
+
+/**
+ * Common constants used across the SDK
+ */
+/**
+ * Prefix used for OData query parameters
+ */
+const ODATA_PREFIX = '$';
+/**
+ * HTTP methods
+ */
+const HTTP_METHODS = {
+    GET: 'GET',
+    POST: 'POST'};
+/**
+ * OData OFFSET pagination parameter names (ODATA-style)
+ */
+const ODATA_OFFSET_PARAMS = {
+    /** OData page size parameter name */
+    PAGE_SIZE_PARAM: '$top',
+    /** OData offset parameter name */
+    OFFSET_PARAM: '$skip',
+    /** OData count parameter name */
+    COUNT_PARAM: '$count'
+};
+/**
+ * Bucket TOKEN pagination parameter names
+ */
+const BUCKET_TOKEN_PARAMS = {
+    /** Bucket page size parameter name */
+    PAGE_SIZE_PARAM: 'takeHint',
+    /** Bucket token parameter name */
+    TOKEN_PARAM: 'continuationToken'
+};
+
+/**
+ * Converts a UTC timestamp string (e.g., "5/8/2026 11:20:17 AM") to ISO 8601 UTC format.
+ * Returns the original value if parsing fails.
+ */
+/**
+ * Adds a prefix to specified keys in an object, returning a new object.
+ * Only the provided keys are prefixed; all others are left unchanged.
+ *
+ * @param obj The source object
+ * @param prefix The prefix to add (e.g., '$')
+ * @param keys The keys to prefix (e.g., ['expand', 'filter'])
+ * @returns A new object with specified keys prefixed
+ *
+ * @example
+ * addPrefixToKeys({ expand: 'a', foo: 1 }, '$', ['expand']) // { $expand: 'a', foo: 1 }
+ */
+function addPrefixToKeys(obj, prefix, keys) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (keys.includes(key)) {
+            result[`${prefix}${key}`] = value;
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+/**
+ * Constants used throughout the pagination system
+ */
+/** Maximum number of items that can be requested in a single page */
+const MAX_PAGE_SIZE = 1000;
+/** Default page size when jumpToPage is used without specifying pageSize */
+const DEFAULT_PAGE_SIZE = 50;
+/** Default field name for items in a paginated response */
+const DEFAULT_ITEMS_FIELD = 'value';
+/** Default field name for total count in a paginated response */
+const DEFAULT_TOTAL_COUNT_FIELD = '@odata.count';
+/**
+ * Limits the page size to the maximum allowed value
+ * @param pageSize - Requested page size
+ * @returns Limited page size value
+ */
+function getLimitedPageSize(pageSize) {
+    if (pageSize === undefined || pageSize === null) {
+        return DEFAULT_PAGE_SIZE;
+    }
+    return Math.max(1, Math.min(pageSize, MAX_PAGE_SIZE));
+}
+
+/**
+ * Helper functions for pagination that can be used across services
+ */
+class PaginationHelpers {
+    /**
+     * Checks if any pagination parameters are provided
+     *
+     * @param options - The options object to check
+     * @returns True if any pagination parameter is defined, false otherwise
+     */
+    static hasPaginationParameters(options = {}) {
+        const { cursor, pageSize, jumpToPage } = options;
+        return cursor !== undefined || pageSize !== undefined || jumpToPage !== undefined;
+    }
+    /**
+     * Parse a pagination cursor string into cursor data
+     */
+    static parseCursor(cursorString) {
+        try {
+            const cursorData = JSON.parse(decodeBase64(cursorString));
+            return cursorData;
+        }
+        catch {
+            throw new Error('Invalid pagination cursor');
+        }
+    }
+    /**
+     * Validates cursor format and structure
+     *
+     * @param paginationOptions - The pagination options containing the cursor
+     * @param paginationType - Optional pagination type to validate against
+     */
+    static validateCursor(paginationOptions, paginationType) {
+        if (paginationOptions.cursor !== undefined) {
+            if (!paginationOptions.cursor || typeof paginationOptions.cursor.value !== 'string' || !paginationOptions.cursor.value) {
+                throw new Error('cursor must contain a valid cursor string');
+            }
+            try {
+                // Try to parse the cursor to validate it
+                const cursorData = PaginationHelpers.parseCursor(paginationOptions.cursor.value);
+                // If type is provided, validate cursor contains expected type information
+                if (paginationType) {
+                    if (!cursorData.type) {
+                        throw new Error('Invalid cursor: missing pagination type');
+                    }
+                    // Check pagination type compatibility
+                    if (cursorData.type !== paginationType) {
+                        throw new Error(`Pagination type mismatch: cursor is for ${cursorData.type} but service uses ${paginationType}`);
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    // If it's already our error with specific message, pass it through
+                    if (error.message.startsWith('Invalid cursor') ||
+                        error.message.startsWith('Pagination type mismatch')) {
+                        throw error;
+                    }
+                }
+                throw new Error('Invalid pagination cursor format');
+            }
+        }
+    }
+    /**
+     * Comprehensive validation for pagination options
+     *
+     * @param options - The pagination options to validate
+     * @param paginationType - The pagination type these options will be used with
+     * @returns Processed pagination parameters ready for use
+     */
+    static validatePaginationOptions(options, paginationType) {
+        // Validate pageSize
+        if (options.pageSize !== undefined && options.pageSize <= 0) {
+            throw new Error('pageSize must be a positive number');
+        }
+        // Validate jumpToPage
+        if (options.jumpToPage !== undefined && options.jumpToPage <= 0) {
+            throw new Error('jumpToPage must be a positive number');
+        }
+        // Validate cursor
+        PaginationHelpers.validateCursor(options, paginationType);
+        // Validate service compatibility
+        if (options.jumpToPage !== undefined && paginationType === PaginationType.TOKEN) {
+            throw new Error('jumpToPage is not supported for token-based pagination. Use cursor-based navigation instead.');
+        }
+        // Get processed parameters
+        return PaginationHelpers.getRequestParameters(options, paginationType);
+    }
+    /**
+     * Convert a unified pagination options to service-specific parameters
+     */
+    static getRequestParameters(options, paginationType) {
+        // Handle jumpToPage
+        if (options.jumpToPage !== undefined) {
+            const jumpToPageOptions = {
+                pageSize: options.pageSize,
+                pageNumber: options.jumpToPage
+            };
+            return filterUndefined(jumpToPageOptions);
+        }
+        // If no cursor is provided, it's a first page request
+        if (!options.cursor) {
+            const firstPageOptions = {
+                pageSize: options.pageSize,
+                // Only set pageNumber for OFFSET pagination
+                pageNumber: paginationType === PaginationType.OFFSET ? 1 : undefined
+            };
+            return filterUndefined(firstPageOptions);
+        }
+        // Parse the cursor
+        try {
+            const cursorData = PaginationHelpers.parseCursor(options.cursor.value);
+            const cursorBasedOptions = {
+                pageSize: cursorData.pageSize || options.pageSize,
+                pageNumber: cursorData.pageNumber,
+                continuationToken: cursorData.continuationToken,
+                type: cursorData.type,
+            };
+            return filterUndefined(cursorBasedOptions);
+        }
+        catch {
+            throw new Error('Invalid pagination cursor');
+        }
+    }
+    /**
+     * Helper method for paginated resource retrieval
+     *
+     * @param params - Parameters for pagination
+     * @returns Promise resolving to a paginated result
+     */
+    static async getAllPaginated(params) {
+        const { serviceAccess, getEndpoint, folderId, headers: providedHeaders, paginationParams, additionalParams, queryParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        const endpoint = getEndpoint(folderId);
+        const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
+        // On POST, the caller's options go in the body; queryParams stays in the URL.
+        // On GET, everything is URL — queryParams merges with additionalParams.
+        const isPost = method === HTTP_METHODS.POST;
+        const requestSpec = isPost
+            ? { body: additionalParams, params: queryParams }
+            : { params: { ...additionalParams, ...queryParams } };
+        const paginatedResponse = await serviceAccess.requestWithPagination(method, endpoint, paginationParams, {
+            headers,
+            ...requestSpec,
+            pagination: {
+                paginationType: options.paginationType || PaginationType.OFFSET,
+                itemsField: options.itemsField || DEFAULT_ITEMS_FIELD,
+                totalCountField: options.totalCountField || DEFAULT_TOTAL_COUNT_FIELD,
+                continuationTokenField: options.continuationTokenField,
+                paginationParams: options.paginationParams
+            }
+        });
+        // Parse items - automatically handle JSON string responses
+        const rawItems = paginatedResponse.items;
+        const parsedItems = typeof rawItems === 'string' ? JSON.parse(rawItems) : (rawItems || []);
+        const transformedItems = transformFn ? parsedItems.map(transformFn) : parsedItems;
+        return {
+            ...paginatedResponse,
+            items: transformedItems
+        };
+    }
+    /**
+     * Helper method for non-paginated resource retrieval
+     *
+     * @param params - Parameters for non-paginated resource retrieval
+     * @returns Promise resolving to an object with data and totalCount
+     */
+    static async getAllNonPaginated(params) {
+        const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, headers: providedHeaders, additionalParams, queryParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        // Set default field names
+        const itemsField = options.itemsField || DEFAULT_ITEMS_FIELD;
+        const totalCountField = options.totalCountField || DEFAULT_TOTAL_COUNT_FIELD;
+        // Determine endpoint and headers based on folderId
+        const endpoint = folderId ? getByFolderEndpoint : getAllEndpoint;
+        const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
+        // Make the API call based on method
+        let response;
+        if (method === HTTP_METHODS.POST) {
+            response = await serviceAccess.post(endpoint, additionalParams, { headers, params: queryParams });
+        }
+        else {
+            response = await serviceAccess.get(endpoint, {
+                params: { ...additionalParams, ...queryParams },
+                headers
+            });
+        }
+        // Extract and transform items from response
+        // Handle both plain array responses and envelope responses ({ value: [...], totalRecordCount: N }).
+        // itemsField may be a dotted path (e.g. 'data.agents') for nested envelopes.
+        const rawItems = Array.isArray(response.data) ? response.data : resolveNestedField(response.data, itemsField);
+        const rawTotalCount = Array.isArray(response.data) ? undefined : resolveNestedField(response.data, totalCountField);
+        const totalCount = typeof rawTotalCount === 'number' ? rawTotalCount : undefined;
+        // Parse items - automatically handle JSON string responses
+        const parsedItems = typeof rawItems === 'string' ? JSON.parse(rawItems) : (rawItems || []);
+        const items = transformFn ? parsedItems.map(transformFn) : parsedItems;
+        return {
+            items,
+            totalCount
+        };
+    }
+    /**
+     * Centralized getAll implementation that handles both paginated and non-paginated requests
+     *
+     * @param config - Configuration for the getAll operation
+     * @param options - Request options including pagination parameters
+     * @returns Promise resolving to either paginated or non-paginated response based on options
+     */
+    static async getAll(config, options) {
+        const optionsWithDefaults = options || {};
+        const { folderId, pageSize, cursor, jumpToPage, ...restOptions } = optionsWithDefaults;
+        // Determine if pagination is requested
+        const isPaginationRequested = PaginationHelpers.hasPaginationParameters(options || {});
+        // Process parameters (custom processing if provided, otherwise default)
+        let processedOptions = restOptions;
+        if (config.processParametersFn) {
+            processedOptions = config.processParametersFn(restOptions, folderId);
+        }
+        // Apply ODATA prefix to keys (excluding specified keys)
+        const excludeKeys = config.excludeFromPrefix || [];
+        const keysToPrefix = Object.keys(processedOptions).filter(k => !excludeKeys.includes(k));
+        const prefixedOptions = addPrefixToKeys(processedOptions, ODATA_PREFIX, keysToPrefix);
+        // Default pagination options
+        const paginationOptions = {
+            paginationType: PaginationType.OFFSET,
+            itemsField: DEFAULT_ITEMS_FIELD,
+            totalCountField: DEFAULT_TOTAL_COUNT_FIELD,
+            ...config.pagination
+        };
+        // Paginated flow
+        if (isPaginationRequested) {
+            return PaginationHelpers.getAllPaginated({
+                serviceAccess: config.serviceAccess,
+                getEndpoint: config.getEndpoint,
+                folderId,
+                headers: config.headers,
+                paginationParams: cursor ? { cursor, pageSize } : jumpToPage !== undefined ? { jumpToPage, pageSize } : { pageSize },
+                additionalParams: prefixedOptions,
+                queryParams: config.queryParams,
+                transformFn: config.transformFn,
+                method: config.method,
+                options: {
+                    ...paginationOptions,
+                    paginationParams: config.pagination?.paginationParams
+                }
+            }); // Type assertion needed due to conditional return
+        }
+        // Non-paginated flow
+        const byFolderEndpoint = config.getByFolderEndpoint || config.getEndpoint(folderId);
+        return PaginationHelpers.getAllNonPaginated({
+            serviceAccess: config.serviceAccess,
+            getAllEndpoint: config.getEndpoint(),
+            getByFolderEndpoint: byFolderEndpoint,
+            folderId,
+            headers: config.headers,
+            additionalParams: prefixedOptions,
+            queryParams: config.queryParams,
+            transformFn: config.transformFn,
+            method: config.method,
+            options: {
+                itemsField: paginationOptions.itemsField,
+                totalCountField: paginationOptions.totalCountField
+            }
+        });
+    }
+}
+
+/**
+ * SDK Internals Registry - Internal registry for SDK instances
+ *
+ * This class is NOT exported in the public API.
+ * It provides a secure way to share SDK internals between
+ * the UiPath class and service classes without exposing them publicly.
+ *
+ * @internal
+ */
+// Global symbol key to ensure WeakMap is shared across module instances
+// This prevents issues when core and service modules are bundled separately
+const REGISTRY_KEY = Symbol.for('@uipath/sdk-internals-registry');
+// Get or create the global WeakMap store
+const getGlobalStore = () => {
+    const globalObj = globalThis;
+    if (!globalObj[REGISTRY_KEY]) {
+        globalObj[REGISTRY_KEY] = new WeakMap();
+    }
+    return globalObj[REGISTRY_KEY];
+};
+/**
+ * Internal registry for SDK private components.
+ * Uses WeakMap to prevent memory leaks - entries are automatically
+ * garbage collected when the SDK instance is no longer referenced.
+ *
+ * Uses a global singleton pattern to ensure the same WeakMap is shared
+ * across separately bundled modules (core, entities, tasks, etc.).
+ *
+ * @internal - Not exported in public API
+ */
+class SDKInternalsRegistry {
+    // Use global store to ensure sharing across module bundles
+    static get store() {
+        return getGlobalStore();
+    }
+    /**
+     * Register SDK instance internals
+     * Called by UiPath constructor
+     */
+    static set(instance, internals) {
+        this.store.set(instance, internals);
+    }
+    /**
+     * Retrieve SDK instance internals
+     * Called by BaseService constructor
+     */
+    static get(instance) {
+        const internals = this.store.get(instance);
+        if (!internals) {
+            throw new Error('Invalid SDK instance. Make sure to pass a valid UiPath instance to the service constructor.');
+        }
+        return internals;
+    }
+}
+
+var _BaseService_apiClient;
+/**
+ * Base class for all UiPath SDK services.
+ *
+ * Provides common functionality for authentication, configuration, and API communication.
+ * All service classes extend this base to inherit dependency injection and HTTP client access.
+ *
+ * This class implements the dependency injection pattern where services receive a configured
+ * UiPath instance. The ApiClient is created internally and handles all HTTP operations
+ * including authentication token management.
+ *
+ * @remarks
+ * Service classes should extend this base and call `super(uiPath)` in their constructor.
+ * Protected HTTP methods (get, post, put, patch, delete) are available to all subclasses.
+ *
+ */
+class BaseService {
+    /**
+     * Creates a base service instance with dependency injection.
+     *
+     * Extracts configuration, execution context, and token manager from the UiPath instance
+     * to initialize an authenticated API client. The ApiClient handles all HTTP operations
+     * and token management internally.
+     *
+     * @param instance - UiPath SDK instance providing authentication and configuration.
+     *                    Services receive this via dependency injection in the modular pattern.
+     * @param headers - Optional default headers to include in every request (e.g. `x-uipath-external-user-id` for
+     *                  CAS external-app auth)
+     *
+     * @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, headers) {
+        // Private field - not visible via Object.keys() or any reflection
+        _BaseService_apiClient.set(this, void 0);
+        const { config, context, tokenManager, folderKey } = SDKInternalsRegistry.get(instance);
+        __classPrivateFieldSet(this, _BaseService_apiClient, new ApiClient(config, context, tokenManager, headers ? { headers } : {}), "f");
+        this.config = { folderKey };
+    }
+    /**
+     * Gets a valid authentication token, refreshing if necessary.
+     * Use this when you need to manually add Authorization headers (e.g., direct uploads).
+     *
+     * @returns Promise resolving to a valid access token string
+     * @throws AuthenticationError if no token is available or refresh fails
+     */
+    async getValidAuthToken() {
+        return __classPrivateFieldGet(this, _BaseService_apiClient, "f").getValidToken();
+    }
+    /**
+     * Creates a service accessor for pagination helpers
+     * This allows pagination helpers to access protected methods without making them public
+     */
+    createPaginationServiceAccess() {
+        return {
+            get: (path, options) => this.get(path, options || {}),
+            post: (path, body, options) => this.post(path, body, options || {}),
+            requestWithPagination: (method, path, paginationOptions, options) => this.requestWithPagination(method, path, paginationOptions, options)
+        };
+    }
+    async request(method, path, options = {}) {
+        switch (method.toUpperCase()) {
+            case 'GET':
+                return this.get(path, options);
+            case 'POST':
+                return this.post(path, options.body, options);
+            case 'PUT':
+                return this.put(path, options.body, options);
+            case 'PATCH':
+                return this.patch(path, options.body, options);
+            case 'DELETE':
+                return this.delete(path, options);
+            default:
+                throw new Error(`Unsupported HTTP method: ${method}`);
+        }
+    }
+    async requestWithSpec(spec) {
+        if (!spec.method || !spec.url) {
+            throw new Error('Request spec must include method and url');
+        }
+        return this.request(spec.method, spec.url, spec);
+    }
+    async get(path, options = {}) {
+        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").get(path, options);
+        return { data: response };
+    }
+    async post(path, data, options = {}) {
+        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").post(path, data, options);
+        return { data: response };
+    }
+    async put(path, data, options = {}) {
+        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").put(path, data, options);
+        return { data: response };
+    }
+    async patch(path, data, options = {}) {
+        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").patch(path, data, options);
+        return { data: response };
+    }
+    async delete(path, options = {}) {
+        const response = await __classPrivateFieldGet(this, _BaseService_apiClient, "f").delete(path, options);
+        return { data: response };
+    }
+    /**
+     * Execute a request with cursor-based pagination
+     */
+    async requestWithPagination(method, path, paginationOptions, options) {
+        const paginationType = options.pagination.paginationType;
+        // Validate and prepare pagination parameters
+        const params = this.validateAndPreparePaginationParams(paginationType, paginationOptions);
+        // Prepare request parameters based on pagination type
+        const requestParams = this.preparePaginationRequestParams(paginationType, params, options.pagination);
+        // Route pagination state to wherever the API expects it (body for POST, URL for GET).
+        // Caller-supplied options.body / options.params are respected as-is — the api-client
+        // already handles params (URL) and body (request body) independently for every method.
+        if (method.toUpperCase() === 'POST') {
+            const existingBody = (options.body && typeof options.body === 'object') ? options.body : {};
+            options.body = {
+                ...existingBody,
+                ...requestParams
+            };
+        }
+        else {
+            options.params = {
+                ...options.params,
+                ...requestParams
+            };
+        }
+        // Make the request
+        const response = await this.request(method, path, options);
+        // Extract data from the response and create page result
+        return this.createPaginatedResponseFromResponse(response, params, paginationType, {
+            itemsField: options.pagination.itemsField,
+            totalCountField: options.pagination.totalCountField,
+            continuationTokenField: options.pagination.continuationTokenField
+        });
+    }
+    /**
+     * Validates and prepares pagination parameters from options
+     */
+    validateAndPreparePaginationParams(paginationType, paginationOptions) {
+        return PaginationHelpers.validatePaginationOptions(paginationOptions, paginationType);
+    }
+    /**
+     * Prepares request parameters for pagination based on pagination type
+     */
+    preparePaginationRequestParams(paginationType, params, paginationConfig) {
+        const requestParams = {};
+        let limitedPageSize;
+        const paginationParams = paginationConfig?.paginationParams;
+        switch (paginationType) {
+            case PaginationType.OFFSET:
+                limitedPageSize = getLimitedPageSize(params.pageSize);
+                const pageSizeParam = paginationParams?.pageSizeParam || ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM;
+                const offsetParam = paginationParams?.offsetParam || ODATA_OFFSET_PARAMS.OFFSET_PARAM;
+                const countParam = paginationParams?.countParam || ODATA_OFFSET_PARAMS.COUNT_PARAM;
+                // When true (default), converts pageNumber to a skip/offset value (e.g., page 3 with pageSize 10 → skip 20).
+                // When false, passes pageNumber directly as the offset param — used by APIs that accept a page number instead of a record offset.
+                const convertToSkip = paginationParams?.convertToSkip ?? true;
+                // When true, sends pageNumber - 1 (for 0-based APIs). Default false (1-based).
+                const zeroBased = paginationParams?.zeroBased ?? false;
+                requestParams[pageSizeParam] = limitedPageSize;
+                if (convertToSkip) {
+                    if (params.pageNumber && params.pageNumber > 1) {
+                        requestParams[offsetParam] = (params.pageNumber - 1) * limitedPageSize;
+                    }
+                }
+                else {
+                    const sdkPageNumber = params.pageNumber || 1;
+                    requestParams[offsetParam] = zeroBased ? sdkPageNumber - 1 : sdkPageNumber;
+                }
+                {
+                    requestParams[countParam] = true;
+                }
+                break;
+            case PaginationType.TOKEN:
+                const tokenPageSizeParam = paginationParams?.pageSizeParam || BUCKET_TOKEN_PARAMS.PAGE_SIZE_PARAM;
+                const tokenParam = paginationParams?.tokenParam || BUCKET_TOKEN_PARAMS.TOKEN_PARAM;
+                if (params.pageSize) {
+                    requestParams[tokenPageSizeParam] = getLimitedPageSize(params.pageSize);
+                }
+                if (params.continuationToken) {
+                    requestParams[tokenParam] = params.continuationToken;
+                }
+                break;
+        }
+        return requestParams;
+    }
+    /**
+     * Creates a paginated response from API response
+     */
+    createPaginatedResponseFromResponse(response, params, paginationType, fields) {
+        // Extract fields from response
+        const itemsField = fields.itemsField ||
+            (paginationType === PaginationType.TOKEN ? 'items' : 'value');
+        const totalCountField = fields.totalCountField || 'totalRecordCount';
+        const continuationTokenField = fields.continuationTokenField || 'continuationToken';
+        // Extract items and metadata
+        // Handle both plain array responses and envelope responses ({ value: [...], totalRecordCount: N }).
+        // itemsField may be a dotted path (e.g. 'data.agents') for nested envelopes.
+        const items = Array.isArray(response.data) ? response.data : (resolveNestedField(response.data, itemsField) || []);
+        const rawTotalCount = Array.isArray(response.data) ? undefined : resolveNestedField(response.data, totalCountField);
+        const totalCount = typeof rawTotalCount === 'number' ? rawTotalCount : undefined;
+        const continuationToken = response.data[continuationTokenField];
+        // Determine if there are more pages
+        const hasMore = this.determineHasMorePages(paginationType, {
+            totalCount,
+            pageSize: params.pageSize,
+            currentPage: params.pageNumber || 1,
+            itemsCount: items.length,
+            continuationToken
+        });
+        // Create and return the page result
+        return PaginationManager.createPaginatedResponse({
+            pageInfo: {
+                hasMore,
+                totalCount,
+                currentPage: params.pageNumber,
+                pageSize: params.pageSize,
+                continuationToken
+            },
+            type: paginationType,
+        }, items);
+    }
+    /**
+     * Determines if there are more pages based on pagination type and metadata
+     */
+    determineHasMorePages(paginationType, info) {
+        switch (paginationType) {
+            case PaginationType.OFFSET:
+                const effectivePageSize = info.pageSize ?? DEFAULT_PAGE_SIZE;
+                // If totalCount is available, use it for precise calculation
+                if (info.totalCount !== undefined) {
+                    return (info.currentPage * effectivePageSize) < info.totalCount;
+                }
+                // Fallback when totalCount is not available
+                // NOTE: This code path should rarely be executed as the APIs typically return totalCount
+                return info.itemsCount === effectivePageSize;
+            case PaginationType.TOKEN:
+                return !!info.continuationToken;
+            default:
+                return false;
+        }
+    }
+}
+_BaseService_apiClient = new WeakMap();
+
+/**
+ * Service for the Orchestrator Document Understanding module.
+ */
+class OrchestratorDuModuleService extends BaseService {
+    /**
+     * Submits an exception report for a Document Understanding validation task.
+     *
+     * Records that the document under validation cannot be processed normally and captures
+     * a reason. The server echoes the submitted payload and signals acceptance via
+     * {@link SubmitExceptionReportResponse.IsSuccessful}.
+     *
+     * @param taskId - Identifier of the validation task the exception applies to.
+     * @param documentId - Identifier of the document the exception applies to.
+     * @param reason - Free-text reason the document is being reported as an exception.
+     * @returns Promise resolving to a {@link SubmitExceptionReportResponse} containing the echoed payload and success status.
+     *
+     * @example
+     * ```typescript
+     * import { Tasks, TaskType } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Fetch the Document Validation task to get its documentId
+     * const dvTask = await tasks.getById(<taskId>, { taskType: TaskType.DocumentValidation }, <folderId>);
+     * const documentId = dvTask.data?.documentId as string;
+     *
+     * // Submit an exception report for the validation task
+     * const result = await orchestratorDuModule.submitExceptionReport(<taskId>, documentId, '<reason>');
+     *
+     * if (result.IsSuccessful) {
+     *   console.log('Exception recorded for', result.SubmitResult?.DocumentId);
+     * }
+     * ```
+     * @internal
+     */
+    async submitExceptionReport(taskId, documentId, reason, options) {
+        const headers = resolveFolderHeaders({
+            folderId: options.folderId,
+            folderKey: options.folderKey,
+            folderPath: options.folderPath,
+            resourceType: 'orchestratorDuModule.submitExceptionReport',
+            fallbackFolderKey: this.config.folderKey,
+        });
+        const response = await this.post(ORCHESTRATOR_DU_MODULE_ENDPOINTS.SUBMIT_EXCEPTION_REPORT, { DocumentId: documentId, Reason: reason }, { params: { taskId }, headers });
+        return response.data;
+    }
+    /**
+     * Processes automatically extracted data against validator-edited data and a taxonomy.
+     *
+     * Sends the automatic extraction result, the validated extraction result, and the
+     * document taxonomy to the server, which merges and normalizes the inputs and returns
+     * the resulting {@link ExtractionResult}.
+     *
+     * @param request - Automatic and validated extraction results plus the document taxonomy.
+     * @returns Promise resolving to the merged {@link ExtractionResult}.
+     *
+     * @example
+     * ```typescript
+     * // Merge automatic and validator-edited extraction results against a taxonomy
+     * const result = await orchestratorDuModule.processExtractedData({
+     *   AutomaticExtractedResults: <automaticExtractionResult>,
+     *   ValidatedExtractedResults: <validatedData>,
+     *   Taxonomy: <taxonomy>,
+     * });
+     *
+     * console.log(result.DocumentId, result.ResultsDocument?.DocumentTypeName);
+     * ```
+     * @internal
+     */
+    async processExtractedData(request, options) {
+        const headers = resolveFolderHeaders({
+            folderId: options.folderId,
+            folderKey: options.folderKey,
+            folderPath: options.folderPath,
+            resourceType: 'orchestratorDuModule.processExtractedData',
+            fallbackFolderKey: this.config.folderKey,
+        });
+        const response = await this.post(ORCHESTRATOR_DU_MODULE_ENDPOINTS.PROCESS_EXTRACTED_DATA, request, { headers });
+        return response.data;
+    }
+}
+__decorate([
+    track('OrchestratorDuModule.SubmitExceptionReport')
+], OrchestratorDuModuleService.prototype, "submitExceptionReport", null);
+__decorate([
+    track('OrchestratorDuModule.ProcessExtractedData')
+], OrchestratorDuModuleService.prototype, "processExtractedData", null);
+
+exports.OrchestratorDuModule = OrchestratorDuModuleService;
+exports.OrchestratorDuModuleService = OrchestratorDuModuleService;