@uipath/uipath-typescript 1.0.0-beta.13 → 1.0.0-beta.14

package/dist/index.js

@@ -2092,8 +2092,11 @@ class TokenManager {
  * Maestro Process Service Endpoints
  */
 const MAESTRO_ENDPOINTS = {
+    BASE_PATH: 'pims_/api/v1',
     PROCESSES: {
-        GET_ALL: 'pims_/api/v1/processes/summary'},
+        GET_ALL: 'pims_/api/v1/processes/summary',
+        GET_SETTINGS: (processKey) => `pims_/api/v1/processes/${processKey}/settings`,
+    },
     INSTANCES: {
         GET_ALL: 'pims_/api/v1/instances',
         GET_BY_ID: (instanceId) => `pims_/api/v1/instances/${instanceId}`,
@@ -2104,6 +2107,10 @@ const MAESTRO_ENDPOINTS = {
         PAUSE: (instanceId) => `pims_/api/v1/instances/${instanceId}/pause`,
         RESUME: (instanceId) => `pims_/api/v1/instances/${instanceId}/resume`,
     },
+    CASES: {
+        GET_CASE_JSON: (instanceId) => `pims_/api/v1/cases/${instanceId}/case-json`,
+        GET_ELEMENT_EXECUTIONS: (instanceId) => `pims_/api/v1alpha1/element-executions/case-instances/${instanceId}`,
+    },
 };
 /**
  * Task Service (Action Center) Endpoints
@@ -2111,7 +2118,7 @@ const MAESTRO_ENDPOINTS = {
 const TASK_ENDPOINTS = {
     CREATE_GENERIC_TASK: '/tasks/GenericTasks/CreateTask',
     GET_TASK_USERS: (folderId) => `/odata/Tasks/UiPath.Server.Configuration.OData.GetTaskUsers(organizationUnitId=${folderId})`,
-    GET_TASKS_ACROSS_FOLDERS: '/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFolders',
+    GET_TASKS_ACROSS_FOLDERS: '/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFoldersForAdmin',
     GET_BY_ID: (id) => `/odata/Tasks(${id})`,
     ASSIGN_TASKS: '/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks',
     REASSIGN_TASKS: '/odata/Tasks/UiPath.Server.Configuration.OData.ReassignTasks',
@@ -2179,11 +2186,66 @@ const ASSET_ENDPOINTS = {
 
 class AuthService extends BaseService {
     constructor(config, executionContext) {
-        const isOAuth = hasOAuthConfig(config);
-        const tokenManager = new TokenManager(executionContext, config, isOAuth);
-        super(config, executionContext, tokenManager);
+        // Check if we should use stored OAuth context instead of provided config
+        const storedContext = AuthService.getStoredOAuthContext();
+        const effectiveConfig = storedContext ? AuthService._mergeConfigWithContext(config, storedContext) : config;
+        const isOAuth = hasOAuthConfig(effectiveConfig);
+        const tokenManager = new TokenManager(executionContext, effectiveConfig, isOAuth);
+        super(effectiveConfig, executionContext, tokenManager);
         this.tokenManager = tokenManager;
     }
+    /**
+     * Check if we're in an OAuth callback state
+     */
+    static isInOAuthCallback() {
+        if (!isBrowser)
+            return false;
+        const urlParams = new URLSearchParams(window.location.search);
+        const code = urlParams.get('code');
+        const hasCodeVerifier = sessionStorage.getItem('uipath_sdk_code_verifier');
+        return !!(code && hasCodeVerifier);
+    }
+    /**
+     * Get stored OAuth context
+     */
+    static getStoredOAuthContext() {
+        if (!isBrowser) {
+            return null;
+        }
+        try {
+            const stored = sessionStorage.getItem('uipath_sdk_oauth_context');
+            if (!stored) {
+                return null;
+            }
+            const context = JSON.parse(stored);
+            // Validate required fields
+            if (!context.codeVerifier || !context.clientId || !context.redirectUri ||
+                !context.baseUrl || !context.orgName) {
+                sessionStorage.removeItem('uipath_sdk_oauth_context');
+                return null;
+            }
+            return context;
+        }
+        catch (error) {
+            sessionStorage.removeItem('uipath_sdk_oauth_context');
+            console.warn('Failed to parse stored OAuth context from session storage', error);
+            return null;
+        }
+    }
+    /**
+     * Merges provided config with stored OAuth context, prioritizing stored values
+     */
+    static _mergeConfigWithContext(config, context) {
+        return {
+            ...config,
+            baseUrl: context.baseUrl,
+            orgName: context.orgName,
+            tenantName: context.tenantName,
+            clientId: context.clientId,
+            redirectUri: context.redirectUri,
+            scope: context.scope
+        };
+    }
     /**
      * Get the token manager instance
      */
@@ -2199,13 +2261,34 @@ class AuthService extends BaseService {
      * In an OAuth flow, this method will trigger a page redirect and the promise will not resolve.
      */
     async authenticate(config) {
-        // Try to load token from storage first (only works for OAuth tokens)
+        if (!isBrowser) {
+            return false;
+        }
+        // First priority: Complete OAuth callback if we detect it
+        if (AuthService.isInOAuthCallback()) {
+            const urlParams = new URLSearchParams(window.location.search);
+            const code = urlParams.get('code');
+            if (!code) {
+                throw new Error('Authorization code missing in OAuth callback');
+            }
+            // Check if token already exists (prevents duplicate processing)
+            if (this.tokenManager.hasValidToken()) {
+                return true;
+            }
+            // Ensure we have OAuth config for callback completion
+            if (!hasOAuthConfig(config)) {
+                throw new Error('OAuth configuration incomplete: clientId, redirectUri, and scope are required for OAuth callback');
+            }
+            const result = await this._authenticateWithOAuth(config.clientId, config.redirectUri, config.scope);
+            return result;
+        }
+        // Secondly: Try to load existing valid token from storage
         const loadedFromStorage = this.tokenManager.loadFromStorage();
         // If we have a valid token from storage, return true
         if (loadedFromStorage && this.tokenManager.hasValidToken()) {
             return true;
         }
-        // If we don't have a valid token from storage, authenticate with OAuth
+        // Start new OAuth flow if config has OAuth fields
         if (hasOAuthConfig(config)) {
             return await this._authenticateWithOAuth(config.clientId, config.redirectUri, config.scope);
         }
@@ -2388,6 +2471,17 @@ class AuthService extends BaseService {
     async _initiateOAuthFlow(clientId, redirectUri, scope) {
         const codeVerifier = this.generateCodeVerifier();
         const codeChallenge = await this.generateCodeChallenge(codeVerifier);
+        // Store complete OAuth context for callback completion
+        const oauthContext = {
+            codeVerifier,
+            clientId,
+            redirectUri,
+            baseUrl: this.config.baseUrl,
+            orgName: this.config.orgName,
+            tenantName: this.config.tenantName,
+            scope
+        };
+        sessionStorage.setItem('uipath_sdk_oauth_context', JSON.stringify(oauthContext));
         sessionStorage.setItem('uipath_sdk_code_verifier', codeVerifier);
         const authUrl = this.getAuthorizationUrl({
             clientId,
@@ -2402,13 +2496,15 @@ class AuthService extends BaseService {
         if (!codeVerifier) {
             throw new Error('Code verifier not found in session storage. Authentication may have been interrupted.');
         }
-        sessionStorage.removeItem('uipath_sdk_code_verifier');
         await this._getAccessToken({
             clientId,
             redirectUri,
             code,
             codeVerifier
         });
+        // Clear OAuth context and code verifier after successful token exchange
+        sessionStorage.removeItem('uipath_sdk_oauth_context');
+        sessionStorage.removeItem('uipath_sdk_code_verifier');
         const url = new URL(window.location.href);
         url.searchParams.delete('code');
         url.searchParams.delete('state');
@@ -2637,7 +2733,7 @@ const EntityFieldTypeMap = {
 // Connection string placeholder that will be replaced during build
 const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
 // SDK Version placeholder 
-const SDK_VERSION = "1.0.0-beta.13";
+const SDK_VERSION = "1.0.0-beta.14";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -3301,6 +3397,94 @@ function createProcessInstanceWithMethods(instanceData, service) {
     return Object.assign({}, instanceData, methods);
 }
 
+/**
+ * Case Instance Types
+ * Types and interfaces for Maestro case instance management
+ */
+/**
+ * Case stage task type
+ */
+exports.StageTaskType = void 0;
+(function (StageTaskType) {
+    StageTaskType["EXTERNAL_AGENT"] = "external-agent";
+    StageTaskType["RPA"] = "rpa";
+    StageTaskType["AGENTIC_PROCESS"] = "process";
+    StageTaskType["AGENT"] = "agent";
+    StageTaskType["ACTION"] = "action";
+    StageTaskType["API_WORKFLOW"] = "api-workflow";
+})(exports.StageTaskType || (exports.StageTaskType = {}));
+/**
+ * Escalation recipient scope
+ */
+exports.EscalationRecipientScope = void 0;
+(function (EscalationRecipientScope) {
+    EscalationRecipientScope["USER"] = "user";
+    EscalationRecipientScope["USER_GROUP"] = "usergroup";
+})(exports.EscalationRecipientScope || (exports.EscalationRecipientScope = {}));
+/**
+ * Escalation action type
+ */
+exports.EscalationActionType = void 0;
+(function (EscalationActionType) {
+    EscalationActionType["NOTIFICATION"] = "notification";
+})(exports.EscalationActionType || (exports.EscalationActionType = {}));
+/**
+ * Escalation rule trigger type
+ */
+exports.EscalationTriggerType = void 0;
+(function (EscalationTriggerType) {
+    EscalationTriggerType["SLA_BREACHED"] = "sla-breached";
+    EscalationTriggerType["AT_RISK"] = "at-risk";
+})(exports.EscalationTriggerType || (exports.EscalationTriggerType = {}));
+/**
+ * SLA duration unit
+ */
+exports.SLADurationUnit = void 0;
+(function (SLADurationUnit) {
+    SLADurationUnit["HOURS"] = "h";
+    SLADurationUnit["DAYS"] = "d";
+    SLADurationUnit["WEEKS"] = "w";
+    SLADurationUnit["MONTHS"] = "m";
+})(exports.SLADurationUnit || (exports.SLADurationUnit = {}));
+
+/**
+ * Creates methods for a case instance
+ *
+ * @param instanceData - The case instance data (response from API)
+ * @param service - The case instance service instance
+ * @returns Object containing case instance methods
+ */
+function createCaseInstanceMethods(instanceData, service) {
+    return {
+        async close(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            return service.close(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async pause(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            return service.pause(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async resume(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            return service.resume(instanceData.instanceId, instanceData.folderKey, options);
+        }
+    };
+}
+/**
+ * Creates an actionable case instance by combining API case instance data with operational methods.
+ *
+ * @param instanceData - The case instance data from API
+ * @param service - The case instance service instance
+ * @returns A case instance object with added methods
+ */
+function createCaseInstanceWithMethods(instanceData, service) {
+    const methods = createCaseInstanceMethods(instanceData, service);
+    return Object.assign({}, instanceData, methods);
+}
+
 /**
  * Maps fields for Process Instance entities to ensure consistent naming
  */
@@ -3610,48 +3794,21 @@ __decorate([
 ], ProcessInstancesService.prototype, "getVariables", null);
 
 /**
- * Base service for services that need folder-specific functionality
+ * Internal types for Maestro Cases
+ * These types are used internally by the cases service
  */
-class FolderScopedService extends BaseService {
-    constructor(config, executionContext, tokenManager) {
-        super(config, executionContext, tokenManager);
-    }
-    /**
-     * Gets resources in a folder with optional query parameters
-     *
-     * @param endpoint - API endpoint to call
-     * @param folderId - required folder ID
-     * @param options - Query options
-     * @param transformFn - Optional function to transform the response data
-     * @returns Promise resolving to an array of resources
-     */
-    async _getByFolder(endpoint, folderId, options = {}, transformFn) {
-        const headers = createHeaders({ [FOLDER_ID]: folderId });
-        const keysToPrefix = Object.keys(options);
-        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
-        const response = await this.get(endpoint, {
-            params: apiOptions,
-            headers
-        });
-        if (transformFn) {
-            return response.data?.value.map(transformFn);
-        }
-        return response.data?.value;
-    }
-}
-
 /**
- * Maps fields for Asset entities to ensure consistent naming
+ * Process type enum for filtering
  */
-const AssetMap = {
-    creationTime: 'createdTime',
-    lastModificationTime: 'lastModifiedTime'
-};
+var ProcessType;
+(function (ProcessType) {
+    ProcessType["CaseManagement"] = "CaseManagement";
+})(ProcessType || (ProcessType = {}));
 
 /**
- * Service for interacting with UiPath Orchestrator Assets API
+ * Service for interacting with UiPath Maestro Cases
  */
-class AssetService extends FolderScopedService {
+class CasesService extends BaseService {
     /**
      * @hideconstructor
      */
@@ -3659,195 +3816,346 @@ class AssetService extends FolderScopedService {
         super(config, executionContext, tokenManager);
     }
     /**
-     * Gets all assets across folders with optional filtering and folder scoping
-     *
-     * @signature getAll(options?) -> Promise<AssetGetResponse[]>
-     * @param options Query options including optional folderId and pagination options
-     * @returns Promise resolving to array of assets or paginated response
+     * Get all case management processes with their instance statistics
+     * @returns Promise resolving to array of Case objects
      *
      * @example
      * ```typescript
-     * // Standard array return
-     * const assets = await sdk.assets.getAll();
-     *
-     * // With folder
-     * const folderAssets = await sdk.assets.getAll({ folderId: 123 });
-     *
-     * // First page with pagination
-     * const page1 = await sdk.assets.getAll({ pageSize: 10 });
+     * // Get all case management processes
+     * const cases = await sdk.maestro.cases.getAll();
      *
-     * // Navigate using cursor
-     * if (page1.hasNextPage) {
-     *   const page2 = await sdk.assets.getAll({ cursor: page1.nextCursor });
+     * // Access case information
+     * for (const caseProcess of cases) {
+     *   console.log(`Case Process: ${caseProcess.processKey}`);
+     *   console.log(`Running instances: ${caseProcess.runningCount}`);
+     *   console.log(`Completed instances: ${caseProcess.completedCount}`);
      * }
      *
-     * // Jump to specific page
-     * const page5 = await sdk.assets.getAll({
-     *   jumpToPage: 5,
-     *   pageSize: 10
-     * });
      * ```
      */
-    async getAll(options) {
-        // Transformation function for assets
-        const transformAssetResponse = (asset) => transformData(pascalToCamelCaseKeys(asset), AssetMap);
-        return PaginationHelpers.getAll({
-            serviceAccess: this.createPaginationServiceAccess(),
-            getEndpoint: (folderId) => folderId ? ASSET_ENDPOINTS.GET_BY_FOLDER : ASSET_ENDPOINTS.GET_ALL,
-            getByFolderEndpoint: ASSET_ENDPOINTS.GET_BY_FOLDER,
-            transformFn: transformAssetResponse,
-            pagination: {
-                paginationType: PaginationType.OFFSET,
-                itemsField: ODATA_PAGINATION.ITEMS_FIELD,
-                totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
-                paginationParams: {
-                    pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
-                    offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
-                    countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
-                }
-            }
-        }, options);
+    async getAll() {
+        const params = createParams({
+            processType: ProcessType.CaseManagement
+        });
+        const response = await this.get(MAESTRO_ENDPOINTS.PROCESSES.GET_ALL, { params });
+        // Extract processes array from response data and add name field
+        const cases = response.data?.processes || [];
+        return cases.map(caseItem => ({
+            ...caseItem,
+            name: this.extractCaseName(caseItem.packageId)
+        }));
     }
     /**
-     * Gets a single asset by ID
-     *
-     * @param id - Asset ID
-     * @param folderId - Required folder ID
-     * @param options - Optional query parameters (expand, select)
-     * @returns Promise resolving to a single asset
-     *
-     * @example
-     * ```typescript
-     * // Get asset by ID
-     * const asset = await sdk.assets.getById(123, 456);
-     * ```
+     * Extract a readable case name from the packageId
+     * @param packageId - The full package identifier
+     * @returns A human-readable case name
+     * @private
      */
-    async getById(id, folderId, options = {}) {
-        const headers = createHeaders({ [FOLDER_ID]: folderId });
-        const keysToPrefix = Object.keys(options);
-        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
-        const response = await this.get(ASSET_ENDPOINTS.GET_BY_ID(id), {
-            headers,
-            params: apiOptions
-        });
-        const transformedAsset = transformData(pascalToCamelCaseKeys(response.data), AssetMap);
-        return transformedAsset;
+    extractCaseName(packageId) {
+        // Check if packageId contains "CaseManagement."
+        const caseManagementIndex = packageId.indexOf('CaseManagement.');
+        if (caseManagementIndex !== -1) {
+            // Extract everything after "CaseManagement."
+            const afterCaseManagement = packageId.substring(caseManagementIndex + 'CaseManagement.'.length);
+            // Replace hyphens with spaces for better readability
+            return afterCaseManagement.replace(/-/g, ' ');
+        }
+        // If no "CaseManagement.", return the whole packageId
+        return packageId;
     }
 }
 __decorate([
-    track('Assets.GetAll')
-], AssetService.prototype, "getAll", null);
-__decorate([
-    track('Assets.GetById')
-], AssetService.prototype, "getById", null);
+    track('Cases.GetAll')
+], CasesService.prototype, "getAll", null);
 
 /**
- * Maps fields for Bucket entities to ensure consistent naming
+ * Maps fields for Case Instance entities to ensure consistent naming
  */
-const BucketMap = {
-    fullPath: 'path',
-    items: 'blobItems',
-    verb: 'httpMethod'
+const CaseInstanceMap = {
+    startedTimeUtc: 'startedTime',
+    completedTimeUtc: 'completedTime',
+    expiryTimeUtc: 'expiredTime',
+    createdAt: 'createdTime',
+    updatedAt: 'updatedTime',
+    externalId: 'caseId',
+};
+/**
+ * Maps fields for Case App Config
+ */
+const CaseAppConfigMap = {
+    sections: 'overview',
+};
+/**
+ * Maps fields for Stage SLA configuration
+ */
+const StageSLAMap = {
+    count: 'length',
+    unit: 'duration',
+};
+/**
+ * Maps UTC time fields to simpler field names
+ * Used for transforming execution history responses
+ */
+const TimeFieldTransformMap = {
+    startedTimeUtc: 'startedTime',
+    completedTimeUtc: 'completedTime',
+};
+/**
+ * Constants for case instance stage processing
+ */
+const CASE_STAGE_CONSTANTS = {
+    TRIGGER_NODE_TYPE: 'case-management:Trigger',
+    UNDEFINED_VALUE: 'Undefined',
+    NOT_STARTED_STATUS: 'Not Started'
 };
+/**
+ * Function to generate case instance task filter by case instance ID
+ */
+const CASE_INSTANCE_TASK_FILTER = (caseInstanceId) => `Tags/any(tags:tags/DisplayName eq '${caseInstanceId}') and (IsDeleted eq false)`;
+/**
+ * Default expand parameters for case instance tasks
+ */
+const CASE_INSTANCE_TASK_EXPAND = 'AssignedToUser,Activities';
 
-// Import file-type dynamically to avoid issues in browser environment
-// This variable will hold the fileTypeFromBuffer function when in Node.js environment
-let fileTypeFromBuffer;
-// Only import in Node.js environment
-if (!isBrowser) {
-    import('file-type').then(module => {
-        fileTypeFromBuffer = module.fileTypeFromBuffer;
-    }).catch(err => {
-        console.debug('Could not load file-type module:', err);
-    });
-}
-class BucketService extends FolderScopedService {
-    /**
-     * @hideconstructor
-     */
-    constructor(config, executionContext, tokenManager) {
-        super(config, executionContext, tokenManager);
-        this.tokenManager = tokenManager;
-    }
-    /**
-     * Gets a bucket by ID
-     * @param bucketId - The ID of the bucket to retrieve
-     * @param folderId - Folder ID for organization unit context
-     * @param options - Optional query parameters (expand, select)
-     * @returns Promise resolving to the bucket
-     *
-     * @example
-     * ```typescript
-     * // Get bucket by ID
-     * const bucket = await sdk.buckets.getById(123, 456);
-     * ```
-     */
-    async getById(id, folderId, options = {}) {
-        if (!id) {
-            throw new ValidationError({ message: 'bucketId is required for getById' });
-        }
-        if (!folderId) {
-            throw new ValidationError({ message: 'folderId is required for getById' });
-        }
-        const headers = createHeaders({ [FOLDER_ID]: folderId });
-        // Prefix all keys in options with $ for OData
-        const keysToPrefix = Object.keys(options);
-        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
-        const response = await this.get(BUCKET_ENDPOINTS.GET_BY_ID(id), {
-            params: apiOptions,
-            headers
-        });
-        // Transform response from PascalCase to camelCase
-        return pascalToCamelCaseKeys(response.data);
+exports.TaskType = void 0;
+(function (TaskType) {
+    TaskType["Form"] = "FormTask";
+    TaskType["External"] = "ExternalTask";
+    TaskType["App"] = "AppTask";
+})(exports.TaskType || (exports.TaskType = {}));
+exports.TaskPriority = void 0;
+(function (TaskPriority) {
+    TaskPriority["Low"] = "Low";
+    TaskPriority["Medium"] = "Medium";
+    TaskPriority["High"] = "High";
+    TaskPriority["Critical"] = "Critical";
+})(exports.TaskPriority || (exports.TaskPriority = {}));
+exports.TaskStatus = void 0;
+(function (TaskStatus) {
+    TaskStatus["Unassigned"] = "Unassigned";
+    TaskStatus["Pending"] = "Pending";
+    TaskStatus["Completed"] = "Completed";
+})(exports.TaskStatus || (exports.TaskStatus = {}));
+exports.TaskSlaCriteria = void 0;
+(function (TaskSlaCriteria) {
+    TaskSlaCriteria["TaskCreated"] = "TaskCreated";
+    TaskSlaCriteria["TaskAssigned"] = "TaskAssigned";
+    TaskSlaCriteria["TaskCompleted"] = "TaskCompleted";
+})(exports.TaskSlaCriteria || (exports.TaskSlaCriteria = {}));
+exports.TaskSlaStatus = void 0;
+(function (TaskSlaStatus) {
+    TaskSlaStatus["OverdueLater"] = "OverdueLater";
+    TaskSlaStatus["OverdueSoon"] = "OverdueSoon";
+    TaskSlaStatus["Overdue"] = "Overdue";
+    TaskSlaStatus["CompletedInTime"] = "CompletedInTime";
+})(exports.TaskSlaStatus || (exports.TaskSlaStatus = {}));
+exports.TaskSourceName = void 0;
+(function (TaskSourceName) {
+    TaskSourceName["Agent"] = "Agent";
+    TaskSourceName["Workflow"] = "Workflow";
+    TaskSourceName["Maestro"] = "Maestro";
+    TaskSourceName["Default"] = "Default";
+})(exports.TaskSourceName || (exports.TaskSourceName = {}));
+/**
+ * Task activity types
+ */
+exports.TaskActivityType = void 0;
+(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";
+})(exports.TaskActivityType || (exports.TaskActivityType = {}));
+
+/**
+ * Creates methods for a task
+ *
+ * @param taskData - The task data (response from API)
+ * @param service - The task service instance
+ * @returns Object containing task methods
+ */
+function createTaskMethods(taskData, service) {
+    return {
+        async assign(options) {
+            if (!taskData.id)
+                throw new Error('Task ID is undefined');
+            const assignmentOptions = {
+                taskId: taskData.id,
+                userId: options.userId || 0, // Will be handled by userNameOrEmail if userId is not provided, 0 is considered as invalid user id
+                userNameOrEmail: options.userNameOrEmail
+            };
+            return service.assign(assignmentOptions, taskData.organizationUnitId);
+        },
+        async reassign(options) {
+            if (!taskData.id)
+                throw new Error('Task ID is undefined');
+            const assignmentOptions = {
+                taskId: taskData.id,
+                userId: options.userId || 0, // Will be handled by userNameOrEmail if userId is not provided, 0 is considered as invalid user id
+                userNameOrEmail: options.userNameOrEmail
+            };
+            return service.reassign(assignmentOptions, taskData.organizationUnitId);
+        },
+        async unassign() {
+            if (!taskData.id)
+                throw new Error('Task ID is undefined');
+            return service.unassign(taskData.id, taskData.organizationUnitId);
+        },
+        async complete(options) {
+            if (!taskData.id)
+                throw new Error('Task ID is undefined');
+            const folderId = taskData.organizationUnitId;
+            if (!folderId)
+                throw new Error('Folder ID is required');
+            return service.complete(options.type, {
+                taskId: taskData.id,
+                data: options.data,
+                action: options.action
+            }, folderId);
+        }
+    };
+}
+/**
+ * Creates an actionable task by combining API task data with operational methods.
+ *
+ * @param taskData - The task data from API
+ * @param service - The task service instance
+ * @returns A task object with added methods
+ */
+function createTaskWithMethods(taskData, service) {
+    const methods = createTaskMethods(taskData, service);
+    return Object.assign({}, taskData, methods);
+}
+
+/**
+ * Maps numeric TaskStatus values (from API) to TaskStatus enum values.
+ * Extend this file with additional field mappings as needed.
+ */
+const TaskStatusMap = {
+    0: exports.TaskStatus.Unassigned,
+    1: exports.TaskStatus.Pending,
+    2: exports.TaskStatus.Completed,
+};
+// Field mapping for time-related fields to ensure consistent naming
+const TaskMap = {
+    completionTime: 'completedTime',
+    deletionTime: 'deletedTime',
+    lastModificationTime: 'lastModifiedTime',
+    creationTime: 'createdTime',
+    organizationUnitId: 'folderId'
+};
+
+/**
+ * Service for interacting with UiPath Tasks API
+ */
+class TaskService extends BaseService {
+    /**
+     * @hideconstructor
+     */
+    constructor(config, executionContext, tokenManager) {
+        super(config, executionContext, tokenManager);
+        /**
+         * Process parameters for task queries with folder filtering
+         * @param options - The REST API options to process
+         * @param folderId - Optional folder ID to filter by
+         * @returns Processed options with folder filtering applied if needed
+         * @private
+         */
+        this.processTaskParameters = (options, folderId) => {
+            const processedOptions = { ...options };
+            if (folderId) {
+                // Create or add to existing filter for folder-specific queries
+                if (processedOptions.filter) {
+                    processedOptions.filter = `${processedOptions.filter} and organizationUnitId eq ${folderId}`;
+                }
+                else {
+                    processedOptions.filter = `organizationUnitId eq ${folderId}`;
+                }
+            }
+            return processedOptions;
+        };
     }
     /**
-     * Gets all buckets across folders with optional filtering and folder scoping
+     * Creates a new task
+     * @param task - The task to be created
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to the created task
+     *
+     * @example
+     * ```typescript
+     * const task = await sdk.tasks.create({
+     *   title: "My Task",
+     *   priority: TaskPriority.Medium,
+     *   data: { key: "value" }
+     * }, 123); // folderId is required
+     * ```
+     */
+    async create(task, folderId) {
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        const externalTask = {
+            ...task,
+            type: exports.TaskType.External //currently only external task is supported
+        };
+        const response = await this.post(TASK_ENDPOINTS.CREATE_GENERIC_TASK, externalTask, { headers });
+        // Transform time fields for consistency
+        const normalizedData = transformData(response.data, TaskMap);
+        const transformedData = applyDataTransforms(normalizedData, { field: 'status', valueMap: TaskStatusMap });
+        return createTaskWithMethods(transformedData, this);
+    }
+    /**
+     * Gets users in the given folder who have Tasks.View and Tasks.Edit permissions
      *
      * The method returns either:
-     * - An array of buckets (when no pagination parameters are provided)
+     * - An array of users (when no pagination parameters are provided)
      * - A paginated result with navigation cursors (when any pagination parameter is provided)
      *
-     * @param options - Query options including optional folderId
-     * @returns Promise resolving to an array of buckets or paginated result
+     * @param folderId - The folder ID to get users from
+     * @param options - Optional query and pagination parameters
+     * @returns Promise resolving to an array of users or paginated result
      *
      * @example
      * ```typescript
-     * // Get all buckets across folders
-     * const buckets = await sdk.buckets.getAll();
-     *
-     * // Get buckets within a specific folder
-     * const buckets = await sdk.buckets.getAll({
-     *   folderId: 123
-     * });
+     * // Standard array return
+     * const users = await sdk.tasks.getUsers(123);
      *
-     * // Get buckets with filtering
-     * const buckets = await sdk.buckets.getAll({
-     *   filter: "name eq 'MyBucket'"
+     * // Get users with filtering
+     * const users = await sdk.tasks.getUsers(123, {
+     *   filter: "name eq 'abc'"
      * });
      *
      * // First page with pagination
-     * const page1 = await sdk.buckets.getAll({ pageSize: 10 });
+     * const page1 = await sdk.tasks.getUsers(123, { pageSize: 10 });
      *
      * // Navigate using cursor
      * if (page1.hasNextPage) {
-     *   const page2 = await sdk.buckets.getAll({ cursor: page1.nextCursor });
+     *   const page2 = await sdk.tasks.getUsers(123, { cursor: page1.nextCursor });
      * }
      *
      * // Jump to specific page
-     * const page5 = await sdk.buckets.getAll({
+     * const page5 = await sdk.tasks.getUsers(123, {
      *   jumpToPage: 5,
      *   pageSize: 10
      * });
      * ```
      */
-    async getAll(options) {
-        // Transformation function for buckets
-        const transformBucketResponse = (bucket) => pascalToCamelCaseKeys(bucket);
+    async getUsers(folderId, options) {
+        // Transformation function for users
+        const transformUserResponse = (user) => pascalToCamelCaseKeys(user);
+        // Add folderId to options so the centralized helper can handle it properly
+        const optionsWithFolder = { ...options, folderId };
         return PaginationHelpers.getAll({
             serviceAccess: this.createPaginationServiceAccess(),
-            getEndpoint: (folderId) => folderId ? BUCKET_ENDPOINTS.GET_BY_FOLDER : BUCKET_ENDPOINTS.GET_ALL,
-            getByFolderEndpoint: BUCKET_ENDPOINTS.GET_BY_FOLDER,
-            transformFn: transformBucketResponse,
+            getEndpoint: (folderId) => TASK_ENDPOINTS.GET_TASK_USERS(folderId), // Use folderId from centralized helper
+            getByFolderEndpoint: TASK_ENDPOINTS.GET_TASK_USERS(folderId), // Use the passed folderId
+            transformFn: transformUserResponse,
             pagination: {
                 paginationType: PaginationType.OFFSET,
                 itemsField: ODATA_PAGINATION.ITEMS_FIELD,
@@ -3858,498 +4166,788 @@ class BucketService extends FolderScopedService {
                     countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
                 }
             }
-        }, options);
+        }, optionsWithFolder);
     }
     /**
-     * Gets metadata for files in a bucket with optional filtering and pagination
+     * Gets tasks across folders with optional filtering and folder scoping
      *
      * The method returns either:
-     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
-     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     * - An array of tasks (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (when any pagination parameter is provided)
      *
-     * @param bucketId - The ID of the bucket to get file metadata from
-     * @param folderId - Required folder ID for organization unit context
-     * @param options - Optional parameters for filtering, pagination and access URL generation
-     * @returns Promise resolving to the list of file metadata in the bucket or paginated result
+     * @param options - Query options including optional folderId and pagination options
+     * @returns Promise resolving to an array of tasks or paginated result
      *
      * @example
      * ```typescript
-     * // Get metadata for all files in a bucket
-     * const fileMetadata = await sdk.buckets.getFileMetaData(123, 456);
+     * // Standard array return
+     * const tasks = await sdk.tasks.getAll();
      *
-     * // Get file metadata with a specific prefix
-     * const fileMetadata = await sdk.buckets.getFileMetaData(123, 456, {
-     *   prefix: '/folder1'
+     * // Get tasks within a specific folder
+     * const tasks = await sdk.tasks.getAll({
+     *   folderId: 123
      * });
      *
      * // First page with pagination
-     * const page1 = await sdk.buckets.getFileMetaData(123, 456, { pageSize: 10 });
+     * const page1 = await sdk.tasks.getAll({ pageSize: 10 });
      *
      * // Navigate using cursor
      * if (page1.hasNextPage) {
-     *   const page2 = await sdk.buckets.getFileMetaData(123, 456, { cursor: page1.nextCursor });
+     *   const page2 = await sdk.tasks.getAll({ cursor: page1.nextCursor });
      * }
-     * ```
-     */
-    async getFileMetaData(bucketId, folderId, options) {
-        if (!bucketId) {
-            throw new ValidationError({ message: 'bucketId is required for getFileMetaData' });
-        }
-        if (!folderId) {
-            throw new ValidationError({ message: 'folderId is required for getFileMetaData' });
-        }
-        // Transformation function for blob items
-        const transformBlobItem = (item) => transformData(item, BucketMap);
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.tasks.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    async getAll(options) {
+        // Transformation function for tasks
+        const transformTaskResponse = (task) => {
+            const transformedTask = transformData(pascalToCamelCaseKeys(task), TaskMap);
+            return createTaskWithMethods(applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }), this);
+        };
         return PaginationHelpers.getAll({
             serviceAccess: this.createPaginationServiceAccess(),
-            getEndpoint: () => BUCKET_ENDPOINTS.GET_FILE_META_DATA(bucketId),
-            transformFn: transformBlobItem,
+            getEndpoint: () => TASK_ENDPOINTS.GET_TASKS_ACROSS_FOLDERS,
+            transformFn: transformTaskResponse,
+            processParametersFn: this.processTaskParameters,
+            excludeFromPrefix: ['event'], // Exclude 'event' key from ODATA prefix transformation
             pagination: {
-                paginationType: PaginationType.TOKEN,
-                itemsField: BUCKET_PAGINATION.ITEMS_FIELD,
-                continuationTokenField: BUCKET_PAGINATION.CONTINUATION_TOKEN_FIELD,
+                paginationType: PaginationType.OFFSET,
+                itemsField: ODATA_PAGINATION.ITEMS_FIELD,
+                totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
                 paginationParams: {
-                    pageSizeParam: BUCKET_TOKEN_PARAMS.PAGE_SIZE_PARAM,
-                    tokenParam: BUCKET_TOKEN_PARAMS.TOKEN_PARAM
+                    pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM, // OData OFFSET parameter
+                    offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM, // OData OFFSET parameter
+                    countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM // OData OFFSET parameter
                 }
-            },
-            excludeFromPrefix: ['prefix'] // Bucket-specific param, not OData
-        }, { ...options, folderId });
+            }
+        }, options);
     }
     /**
-     * Uploads a file to a bucket
+     * Gets a task by ID
      *
-     * @param options - Options for file upload including bucket ID, folder ID, path, content, and optional parameters
-     * @returns Promise resolving to a response with success status and HTTP status code
+     * @param id - The ID of the task to retrieve
+     * @param options - Optional query parameters
+     * @param folderId - Optional folder ID
+     * @returns Promise resolving to the task (form tasks will return form-specific data)
      *
      * @example
      * ```typescript
-     * // Upload a file from browser
-     * const file = new File(['file content'], 'example.txt');
-     * const result = await sdk.buckets.uploadFile({
-     *   bucketId: 123,
-     *   folderId: 456,
-     *   path: '/folder/example.txt',
-     *   content: file
-     * });
+     * // Get task by ID
+     * const task = await sdk.tasks.getById(123);
      *
-     * // In Node env with explicit content type
-     * const buffer = Buffer.from('file content');
-     * const result = await sdk.buckets.uploadFile({
-     *   bucketId: 123,
-     *   folderId: 456,
-     *   path: '/folder/example.txt',
-     *   content: buffer,
-     *   contentType: 'text/plain'
-     * });
+     * // If the task is a form task, it will automatically return form-specific data
      * ```
      */
-    async uploadFile(options) {
-        const { bucketId, folderId, path, content, contentType } = options;
-        if (!bucketId) {
-            throw new ValidationError({ message: 'bucketId is required for uploadFile' });
-        }
-        if (!folderId) {
-            throw new ValidationError({ message: 'folderId is required for uploadFile' });
-        }
-        if (!path) {
-            throw new ValidationError({ message: 'path is required for uploadFile' });
-        }
-        if (!content) {
-            throw new ValidationError({ message: 'content is required for uploadFile' });
-        }
-        try {
-            // Get write URI for upload with detected content type if not provided
-            let detectedContentType = contentType;
-            if (!detectedContentType) {
-                detectedContentType = await this._determineContentType(content, path);
-            }
-            const uriResponse = await this._getWriteUri({
-                bucketId,
-                folderId,
-                path,
-                contentType: detectedContentType
-            });
-            // Upload file to the provided URI
-            const response = await this._uploadToUri(uriResponse, content, detectedContentType);
-            return {
-                success: response.status >= 200 && response.status < 300,
-                statusCode: response.status
-            };
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    /**
-     * Determines the content type of the file based on the content and path
-     * Uses a hybrid approach:
-     * 1. Checks Blob/File type if available (browser)
-     * 2. Uses content-based detection with file-type (primarily Node.js)
-     * 3. Falls back to extension-based detection with mime-types
-     * 4. Finally defaults to application/octet-stream
-     *
-     * @param content - The file content
-     * @param path - The file path
-     * @returns The determined content type or default
-     */
-    async _determineContentType(content, path) {
-        // 1. If content is a File or Blob with type, use that (works in browser)
-        if ('type' in content && content.type) {
-            return content.type;
-        }
-        // 2. Try content-based detection (primarily for Node.js)
-        if (content instanceof Buffer && fileTypeFromBuffer) {
-            try {
-                const fileTypeResult = await fileTypeFromBuffer(content);
-                if (fileTypeResult?.mime) {
-                    return fileTypeResult.mime;
-                }
-            }
-            catch (error) {
-                // Silently continue to next detection method if this fails
-                console.debug('Content-based type detection failed:', error);
-            }
-        }
-        // 3. Try to infer from file extension using mime-types library
-        const mimeType = mimeTypes__namespace.lookup(path);
-        if (mimeType) {
-            return mimeType;
-        }
-        // 4. Final fallback
-        return CONTENT_TYPES.OCTET_STREAM;
-    }
-    /**
-     * Uploads content to the provided URI
-     * @param uriResponse - Response from getWriteUri containing URL and headers
-     * @param content - The content to upload
-     * @param contentType - The content type of the file
-     * @returns The response from the upload request with status info
-     */
-    async _uploadToUri(uriResponse, content, contentType) {
-        const { uri, headers = {}, requiresAuth } = uriResponse;
-        if (!uri) {
-            throw new ValidationError({ message: 'Upload URI not available', statusCode: HttpStatus.BAD_REQUEST });
-        }
-        // Create headers for the request
-        let requestHeaders = { ...headers };
-        // Ensure content-type is set if provided
-        if (contentType && !requestHeaders['content-type']) {
-            requestHeaders['content-type'] = contentType;
-        }
-        // Add auth header if required
-        if (requiresAuth) {
-            try {
-                const tokenInfo = this.executionContext.get('tokenInfo');
-                if (!tokenInfo) {
-                    throw new AuthenticationError({ message: 'No authentication token available. Make sure to initialize the SDK first.' });
-                }
-                let token;
-                // For secret-based tokens, they never expire so use directly
-                if (tokenInfo.type === 'secret') {
-                    token = tokenInfo.token;
-                }
-                // For non-secret tokens, check expiration and refresh if needed
-                else if (!this.tokenManager.isTokenExpired(tokenInfo)) {
-                    token = tokenInfo.token;
-                }
-                else {
-                    const newToken = await this.tokenManager.refreshAccessToken();
-                    token = newToken.access_token;
-                }
-                requestHeaders['Authorization'] = `Bearer ${token}`;
-            }
-            catch (error) {
-                throw new AuthenticationError({
-                    message: `Authentication required but failed: ${error instanceof Error ? error.message : ''}`,
-                    statusCode: HttpStatus.UNAUTHORIZED
-                });
-            }
-        }
-        return axios.put(uri, content, {
-            headers: createHeaders(requestHeaders)
-        });
-    }
-    /**
-     * Private method to handle common URI request logic
-     * @param endpoint - The API endpoint to call
-     * @param bucketId - The bucket ID
-     * @param folderId - The folder ID
-     * @param path - The file path
-     * @param queryOptions - Additional query parameters
-     * @returns Promise resolving to blob file access information
-     */
-    async _getUri(endpoint, bucketId, folderId, path, queryOptions = {}) {
-        if (!bucketId) {
-            throw new ValidationError({ message: 'bucketId is required for getUri' });
-        }
-        if (!folderId) {
-            throw new ValidationError({ message: 'folderId is required for getUri' });
-        }
-        if (!path) {
-            throw new ValidationError({ message: 'path is required for getUri' });
-        }
-        // Create headers with required folder ID
+    async getById(id, options = {}, folderId) {
         const headers = createHeaders({ [FOLDER_ID]: folderId });
-        // Filter out undefined values and build query params
-        const queryParams = filterUndefined({
-            path,
-            ...queryOptions
-        });
-        // Make the API call to get URI
-        const response = await this.get(endpoint, {
-            params: queryParams,
+        // prefix all keys in options
+        const keysToPrefix = Object.keys(options);
+        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+        const response = await this.get(TASK_ENDPOINTS.GET_BY_ID(id), {
+            params: apiOptions,
             headers
         });
-        const transformedData = transformData(pascalToCamelCaseKeys(response.data), BucketMap);
-        // Convert headers from array-based to record if needed
-        if (transformedData.headers && 'keys' in transformedData.headers && 'values' in transformedData.headers) {
-            transformedData.headers = arrayDictionaryToRecord(transformedData.headers);
+        // Transform response from PascalCase to camelCase and normalize time fields
+        const transformedTask = transformData(pascalToCamelCaseKeys(response.data), TaskMap);
+        // Check if this is a form task and get form-specific data if it is
+        if (transformedTask.type === exports.TaskType.Form) {
+            const formOptions = { expandOnFormLayout: true };
+            return this.getFormTaskById(id, folderId || transformedTask.organizationUnitId, formOptions);
         }
-        return transformedData;
+        return createTaskWithMethods(applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }), this);
     }
     /**
-     * Gets a direct download URL for a file in the bucket
+     * Assigns tasks to users
      *
-     * @param options - Contains bucketId, folderId, file path and optional expiry time
-     * @returns Promise resolving to blob file access information
+     * @param taskAssignments - Single task assignment or array of task assignments
+     * @param folderId - Optional folder ID
+     * @returns Promise resolving to array of task assignment results
      *
      * @example
      * ```typescript
-     * // Get download URL for a file
-     * const fileAccess = await sdk.buckets.getReadUri({
-     *   bucketId: 123,
-     *   folderId: 456,
-     *   path: '/folder/file.pdf'
+     * // Assign a single task to a user by ID
+     * const result = await sdk.tasks.assign({
+     *   taskId: 123,
+     *   userId: 456
      * });
+     *
+     * // Assign a single task to a user by email
+     * const result = await sdk.tasks.assign({
+     *   taskId: 123,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Assign multiple tasks
+     * const result = await sdk.tasks.assign([
+     *   {
+     *     taskId: 123,
+     *     userId: 456
+     *   },
+     *   {
+     *     taskId: 789,
+     *     userNameOrEmail: "user@example.com"
+     *   }
+     * ]);
      * ```
      */
-    async getReadUri(options) {
-        const { bucketId, folderId, path, expiryInMinutes, ...restOptions } = options;
-        const queryOptions = {
-            expiryInMinutes,
-            ...addPrefixToKeys(restOptions, ODATA_PREFIX, Object.keys(restOptions))
+    async assign(taskAssignments, folderId) {
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        // Normalize input to array
+        const assignmentArray = Array.isArray(taskAssignments) ? taskAssignments : [taskAssignments];
+        const options = {
+            taskAssignments: assignmentArray
         };
-        return this._getUri(BUCKET_ENDPOINTS.GET_READ_URI(bucketId), bucketId, folderId, path, queryOptions);
+        // Convert options to PascalCase for API
+        const pascalOptions = camelToPascalCaseKeys(options);
+        const response = await this.post(TASK_ENDPOINTS.ASSIGN_TASKS, pascalOptions, { headers });
+        // Transform response from PascalCase to camelCase
+        const transformedResponse = pascalToCamelCaseKeys(response.data);
+        // Process OData array response - empty array = success, non-empty = error
+        return processODataArrayResponse(transformedResponse, assignmentArray);
     }
     /**
-     * Gets a direct upload URL for a file in the bucket
+     * Reassigns tasks to new users
      *
-     * @param options - Contains bucketId, folderId, file path, optional expiry time and content type
-     * @returns Promise resolving to blob file access information
+     * @param taskAssignments - Single task assignment or array of task assignments
+     * @param folderId - Optional folder ID
+     * @returns Promise resolving to array of task assignment results
+     *
+     * @example
+     * ```typescript
+     * // Reassign a single task to a user by ID
+     * const result = await sdk.tasks.reassign({
+     *   taskId: 123,
+     *   userId: 456
+     * });
+     *
+     * // Reassign a single task to a user by email
+     * const result = await sdk.tasks.reassign({
+     *   taskId: 123,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Reassign multiple tasks
+     * const result = await sdk.tasks.reassign([
+     *   {
+     *     taskId: 123,
+     *     userId: 456
+     *   },
+     *   {
+     *     taskId: 789,
+     *     userNameOrEmail: "user@example.com"
+     *   }
+     * ]);
+     * ```
      */
-    async _getWriteUri(options) {
-        const { bucketId, folderId, path, expiryInMinutes, contentType, ...restOptions } = options;
-        const queryOptions = {
-            expiryInMinutes,
-            contentType,
-            ...addPrefixToKeys(restOptions, ODATA_PREFIX, Object.keys(restOptions))
+    async reassign(taskAssignments, folderId) {
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        // Normalize input to array
+        const assignmentArray = Array.isArray(taskAssignments) ? taskAssignments : [taskAssignments];
+        const options = {
+            taskAssignments: assignmentArray
         };
-        return this._getUri(BUCKET_ENDPOINTS.GET_WRITE_URI(bucketId), bucketId, folderId, path, queryOptions);
+        // Convert options to PascalCase for API
+        const pascalOptions = camelToPascalCaseKeys(options);
+        const response = await this.post(TASK_ENDPOINTS.REASSIGN_TASKS, pascalOptions, { headers });
+        // Transform response from PascalCase to camelCase
+        const transformedResponse = pascalToCamelCaseKeys(response.data);
+        // Process OData array response - empty array = success, non-empty = error
+        return processODataArrayResponse(transformedResponse, assignmentArray);
+    }
+    /**
+     * Unassigns tasks (removes current assignees)
+     *
+     * @param taskIds - Single task ID or array of task IDs to unassign
+     * @param folderId - Optional folder ID
+     * @returns Promise resolving to array of task assignment results
+     *
+     * @example
+     * ```typescript
+     * // Unassign a single task
+     * const result = await sdk.tasks.unassign(123);
+     *
+     * // Unassign multiple tasks
+     * const result = await sdk.tasks.unassign([123, 456, 789]);
+     * ```
+     */
+    async unassign(taskIds, folderId) {
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        // Normalize input to array
+        const taskIdArray = Array.isArray(taskIds) ? taskIds : [taskIds];
+        const options = {
+            taskIds: taskIdArray
+        };
+        const response = await this.post(TASK_ENDPOINTS.UNASSIGN_TASKS, options, { headers });
+        // Transform response from PascalCase to camelCase
+        const transformedResponse = pascalToCamelCaseKeys(response.data);
+        // Process OData array response - empty array = success, non-empty = error
+        // Return the task IDs that were unassigned
+        return processODataArrayResponse(transformedResponse, taskIdArray.map(id => ({ taskId: id })));
+    }
+    /**
+     * Completes a task with the specified type and data
+     *
+     * @param completionType - The type of task (Form, App, or Generic)
+     * @param options - The completion options
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to void
+     *
+     * @example
+     * ```typescript
+     * // Complete an app task
+     * await sdk.tasks.complete(TaskType.App, {
+     *   taskId: 456,
+     *   data: {},
+     *   action: "submit"
+     * }, 123); // folderId is required
+     *
+     * // Complete an external task
+     * await sdk.tasks.complete(TaskType.ExternalTask, {
+     *   taskId: 789
+     * }, 123); // folderId is required
+     * ```
+     */
+    async complete(completionType, options, folderId) {
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        let endpoint;
+        switch (completionType) {
+            case exports.TaskType.Form:
+                endpoint = TASK_ENDPOINTS.COMPLETE_FORM_TASK;
+                break;
+            case exports.TaskType.App:
+                endpoint = TASK_ENDPOINTS.COMPLETE_APP_TASK;
+                break;
+            default:
+                endpoint = TASK_ENDPOINTS.COMPLETE_GENERIC_TASK;
+                break;
+        }
+        // CompleteAppTask returns 204 no content
+        await this.post(endpoint, options, { headers });
+        // Return success with the request context data
+        return {
+            success: true,
+            data: options
+        };
+    }
+    /**
+     * Gets a form task by ID (private method)
+     *
+     * @param id - The ID of the form task to retrieve
+     * @param folderId - Required folder ID
+     * @param options - Optional query parameters
+     * @returns Promise resolving to the form task
+     */
+    async getFormTaskById(id, folderId, options = {}) {
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        const response = await this.get(TASK_ENDPOINTS.GET_TASK_FORM_BY_ID, {
+            params: {
+                taskId: id,
+                ...options
+            },
+            headers
+        });
+        const transformedFormTask = transformData(response.data, TaskMap);
+        return createTaskWithMethods(applyDataTransforms(transformedFormTask, { field: 'status', valueMap: TaskStatusMap }), this);
     }
 }
 __decorate([
-    track('Buckets.GetById')
-], BucketService.prototype, "getById", null);
+    track('Tasks.Create')
+], TaskService.prototype, "create", null);
 __decorate([
-    track('Buckets.GetAll')
-], BucketService.prototype, "getAll", null);
+    track('Tasks.GetUsers')
+], TaskService.prototype, "getUsers", null);
 __decorate([
-    track('Buckets.GetFileMetaData')
-], BucketService.prototype, "getFileMetaData", null);
+    track('Tasks.GetAll')
+], TaskService.prototype, "getAll", null);
 __decorate([
-    track('Buckets.UploadFile')
-], BucketService.prototype, "uploadFile", null);
+    track('Tasks.GetById')
+], TaskService.prototype, "getById", null);
 __decorate([
-    track('Buckets.GetReadUri')
-], BucketService.prototype, "getReadUri", null);
-
-/**
- * Maps fields for Process entities to ensure consistent naming
- */
-const ProcessMap = {
-    lastModificationTime: 'lastModifiedTime',
-    creationTime: 'createdTime',
-    organizationUnitId: 'folderId',
-    organizationUnitFullyQualifiedName: 'folderName',
-    releaseKey: 'processKey',
-    releaseName: 'processName',
-    releaseVersionId: 'processVersionId',
-    processType: 'packageType',
-    processKey: 'packageKey',
-    processVersion: 'packageVersion',
-    isProcessDeleted: 'isPackageDeleted',
-};
+    track('Tasks.Assign')
+], TaskService.prototype, "assign", null);
+__decorate([
+    track('Tasks.Reassign')
+], TaskService.prototype, "reassign", null);
+__decorate([
+    track('Tasks.Unassign')
+], TaskService.prototype, "unassign", null);
+__decorate([
+    track('Tasks.Complete')
+], TaskService.prototype, "complete", null);
 
-/**
- * Service for interacting with UiPath Orchestrator Processes API
- */
-class ProcessService extends BaseService {
+class CaseInstancesService extends BaseService {
     /**
      * @hideconstructor
      */
     constructor(config, executionContext, tokenManager) {
         super(config, executionContext, tokenManager);
+        this.taskService = new TaskService(config, executionContext, tokenManager);
     }
     /**
-     * Gets all processes across folders with optional filtering and folder scoping
+     * Get all case instances with optional filtering and pagination
      *
      * The method returns either:
-     * - An array of processes (when no pagination parameters are provided)
-     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
      *
-     * @param options - Query options including optional folderId
-     * @returns Promise resolving to an array of processes or paginated result
+     * @param options -Query parameters for filtering instances and pagination
+     * @returns Promise resolving to case instances or paginated result
      *
      * @example
      * ```typescript
-     * // Standard array return
-     * const processes = await sdk.processes.getAll();
+     * // Get all case instances (non-paginated)
+     * const instances = await sdk.maestro.cases.instances.getAll();
      *
-     * // Get processes within a specific folder
-     * const processes = await sdk.processes.getAll({
-     *   folderId: 123
-     * });
+     * // Close faulted instances using methods directly on instances
+     * for (const instance of instances.items) {
+     *   if (instance.latestRunStatus === 'Faulted') {
+     *     await instance.close({ comment: 'Closing faulted case instance' });
+     *   }
+     * }
      *
-     * // Get processes with filtering
-     * const processes = await sdk.processes.getAll({
-     *   filter: "name eq 'MyProcess'"
+     * // With filtering
+     * const instances = await sdk.maestro.cases.instances.getAll({
+     *   processKey: 'MyCaseProcess'
      * });
      *
      * // First page with pagination
-     * const page1 = await sdk.processes.getAll({ pageSize: 10 });
+     * const page1 = await sdk.maestro.cases.instances.getAll({ pageSize: 10 });
      *
      * // Navigate using cursor
      * if (page1.hasNextPage) {
-     *   const page2 = await sdk.processes.getAll({ cursor: page1.nextCursor });
+     *   const page2 = await sdk.maestro.cases.instances.getAll({ cursor: page1.nextCursor });
      * }
-     *
-     * // Jump to specific page
-     * const page5 = await sdk.processes.getAll({
-     *   jumpToPage: 5,
-     *   pageSize: 10
-     * });
      * ```
      */
     async getAll(options) {
-        // Transformation function for processes
-        const transformProcessResponse = (process) => transformData(pascalToCamelCaseKeys(process), ProcessMap);
-        return PaginationHelpers.getAll({
+        // Add processType filter to only get case management instances
+        const enhancedOptions = {
+            ...options,
+            processType: ProcessType.CaseManagement
+        };
+        // Base transformation function for case instances (synchronous)
+        const transformCaseInstance = (item) => {
+            const rawInstance = transformData(item, CaseInstanceMap);
+            return createCaseInstanceWithMethods(rawInstance, this);
+        };
+        // Get the paginated result with basic transformation
+        const result = await PaginationHelpers.getAll({
             serviceAccess: this.createPaginationServiceAccess(),
-            getEndpoint: () => PROCESS_ENDPOINTS.GET_ALL,
-            getByFolderEndpoint: PROCESS_ENDPOINTS.GET_ALL, // Processes use same endpoint for both
-            transformFn: transformProcessResponse,
+            getEndpoint: () => MAESTRO_ENDPOINTS.INSTANCES.GET_ALL,
+            transformFn: transformCaseInstance,
             pagination: {
-                paginationType: PaginationType.OFFSET,
-                itemsField: ODATA_PAGINATION.ITEMS_FIELD,
-                totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
+                paginationType: PaginationType.TOKEN,
+                itemsField: PROCESS_INSTANCE_PAGINATION.ITEMS_FIELD,
+                continuationTokenField: PROCESS_INSTANCE_PAGINATION.CONTINUATION_TOKEN_FIELD,
                 paginationParams: {
-                    pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
-                    offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
-                    countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
+                    pageSizeParam: PROCESS_INSTANCE_TOKEN_PARAMS.PAGE_SIZE_PARAM,
+                    tokenParam: PROCESS_INSTANCE_TOKEN_PARAMS.TOKEN_PARAM
                 }
+            },
+            excludeFromPrefix: Object.keys(enhancedOptions || {})
+        }, enhancedOptions);
+        // Enhance instances with case JSON data if requested
+        if (result.items && result.items.length > 0) {
+            const enhancedItems = await this.enhanceInstancesWithCaseJson(result.items);
+            return {
+                ...result,
+                items: enhancedItems
+            };
+        }
+        return result;
+    }
+    /**
+     * Get a case instance by ID with operation methods (close, pause, resume)
+     * @param instanceId - The ID of the instance to retrieve
+     * @param folderKey - Required folder key
+     * @returns Promise<CaseInstanceGetResponse>
+     */
+    async getById(instanceId, folderKey) {
+        const response = await this.get(MAESTRO_ENDPOINTS.INSTANCES.GET_BY_ID(instanceId), {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        const transformedInstance = transformData(response.data, CaseInstanceMap);
+        const instanceWithMethods = createCaseInstanceWithMethods(transformedInstance, this);
+        // Enhance with case JSON data
+        return this.enhanceInstanceWithCaseJson(instanceWithMethods);
+    }
+    /**
+     * Enhance a single case instance with case JSON data
+     * @param instance - The case instance to enhance
+     * @returns Promise resolving to enhanced instance
+     * @private
+     */
+    async enhanceInstanceWithCaseJson(instance) {
+        if (!instance.folderKey) {
+            return instance;
+        }
+        try {
+            const caseJson = await this.getCaseJson(instance.instanceId, instance.folderKey);
+            if (caseJson && caseJson.root) {
+                // Transform caseAppConfig
+                const transformedCaseAppConfig = caseJson.root.caseAppConfig ? (() => {
+                    const transformed = transformData(caseJson.root.caseAppConfig, CaseAppConfigMap);
+                    // Remove id field from each overview item
+                    if (transformed.overview) {
+                        transformed.overview = transformed.overview.map(({ id, ...rest }) => rest);
+                    }
+                    return transformed;
+                })() : undefined;
+                return {
+                    ...instance,
+                    ...(transformedCaseAppConfig && { caseAppConfig: transformedCaseAppConfig }),
+                    ...(caseJson.root.name && { caseType: caseJson.root.name }),
+                    ...(caseJson.root.description && { caseTitle: caseJson.root.description })
+                };
             }
-        }, options);
+        }
+        catch (error) {
+            console.debug(`Failed to fetch case JSON for instance ${instance.instanceId}:`, error);
+        }
+        return instance;
     }
     /**
-     * Starts a process execution (job)
-     *
-     * @param request - Process start request body
-     * @param folderId - Required folder ID
-     * @param options - Optional query parameters
-     * @returns Promise resolving to the created jobs
-     *
+     * Enhance multiple case instances with case JSON data
+     * @param instances - Array of case instances to enhance
+     * @returns Promise resolving to array of enhanced instances
+     * @private
+     */
+    async enhanceInstancesWithCaseJson(instances) {
+        return Promise.all(instances.map(instance => this.enhanceInstanceWithCaseJson(instance)));
+    }
+    /**
+     * Get case JSON for a specific instance
+     * @param instanceId - The case instance ID
+     * @param folderKey - Required folder key
+     * @returns Promise resolving to case JSON data
+     * @private
+     */
+    async getCaseJson(instanceId, folderKey) {
+        try {
+            const response = await this.get(MAESTRO_ENDPOINTS.CASES.GET_CASE_JSON(instanceId), {
+                headers: createHeaders({ [FOLDER_KEY]: folderKey })
+            });
+            return response.data;
+        }
+        catch (error) {
+            // Return null if the case JSON is not available
+            return null;
+        }
+    }
+    /**
+     * Close a case instance
+     * @param instanceId - The ID of the instance to cancel
+     * @param folderKey - Required folder key
+     * @param options - Optional cancellation options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    async close(instanceId, folderKey, options) {
+        const response = await this.post(MAESTRO_ENDPOINTS.INSTANCES.CANCEL(instanceId), options || {}, {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        return {
+            success: true,
+            data: response.data
+        };
+    }
+    /**
+     * Pause a case instance
+     * @param instanceId - The ID of the instance to pause
+     * @param folderKey - Required folder key
+     * @param options - Optional pause options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    async pause(instanceId, folderKey, options) {
+        const response = await this.post(MAESTRO_ENDPOINTS.INSTANCES.PAUSE(instanceId), options || {}, {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        return {
+            success: true,
+            data: response.data
+        };
+    }
+    /**
+     * Resume a case instance
+     * @param instanceId - The ID of the instance to resume
+     * @param folderKey - Required folder key
+     * @param options - Optional resume options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    async resume(instanceId, folderKey, options) {
+        const response = await this.post(MAESTRO_ENDPOINTS.INSTANCES.RESUME(instanceId), options || {}, {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        return {
+            success: true,
+            data: response.data
+        };
+    }
+    /**
+     * Get execution history for a case instance
+     * @param instanceId - The ID of the case instance
+     * @param folderKey - Required folder key
+     * @returns Promise resolving to instance execution history
      * @example
      * ```typescript
-     * // Start a process by process key
-     * const jobs = await sdk.processes.start({
-     *   processKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
-     * }, 123); // folderId is required
-     *
-     * // Start a process by name with specific robots
-     * const jobs = await sdk.processes.start({
-     *   processName: "MyProcess"
-     * }, 123); // folderId is required
+     * // Get execution history for a case instance
+     * const history = await sdk.maestro.cases.instances.getExecutionHistory(
+     *   'instance-id',
+     *   'folder-key'
+     * );
      * ```
      */
-    async start(request, folderId, options = {}) {
-        const headers = createHeaders({ [FOLDER_ID]: folderId });
-        // Transform processKey/processName to releaseKey/releaseName for API compatibility
-        const apiRequest = { ...request };
-        // Create a reverse mapping using ProcessMap
-        const reversedPropertiesMap = reverseMap(ProcessMap);
-        // Apply transformations for any client properties found in the request
-        Object.entries(reversedPropertiesMap).forEach(([clientKey, apiKey]) => {
-            if (clientKey in apiRequest) {
-                apiRequest[apiKey] = apiRequest[clientKey];
-                delete apiRequest[clientKey];
+    async getExecutionHistory(instanceId, folderKey) {
+        const response = await this.get(MAESTRO_ENDPOINTS.CASES.GET_ELEMENT_EXECUTIONS(instanceId), {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        // Transform the main response
+        const transformedResponse = transformData(response.data, TimeFieldTransformMap);
+        // Transform each element execution and its nested element runs
+        if (transformedResponse.elementExecutions && Array.isArray(transformedResponse.elementExecutions)) {
+            transformedResponse.elementExecutions = transformedResponse.elementExecutions.map((execution) => {
+                // Transform the element execution itself
+                const transformedExecution = transformData(execution, TimeFieldTransformMap);
+                // Transform nested element runs if they exist
+                if (transformedExecution.elementRuns && Array.isArray(transformedExecution.elementRuns)) {
+                    transformedExecution.elementRuns = transformedExecution.elementRuns.map((run) => transformData(run, TimeFieldTransformMap));
+                }
+                return transformedExecution;
+            });
+        }
+        return transformedResponse;
+    }
+    /**
+     * Get case stages with their associated tasks and execution status
+     * @param caseInstanceId - The ID of the case instance
+     * @param folderKey - Required folder key
+     * @returns Promise resolving to an array of case stages, each containing their tasks with execution details
+     */
+    async getStages(caseInstanceId, folderKey) {
+        // Fetch both execution history and case JSON in parallel, but handle execution failures gracefully
+        const [executionHistoryResponse, caseJsonResponse] = await Promise.allSettled([
+            this.getExecutionHistory(caseInstanceId, folderKey),
+            this.getCaseJson(caseInstanceId, folderKey)
+        ]);
+        // Extract execution history if successful, otherwise use null
+        const executionHistory = executionHistoryResponse.status === 'fulfilled'
+            ? executionHistoryResponse.value
+            : null;
+        // Extract case JSON - the null check below will handle failures
+        const caseJson = caseJsonResponse.status === 'fulfilled'
+            ? caseJsonResponse.value
+            : null;
+        if (!caseJson || !caseJson.nodes) {
+            return [];
+        }
+        // Create lookup maps for efficient data access
+        const executionMap = this.createExecutionMap(executionHistory);
+        const bindingsMap = this.createBindingsMap(caseJson);
+        // Process nodes to extract stages (exclude triggers)
+        const stages = caseJson.nodes
+            .filter((node) => node.type !== CASE_STAGE_CONSTANTS.TRIGGER_NODE_TYPE)
+            .map((node) => this.createStageFromNode(node, executionMap, bindingsMap));
+        return stages;
+    }
+    /**
+     * Create a map of element ID to execution data
+     * @param executionHistory - The execution history response
+     * @returns Map of elementId to execution metadata
+     * @private
+     */
+    createExecutionMap(executionHistory) {
+        const executionMap = new Map();
+        if (executionHistory?.elementExecutions) {
+            for (const execution of executionHistory.elementExecutions) {
+                executionMap.set(execution.elementId, execution);
+            }
+        }
+        return executionMap;
+    }
+    /**
+     * Create a map of binding IDs to their values
+     * @param caseJsonResponse - The case JSON response
+     * @returns Map of binding ID to binding object
+     * @private
+     */
+    createBindingsMap(caseJsonResponse) {
+        const bindingsMap = new Map();
+        if (caseJsonResponse?.root?.data?.uipath?.bindings) {
+            for (const binding of caseJsonResponse.root.data.uipath.bindings) {
+                if (binding.id) {
+                    bindingsMap.set(binding.id, binding);
+                }
+            }
+        }
+        return bindingsMap;
+    }
+    /**
+     * Resolve binding values from binding expressions
+     * @param value - The value that may contain binding references
+     * @param bindingsMap - Map of binding IDs to binding objects
+     * @returns Resolved value
+     * @private
+     */
+    resolveBinding(value, bindingsMap) {
+        if (typeof value === 'string' && value.startsWith('=bindings.')) {
+            const bindingId = value.substring('=bindings.'.length);
+            const binding = bindingsMap.get(bindingId);
+            return binding?.default || binding?.name || value;
+        }
+        return value;
+    }
+    /**
+     * Process tasks for a stage node
+     * @param node - The stage node containing tasks
+     * @param executionMap - Map of element IDs to execution data
+     * @param bindingsMap - Map of binding IDs to binding objects
+     * @returns Processed tasks array
+     * @private
+     */
+    processTasks(node, executionMap, bindingsMap) {
+        if (!node.data?.tasks || !Array.isArray(node.data.tasks)) {
+            return [];
+        }
+        return node.data.tasks.map((taskGroup) => {
+            if (Array.isArray(taskGroup)) {
+                return taskGroup.map((task) => {
+                    const taskId = task.id;
+                    // Find the execution data using the task's id
+                    const taskExecution = taskId ? executionMap.get(taskId) : undefined;
+                    // Resolve task name from bindings
+                    let taskName = task.displayName;
+                    if (!taskName && task.data?.name) {
+                        taskName = this.resolveBinding(task.data.name, bindingsMap);
+                    }
+                    const stageTask = {
+                        id: taskId || task.elementId || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE,
+                        name: taskName || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE,
+                        completedTime: taskExecution?.completedTime || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE,
+                        startedTime: taskExecution?.startedTime || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE,
+                        status: taskExecution?.status || CASE_STAGE_CONSTANTS.NOT_STARTED_STATUS,
+                        type: task.type || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE
+                    };
+                    return stageTask;
+                });
             }
+            return [];
         });
-        // Convert to PascalCase for API
-        const pascalOptions = camelToPascalCaseKeys(apiRequest);
-        // Create the request object according to API spec
-        const requestBody = {
-            startInfo: pascalOptions
+    }
+    /**
+     * Create a stage from a case node
+     * @param node - The case node to process
+     * @param executionMap - Map of element IDs to execution data
+     * @param bindingsMap - Map of binding IDs to binding objects
+     * @returns CaseGetStageResponse object
+     * @private
+     */
+    createStageFromNode(node, executionMap, bindingsMap) {
+        const execution = executionMap.get(node.id);
+        const stage = {
+            id: node.id,
+            name: node.data?.label || CASE_STAGE_CONSTANTS.UNDEFINED_VALUE,
+            sla: node.data?.sla ? transformData(node.data.sla, StageSLAMap) : undefined,
+            status: execution?.status || CASE_STAGE_CONSTANTS.NOT_STARTED_STATUS,
+            tasks: this.processTasks(node, executionMap, bindingsMap)
         };
-        // Prefix all query parameter keys with '$' for OData
-        const keysToPrefix = Object.keys(options);
-        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
-        const response = await this.post(PROCESS_ENDPOINTS.START_PROCESS, requestBody, {
-            params: apiOptions,
-            headers
-        });
-        const transformedProcess = response.data?.value.map(process => transformData(pascalToCamelCaseKeys(process), ProcessMap));
-        return transformedProcess;
+        return stage;
     }
     /**
-     * Gets a single process by ID
-     *
-     * @param id - Process ID
-     * @param folderId - Required folder ID
-     * @param options - Optional query parameters
-     * @returns Promise resolving to a single process
+     * Get human in the loop tasks associated with a case instance
+     * @param caseInstanceId - The ID of the case instance
+     * @param options - Optional filtering and pagination options
+     * @returns Promise resolving to human in the loop tasks associated with the case instance
+     */
+    async getActionTasks(caseInstanceId, options) {
+        // Build filter to match tasks by case instance ID using tags
+        const tagFilter = CASE_INSTANCE_TASK_FILTER(caseInstanceId);
+        // Combine with any existing filter
+        const filter = options?.filter
+            ? `(${tagFilter}) and (${options.filter})`
+            : tagFilter;
+        // Add expand to include AssignedToUser and Activities
+        const expand = CASE_INSTANCE_TASK_EXPAND;
+        // Prepare the enhanced options with proper typing
+        const enhancedOptions = {
+            ...options,
+            filter,
+            expand
+        };
+        return await this.taskService.getAll(enhancedOptions);
+    }
+}
+__decorate([
+    track('CaseInstances.GetAll')
+], CaseInstancesService.prototype, "getAll", null);
+__decorate([
+    track('CaseInstances.GetById')
+], CaseInstancesService.prototype, "getById", null);
+__decorate([
+    track('CaseInstances.Close')
+], CaseInstancesService.prototype, "close", null);
+__decorate([
+    track('CaseInstances.Pause')
+], CaseInstancesService.prototype, "pause", null);
+__decorate([
+    track('CaseInstances.Resume')
+], CaseInstancesService.prototype, "resume", null);
+__decorate([
+    track('CaseInstances.GetExecutionHistory')
+], CaseInstancesService.prototype, "getExecutionHistory", null);
+__decorate([
+    track('CaseInstances.GetStages')
+], CaseInstancesService.prototype, "getStages", null);
+__decorate([
+    track('CaseInstances.GetActionTasks')
+], CaseInstancesService.prototype, "getActionTasks", null);
+
+/**
+ * Base service for services that need folder-specific functionality
+ */
+class FolderScopedService extends BaseService {
+    constructor(config, executionContext, tokenManager) {
+        super(config, executionContext, tokenManager);
+    }
+    /**
+     * Gets resources in a folder with optional query parameters
      *
-     * @example
-     * ```typescript
-     * // Get process by ID
-     * const process = await sdk.processes.getById(123, 456);
-     * ```
+     * @param endpoint - API endpoint to call
+     * @param folderId - required folder ID
+     * @param options - Query options
+     * @param transformFn - Optional function to transform the response data
+     * @returns Promise resolving to an array of resources
      */
-    async getById(id, folderId, options = {}) {
+    async _getByFolder(endpoint, folderId, options = {}, transformFn) {
         const headers = createHeaders({ [FOLDER_ID]: folderId });
         const keysToPrefix = Object.keys(options);
         const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
-        const response = await this.get(PROCESS_ENDPOINTS.GET_BY_ID(id), {
-            headers,
-            params: apiOptions
+        const response = await this.get(endpoint, {
+            params: apiOptions,
+            headers
         });
-        const transformedProcess = transformData(pascalToCamelCaseKeys(response.data), ProcessMap);
-        return transformedProcess;
+        if (transformFn) {
+            return response.data?.value.map(transformFn);
+        }
+        return response.data?.value;
     }
 }
-__decorate([
-    track('Processes.GetAll')
-], ProcessService.prototype, "getAll", null);
-__decorate([
-    track('Processes.Start')
-], ProcessService.prototype, "start", null);
-__decorate([
-    track('Processes.GetById')
-], ProcessService.prototype, "getById", null);
 
 /**
- * Maps fields for Queue entities to ensure consistent naming
+ * Maps fields for Asset entities to ensure consistent naming
  */
-const QueueMap = {
+const AssetMap = {
     creationTime: 'createdTime',
-    organizationUnitId: 'folderId',
-    organizationUnitFullyQualifiedName: 'folderName'
+    lastModificationTime: 'lastModifiedTime'
 };
 
 /**
- * Service for interacting with UiPath Orchestrator Queues API
+ * Service for interacting with UiPath Orchestrator Assets API
  */
-class QueueService extends FolderScopedService {
+class AssetService extends FolderScopedService {
     /**
      * @hideconstructor
      */
@@ -4357,53 +4955,43 @@ class QueueService extends FolderScopedService {
         super(config, executionContext, tokenManager);
     }
     /**
-     * Gets all queues across folders with optional filtering and folder scoping
-     *
-     * The method returns either:
-     * - An array of queues (when no pagination parameters are provided)
-     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     * Gets all assets across folders with optional filtering and folder scoping
      *
-     * @param options - Query options including optional folderId
-     * @returns Promise resolving to an array of queues or paginated result
+     * @signature getAll(options?) -> Promise<AssetGetResponse[]>
+     * @param options Query options including optional folderId and pagination options
+     * @returns Promise resolving to array of assets or paginated response
      *
      * @example
      * ```typescript
      * // Standard array return
-     * const queues = await sdk.queues.getAll();
-     *
-     * // Get queues within a specific folder
-     * const queues = await sdk.queues.getAll({
-     *   folderId: 123
-     * });
+     * const assets = await sdk.assets.getAll();
      *
-     * // Get queues with filtering
-     * const queues = await sdk.queues.getAll({
-     *   filter: "name eq 'MyQueue'"
-     * });
+     * // With folder
+     * const folderAssets = await sdk.assets.getAll({ folderId: 123 });
      *
      * // First page with pagination
-     * const page1 = await sdk.queues.getAll({ pageSize: 10 });
+     * const page1 = await sdk.assets.getAll({ pageSize: 10 });
      *
      * // Navigate using cursor
      * if (page1.hasNextPage) {
-     *   const page2 = await sdk.queues.getAll({ cursor: page1.nextCursor });
+     *   const page2 = await sdk.assets.getAll({ cursor: page1.nextCursor });
      * }
      *
      * // Jump to specific page
-     * const page5 = await sdk.queues.getAll({
+     * const page5 = await sdk.assets.getAll({
      *   jumpToPage: 5,
      *   pageSize: 10
      * });
      * ```
      */
     async getAll(options) {
-        // Transformation function for queues
-        const transformQueueResponse = (queue) => transformData(pascalToCamelCaseKeys(queue), QueueMap);
+        // Transformation function for assets
+        const transformAssetResponse = (asset) => transformData(pascalToCamelCaseKeys(asset), AssetMap);
         return PaginationHelpers.getAll({
             serviceAccess: this.createPaginationServiceAccess(),
-            getEndpoint: (folderId) => folderId ? QUEUE_ENDPOINTS.GET_BY_FOLDER : QUEUE_ENDPOINTS.GET_ALL,
-            getByFolderEndpoint: QUEUE_ENDPOINTS.GET_BY_FOLDER,
-            transformFn: transformQueueResponse,
+            getEndpoint: (folderId) => folderId ? ASSET_ENDPOINTS.GET_BY_FOLDER : ASSET_ENDPOINTS.GET_ALL,
+            getByFolderEndpoint: ASSET_ENDPOINTS.GET_BY_FOLDER,
+            transformFn: transformAssetResponse,
             pagination: {
                 paginationType: PaginationType.OFFSET,
                 itemsField: ODATA_PAGINATION.ITEMS_FIELD,
@@ -4417,579 +5005,743 @@ class QueueService extends FolderScopedService {
         }, options);
     }
     /**
-     * Gets a single queue by ID
+     * Gets a single asset by ID
      *
-     * @param id - Queue ID
+     * @param id - Asset ID
      * @param folderId - Required folder ID
-     * @returns Promise resolving to a queue definition
+     * @param options - Optional query parameters (expand, select)
+     * @returns Promise resolving to a single asset
      *
      * @example
      * ```typescript
-     * // Get queue by ID
-     * const queue = await sdk.queues.getById(123, 456);
+     * // Get asset by ID
+     * const asset = await sdk.assets.getById(123, 456);
      * ```
      */
     async getById(id, folderId, options = {}) {
         const headers = createHeaders({ [FOLDER_ID]: folderId });
         const keysToPrefix = Object.keys(options);
         const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
-        const response = await this.get(QUEUE_ENDPOINTS.GET_BY_ID(id), {
+        const response = await this.get(ASSET_ENDPOINTS.GET_BY_ID(id), {
             headers,
             params: apiOptions
         });
-        return transformData(pascalToCamelCaseKeys(response.data), QueueMap);
+        const transformedAsset = transformData(pascalToCamelCaseKeys(response.data), AssetMap);
+        return transformedAsset;
     }
 }
 __decorate([
-    track('Queues.GetAll')
-], QueueService.prototype, "getAll", null);
+    track('Assets.GetAll')
+], AssetService.prototype, "getAll", null);
 __decorate([
-    track('Queues.GetById')
-], QueueService.prototype, "getById", null);
-
-exports.TaskType = void 0;
-(function (TaskType) {
-    TaskType["Form"] = "FormTask";
-    TaskType["External"] = "ExternalTask";
-    TaskType["App"] = "AppTask";
-})(exports.TaskType || (exports.TaskType = {}));
-exports.TaskPriority = void 0;
-(function (TaskPriority) {
-    TaskPriority["Low"] = "Low";
-    TaskPriority["Medium"] = "Medium";
-    TaskPriority["High"] = "High";
-    TaskPriority["Critical"] = "Critical";
-})(exports.TaskPriority || (exports.TaskPriority = {}));
-exports.TaskStatus = void 0;
-(function (TaskStatus) {
-    TaskStatus["Unassigned"] = "Unassigned";
-    TaskStatus["Pending"] = "Pending";
-    TaskStatus["Completed"] = "Completed";
-})(exports.TaskStatus || (exports.TaskStatus = {}));
-exports.TaskSlaCriteria = void 0;
-(function (TaskSlaCriteria) {
-    TaskSlaCriteria["TaskCreated"] = "TaskCreated";
-    TaskSlaCriteria["TaskAssigned"] = "TaskAssigned";
-    TaskSlaCriteria["TaskCompleted"] = "TaskCompleted";
-})(exports.TaskSlaCriteria || (exports.TaskSlaCriteria = {}));
-exports.TaskSlaStatus = void 0;
-(function (TaskSlaStatus) {
-    TaskSlaStatus["OverdueLater"] = "OverdueLater";
-    TaskSlaStatus["OverdueSoon"] = "OverdueSoon";
-    TaskSlaStatus["Overdue"] = "Overdue";
-    TaskSlaStatus["CompletedInTime"] = "CompletedInTime";
-})(exports.TaskSlaStatus || (exports.TaskSlaStatus = {}));
-exports.TaskSourceName = void 0;
-(function (TaskSourceName) {
-    TaskSourceName["Agent"] = "Agent";
-    TaskSourceName["Workflow"] = "Workflow";
-    TaskSourceName["Maestro"] = "Maestro";
-    TaskSourceName["Default"] = "Default";
-})(exports.TaskSourceName || (exports.TaskSourceName = {}));
-
-/**
- * Creates methods for a task
- *
- * @param taskData - The task data (response from API)
- * @param service - The task service instance
- * @returns Object containing task methods
- */
-function createTaskMethods(taskData, service) {
-    return {
-        async assign(options) {
-            if (!taskData.id)
-                throw new Error('Task ID is undefined');
-            const assignmentOptions = {
-                taskId: taskData.id,
-                userId: options.userId || 0, // Will be handled by userNameOrEmail if userId is not provided, 0 is considered as invalid user id
-                userNameOrEmail: options.userNameOrEmail
-            };
-            return service.assign(assignmentOptions, taskData.organizationUnitId);
-        },
-        async reassign(options) {
-            if (!taskData.id)
-                throw new Error('Task ID is undefined');
-            const assignmentOptions = {
-                taskId: taskData.id,
-                userId: options.userId || 0, // Will be handled by userNameOrEmail if userId is not provided, 0 is considered as invalid user id
-                userNameOrEmail: options.userNameOrEmail
-            };
-            return service.reassign(assignmentOptions, taskData.organizationUnitId);
-        },
-        async unassign() {
-            if (!taskData.id)
-                throw new Error('Task ID is undefined');
-            return service.unassign(taskData.id, taskData.organizationUnitId);
-        },
-        async complete(options) {
-            if (!taskData.id)
-                throw new Error('Task ID is undefined');
-            const folderId = taskData.organizationUnitId;
-            if (!folderId)
-                throw new Error('Folder ID is required');
-            return service.complete(options.type, {
-                taskId: taskData.id,
-                data: options.data,
-                action: options.action
-            }, folderId);
-        }
-    };
-}
-/**
- * Creates an actionable task by combining API task data with operational methods.
- *
- * @param taskData - The task data from API
- * @param service - The task service instance
- * @returns A task object with added methods
- */
-function createTaskWithMethods(taskData, service) {
-    const methods = createTaskMethods(taskData, service);
-    return Object.assign({}, taskData, methods);
-}
+    track('Assets.GetById')
+], AssetService.prototype, "getById", null);
 
 /**
- * Maps numeric TaskStatus values (from API) to TaskStatus enum values.
- * Extend this file with additional field mappings as needed.
+ * Maps fields for Bucket entities to ensure consistent naming
  */
-const TaskStatusMap = {
-    0: exports.TaskStatus.Unassigned,
-    1: exports.TaskStatus.Pending,
-    2: exports.TaskStatus.Completed,
-};
-// Field mapping for time-related fields to ensure consistent naming
-const TaskTimeMap = {
-    completionTime: 'completedTime',
-    deletionTime: 'deletedTime',
-    lastModificationTime: 'lastModifiedTime',
-    creationTime: 'createdTime',
+const BucketMap = {
+    fullPath: 'path',
+    items: 'blobItems',
+    verb: 'httpMethod'
 };
 
-/**
- * Service for interacting with UiPath Tasks API
- */
-class TaskService extends BaseService {
+// Import file-type dynamically to avoid issues in browser environment
+// This variable will hold the fileTypeFromBuffer function when in Node.js environment
+let fileTypeFromBuffer;
+// Only import in Node.js environment
+if (!isBrowser) {
+    import('file-type').then(module => {
+        fileTypeFromBuffer = module.fileTypeFromBuffer;
+    }).catch(err => {
+        console.debug('Could not load file-type module:', err);
+    });
+}
+class BucketService extends FolderScopedService {
     /**
      * @hideconstructor
      */
     constructor(config, executionContext, tokenManager) {
         super(config, executionContext, tokenManager);
-        /**
-         * Process parameters for task queries with folder filtering
-         * @param options - The REST API options to process
-         * @param folderId - Optional folder ID to filter by
-         * @returns Processed options with folder filtering applied if needed
-         * @private
-         */
-        this.processTaskParameters = (options, folderId) => {
-            const processedOptions = { ...options };
-            if (folderId) {
-                // Create or add to existing filter for folder-specific queries
-                if (processedOptions.filter) {
-                    processedOptions.filter = `${processedOptions.filter} and organizationUnitId eq ${folderId}`;
-                }
-                else {
-                    processedOptions.filter = `organizationUnitId eq ${folderId}`;
-                }
-            }
-            return processedOptions;
-        };
+        this.tokenManager = tokenManager;
     }
     /**
-     * Creates a new task
-     * @param task - The task to be created
-     * @param folderId - Required folder ID
-     * @returns Promise resolving to the created task
+     * Gets a bucket by ID
+     * @param bucketId - The ID of the bucket to retrieve
+     * @param folderId - Folder ID for organization unit context
+     * @param options - Optional query parameters (expand, select)
+     * @returns Promise resolving to the bucket
      *
      * @example
      * ```typescript
-     * const task = await sdk.tasks.create({
-     *   title: "My Task",
-     *   priority: TaskPriority.Medium,
-     *   data: { key: "value" }
-     * }, 123); // folderId is required
+     * // Get bucket by ID
+     * const bucket = await sdk.buckets.getById(123, 456);
      * ```
      */
-    async create(task, folderId) {
+    async getById(id, folderId, options = {}) {
+        if (!id) {
+            throw new ValidationError({ message: 'bucketId is required for getById' });
+        }
+        if (!folderId) {
+            throw new ValidationError({ message: 'folderId is required for getById' });
+        }
         const headers = createHeaders({ [FOLDER_ID]: folderId });
-        const externalTask = {
-            ...task,
-            type: exports.TaskType.External //currently only external task is supported
-        };
-        const response = await this.post(TASK_ENDPOINTS.CREATE_GENERIC_TASK, externalTask, { headers });
-        // Transform time fields for consistency
-        const normalizedData = transformData(response.data, TaskTimeMap);
-        const transformedData = applyDataTransforms(normalizedData, { field: 'status', valueMap: TaskStatusMap });
-        return createTaskWithMethods(transformedData, this);
+        // Prefix all keys in options with $ for OData
+        const keysToPrefix = Object.keys(options);
+        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+        const response = await this.get(BUCKET_ENDPOINTS.GET_BY_ID(id), {
+            params: apiOptions,
+            headers
+        });
+        // Transform response from PascalCase to camelCase
+        return pascalToCamelCaseKeys(response.data);
     }
     /**
-     * Gets users in the given folder who have Tasks.View and Tasks.Edit permissions
-     *
-     * The method returns either:
-     * - An array of users (when no pagination parameters are provided)
-     * - A paginated result with navigation cursors (when any pagination parameter is provided)
-     *
-     * @param folderId - The folder ID to get users from
-     * @param options - Optional query and pagination parameters
-     * @returns Promise resolving to an array of users or paginated result
-     *
-     * @example
-     * ```typescript
-     * // Standard array return
-     * const users = await sdk.tasks.getUsers(123);
-     *
-     * // Get users with filtering
-     * const users = await sdk.tasks.getUsers(123, {
-     *   filter: "name eq 'abc'"
-     * });
-     *
-     * // First page with pagination
-     * const page1 = await sdk.tasks.getUsers(123, { pageSize: 10 });
-     *
-     * // Navigate using cursor
-     * if (page1.hasNextPage) {
-     *   const page2 = await sdk.tasks.getUsers(123, { cursor: page1.nextCursor });
-     * }
-     *
-     * // Jump to specific page
-     * const page5 = await sdk.tasks.getUsers(123, {
-     *   jumpToPage: 5,
-     *   pageSize: 10
-     * });
-     * ```
+     * Gets all buckets across folders with optional filtering and folder scoping
+     *
+     * The method returns either:
+     * - An array of buckets (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options - Query options including optional folderId
+     * @returns Promise resolving to an array of buckets or paginated result
+     *
+     * @example
+     * ```typescript
+     * // Get all buckets across folders
+     * const buckets = await sdk.buckets.getAll();
+     *
+     * // Get buckets within a specific folder
+     * const buckets = await sdk.buckets.getAll({
+     *   folderId: 123
+     * });
+     *
+     * // Get buckets with filtering
+     * const buckets = await sdk.buckets.getAll({
+     *   filter: "name eq 'MyBucket'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.buckets.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.buckets.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.buckets.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    async getAll(options) {
+        // Transformation function for buckets
+        const transformBucketResponse = (bucket) => pascalToCamelCaseKeys(bucket);
+        return PaginationHelpers.getAll({
+            serviceAccess: this.createPaginationServiceAccess(),
+            getEndpoint: (folderId) => folderId ? BUCKET_ENDPOINTS.GET_BY_FOLDER : BUCKET_ENDPOINTS.GET_ALL,
+            getByFolderEndpoint: BUCKET_ENDPOINTS.GET_BY_FOLDER,
+            transformFn: transformBucketResponse,
+            pagination: {
+                paginationType: PaginationType.OFFSET,
+                itemsField: ODATA_PAGINATION.ITEMS_FIELD,
+                totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
+                paginationParams: {
+                    pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+                    offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
+                    countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
+                }
+            }
+        }, options);
+    }
+    /**
+     * Gets metadata for files in a bucket with optional filtering and pagination
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param bucketId - The ID of the bucket to get file metadata from
+     * @param folderId - Required folder ID for organization unit context
+     * @param options - Optional parameters for filtering, pagination and access URL generation
+     * @returns Promise resolving to the list of file metadata in the bucket or paginated result
+     *
+     * @example
+     * ```typescript
+     * // Get metadata for all files in a bucket
+     * const fileMetadata = await sdk.buckets.getFileMetaData(123, 456);
+     *
+     * // Get file metadata with a specific prefix
+     * const fileMetadata = await sdk.buckets.getFileMetaData(123, 456, {
+     *   prefix: '/folder1'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.buckets.getFileMetaData(123, 456, { pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.buckets.getFileMetaData(123, 456, { cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    async getFileMetaData(bucketId, folderId, options) {
+        if (!bucketId) {
+            throw new ValidationError({ message: 'bucketId is required for getFileMetaData' });
+        }
+        if (!folderId) {
+            throw new ValidationError({ message: 'folderId is required for getFileMetaData' });
+        }
+        // Transformation function for blob items
+        const transformBlobItem = (item) => transformData(item, BucketMap);
+        return PaginationHelpers.getAll({
+            serviceAccess: this.createPaginationServiceAccess(),
+            getEndpoint: () => BUCKET_ENDPOINTS.GET_FILE_META_DATA(bucketId),
+            transformFn: transformBlobItem,
+            pagination: {
+                paginationType: PaginationType.TOKEN,
+                itemsField: BUCKET_PAGINATION.ITEMS_FIELD,
+                continuationTokenField: BUCKET_PAGINATION.CONTINUATION_TOKEN_FIELD,
+                paginationParams: {
+                    pageSizeParam: BUCKET_TOKEN_PARAMS.PAGE_SIZE_PARAM,
+                    tokenParam: BUCKET_TOKEN_PARAMS.TOKEN_PARAM
+                }
+            },
+            excludeFromPrefix: ['prefix'] // Bucket-specific param, not OData
+        }, { ...options, folderId });
+    }
+    /**
+     * Uploads a file to a bucket
+     *
+     * @param options - Options for file upload including bucket ID, folder ID, path, content, and optional parameters
+     * @returns Promise resolving to a response with success status and HTTP status code
+     *
+     * @example
+     * ```typescript
+     * // Upload a file from browser
+     * const file = new File(['file content'], 'example.txt');
+     * const result = await sdk.buckets.uploadFile({
+     *   bucketId: 123,
+     *   folderId: 456,
+     *   path: '/folder/example.txt',
+     *   content: file
+     * });
+     *
+     * // In Node env with explicit content type
+     * const buffer = Buffer.from('file content');
+     * const result = await sdk.buckets.uploadFile({
+     *   bucketId: 123,
+     *   folderId: 456,
+     *   path: '/folder/example.txt',
+     *   content: buffer,
+     *   contentType: 'text/plain'
+     * });
+     * ```
+     */
+    async uploadFile(options) {
+        const { bucketId, folderId, path, content, contentType } = options;
+        if (!bucketId) {
+            throw new ValidationError({ message: 'bucketId is required for uploadFile' });
+        }
+        if (!folderId) {
+            throw new ValidationError({ message: 'folderId is required for uploadFile' });
+        }
+        if (!path) {
+            throw new ValidationError({ message: 'path is required for uploadFile' });
+        }
+        if (!content) {
+            throw new ValidationError({ message: 'content is required for uploadFile' });
+        }
+        try {
+            // Get write URI for upload with detected content type if not provided
+            let detectedContentType = contentType;
+            if (!detectedContentType) {
+                detectedContentType = await this._determineContentType(content, path);
+            }
+            const uriResponse = await this._getWriteUri({
+                bucketId,
+                folderId,
+                path,
+                contentType: detectedContentType
+            });
+            // Upload file to the provided URI
+            const response = await this._uploadToUri(uriResponse, content, detectedContentType);
+            return {
+                success: response.status >= 200 && response.status < 300,
+                statusCode: response.status
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Determines the content type of the file based on the content and path
+     * Uses a hybrid approach:
+     * 1. Checks Blob/File type if available (browser)
+     * 2. Uses content-based detection with file-type (primarily Node.js)
+     * 3. Falls back to extension-based detection with mime-types
+     * 4. Finally defaults to application/octet-stream
+     *
+     * @param content - The file content
+     * @param path - The file path
+     * @returns The determined content type or default
+     */
+    async _determineContentType(content, path) {
+        // 1. If content is a File or Blob with type, use that (works in browser)
+        if ('type' in content && content.type) {
+            return content.type;
+        }
+        // 2. Try content-based detection (primarily for Node.js)
+        if (content instanceof Buffer && fileTypeFromBuffer) {
+            try {
+                const fileTypeResult = await fileTypeFromBuffer(content);
+                if (fileTypeResult?.mime) {
+                    return fileTypeResult.mime;
+                }
+            }
+            catch (error) {
+                // Silently continue to next detection method if this fails
+                console.debug('Content-based type detection failed:', error);
+            }
+        }
+        // 3. Try to infer from file extension using mime-types library
+        const mimeType = mimeTypes__namespace.lookup(path);
+        if (mimeType) {
+            return mimeType;
+        }
+        // 4. Final fallback
+        return CONTENT_TYPES.OCTET_STREAM;
+    }
+    /**
+     * Uploads content to the provided URI
+     * @param uriResponse - Response from getWriteUri containing URL and headers
+     * @param content - The content to upload
+     * @param contentType - The content type of the file
+     * @returns The response from the upload request with status info
+     */
+    async _uploadToUri(uriResponse, content, contentType) {
+        const { uri, headers = {}, requiresAuth } = uriResponse;
+        if (!uri) {
+            throw new ValidationError({ message: 'Upload URI not available', statusCode: HttpStatus.BAD_REQUEST });
+        }
+        // Create headers for the request
+        let requestHeaders = { ...headers };
+        // Ensure content-type is set if provided
+        if (contentType && !requestHeaders['content-type']) {
+            requestHeaders['content-type'] = contentType;
+        }
+        // Add auth header if required
+        if (requiresAuth) {
+            try {
+                const tokenInfo = this.executionContext.get('tokenInfo');
+                if (!tokenInfo) {
+                    throw new AuthenticationError({ message: 'No authentication token available. Make sure to initialize the SDK first.' });
+                }
+                let token;
+                // For secret-based tokens, they never expire so use directly
+                if (tokenInfo.type === 'secret') {
+                    token = tokenInfo.token;
+                }
+                // For non-secret tokens, check expiration and refresh if needed
+                else if (!this.tokenManager.isTokenExpired(tokenInfo)) {
+                    token = tokenInfo.token;
+                }
+                else {
+                    const newToken = await this.tokenManager.refreshAccessToken();
+                    token = newToken.access_token;
+                }
+                requestHeaders['Authorization'] = `Bearer ${token}`;
+            }
+            catch (error) {
+                throw new AuthenticationError({
+                    message: `Authentication required but failed: ${error instanceof Error ? error.message : ''}`,
+                    statusCode: HttpStatus.UNAUTHORIZED
+                });
+            }
+        }
+        return axios.put(uri, content, {
+            headers: createHeaders(requestHeaders)
+        });
+    }
+    /**
+     * Private method to handle common URI request logic
+     * @param endpoint - The API endpoint to call
+     * @param bucketId - The bucket ID
+     * @param folderId - The folder ID
+     * @param path - The file path
+     * @param queryOptions - Additional query parameters
+     * @returns Promise resolving to blob file access information
+     */
+    async _getUri(endpoint, bucketId, folderId, path, queryOptions = {}) {
+        if (!bucketId) {
+            throw new ValidationError({ message: 'bucketId is required for getUri' });
+        }
+        if (!folderId) {
+            throw new ValidationError({ message: 'folderId is required for getUri' });
+        }
+        if (!path) {
+            throw new ValidationError({ message: 'path is required for getUri' });
+        }
+        // Create headers with required folder ID
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        // Filter out undefined values and build query params
+        const queryParams = filterUndefined({
+            path,
+            ...queryOptions
+        });
+        // Make the API call to get URI
+        const response = await this.get(endpoint, {
+            params: queryParams,
+            headers
+        });
+        const transformedData = transformData(pascalToCamelCaseKeys(response.data), BucketMap);
+        // Convert headers from array-based to record if needed
+        if (transformedData.headers && 'keys' in transformedData.headers && 'values' in transformedData.headers) {
+            transformedData.headers = arrayDictionaryToRecord(transformedData.headers);
+        }
+        return transformedData;
+    }
+    /**
+     * Gets a direct download URL for a file in the bucket
+     *
+     * @param options - Contains bucketId, folderId, file path and optional expiry time
+     * @returns Promise resolving to blob file access information
+     *
+     * @example
+     * ```typescript
+     * // Get download URL for a file
+     * const fileAccess = await sdk.buckets.getReadUri({
+     *   bucketId: 123,
+     *   folderId: 456,
+     *   path: '/folder/file.pdf'
+     * });
+     * ```
+     */
+    async getReadUri(options) {
+        const { bucketId, folderId, path, expiryInMinutes, ...restOptions } = options;
+        const queryOptions = {
+            expiryInMinutes,
+            ...addPrefixToKeys(restOptions, ODATA_PREFIX, Object.keys(restOptions))
+        };
+        return this._getUri(BUCKET_ENDPOINTS.GET_READ_URI(bucketId), bucketId, folderId, path, queryOptions);
+    }
+    /**
+     * Gets a direct upload URL for a file in the bucket
+     *
+     * @param options - Contains bucketId, folderId, file path, optional expiry time and content type
+     * @returns Promise resolving to blob file access information
+     */
+    async _getWriteUri(options) {
+        const { bucketId, folderId, path, expiryInMinutes, contentType, ...restOptions } = options;
+        const queryOptions = {
+            expiryInMinutes,
+            contentType,
+            ...addPrefixToKeys(restOptions, ODATA_PREFIX, Object.keys(restOptions))
+        };
+        return this._getUri(BUCKET_ENDPOINTS.GET_WRITE_URI(bucketId), bucketId, folderId, path, queryOptions);
+    }
+}
+__decorate([
+    track('Buckets.GetById')
+], BucketService.prototype, "getById", null);
+__decorate([
+    track('Buckets.GetAll')
+], BucketService.prototype, "getAll", null);
+__decorate([
+    track('Buckets.GetFileMetaData')
+], BucketService.prototype, "getFileMetaData", null);
+__decorate([
+    track('Buckets.UploadFile')
+], BucketService.prototype, "uploadFile", null);
+__decorate([
+    track('Buckets.GetReadUri')
+], BucketService.prototype, "getReadUri", null);
+
+/**
+ * Maps fields for Process entities to ensure consistent naming
+ */
+const ProcessMap = {
+    lastModificationTime: 'lastModifiedTime',
+    creationTime: 'createdTime',
+    organizationUnitId: 'folderId',
+    organizationUnitFullyQualifiedName: 'folderName',
+    releaseKey: 'processKey',
+    releaseName: 'processName',
+    releaseVersionId: 'processVersionId',
+    processType: 'packageType',
+    processKey: 'packageKey',
+    processVersion: 'packageVersion',
+    isProcessDeleted: 'isPackageDeleted',
+};
+
+/**
+ * Service for interacting with UiPath Orchestrator Processes API
+ */
+class ProcessService extends BaseService {
+    /**
+     * @hideconstructor
      */
-    async getUsers(folderId, options) {
-        // Transformation function for users
-        const transformUserResponse = (user) => pascalToCamelCaseKeys(user);
-        // Add folderId to options so the centralized helper can handle it properly
-        const optionsWithFolder = { ...options, folderId };
-        return PaginationHelpers.getAll({
-            serviceAccess: this.createPaginationServiceAccess(),
-            getEndpoint: (folderId) => TASK_ENDPOINTS.GET_TASK_USERS(folderId), // Use folderId from centralized helper
-            getByFolderEndpoint: TASK_ENDPOINTS.GET_TASK_USERS(folderId), // Use the passed folderId
-            transformFn: transformUserResponse,
-            pagination: {
-                paginationType: PaginationType.OFFSET,
-                itemsField: ODATA_PAGINATION.ITEMS_FIELD,
-                totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
-                paginationParams: {
-                    pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
-                    offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
-                    countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
-                }
-            }
-        }, optionsWithFolder);
+    constructor(config, executionContext, tokenManager) {
+        super(config, executionContext, tokenManager);
     }
     /**
-     * Gets tasks across folders with optional filtering and folder scoping
+     * Gets all processes across folders with optional filtering and folder scoping
      *
      * The method returns either:
-     * - An array of tasks (when no pagination parameters are provided)
+     * - An array of processes (when no pagination parameters are provided)
      * - A paginated result with navigation cursors (when any pagination parameter is provided)
      *
-     * @param options - Query options including optional folderId and pagination options
-     * @returns Promise resolving to an array of tasks or paginated result
+     * @param options - Query options including optional folderId
+     * @returns Promise resolving to an array of processes or paginated result
      *
      * @example
      * ```typescript
      * // Standard array return
-     * const tasks = await sdk.tasks.getAll();
+     * const processes = await sdk.processes.getAll();
      *
-     * // Get tasks within a specific folder
-     * const tasks = await sdk.tasks.getAll({
+     * // Get processes within a specific folder
+     * const processes = await sdk.processes.getAll({
      *   folderId: 123
      * });
      *
+     * // Get processes with filtering
+     * const processes = await sdk.processes.getAll({
+     *   filter: "name eq 'MyProcess'"
+     * });
+     *
      * // First page with pagination
-     * const page1 = await sdk.tasks.getAll({ pageSize: 10 });
+     * const page1 = await sdk.processes.getAll({ pageSize: 10 });
      *
      * // Navigate using cursor
      * if (page1.hasNextPage) {
-     *   const page2 = await sdk.tasks.getAll({ cursor: page1.nextCursor });
+     *   const page2 = await sdk.processes.getAll({ cursor: page1.nextCursor });
      * }
      *
      * // Jump to specific page
-     * const page5 = await sdk.tasks.getAll({
+     * const page5 = await sdk.processes.getAll({
      *   jumpToPage: 5,
      *   pageSize: 10
      * });
      * ```
      */
     async getAll(options) {
-        // Transformation function for tasks
-        const transformTaskResponse = (task) => {
-            const transformedTask = transformData(pascalToCamelCaseKeys(task), TaskTimeMap);
-            return createTaskWithMethods(applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }), this);
-        };
+        // Transformation function for processes
+        const transformProcessResponse = (process) => transformData(pascalToCamelCaseKeys(process), ProcessMap);
         return PaginationHelpers.getAll({
             serviceAccess: this.createPaginationServiceAccess(),
-            getEndpoint: () => TASK_ENDPOINTS.GET_TASKS_ACROSS_FOLDERS,
-            transformFn: transformTaskResponse,
-            processParametersFn: this.processTaskParameters,
-            excludeFromPrefix: ['event'], // Exclude 'event' key from ODATA prefix transformation
+            getEndpoint: () => PROCESS_ENDPOINTS.GET_ALL,
+            getByFolderEndpoint: PROCESS_ENDPOINTS.GET_ALL, // Processes use same endpoint for both
+            transformFn: transformProcessResponse,
             pagination: {
                 paginationType: PaginationType.OFFSET,
                 itemsField: ODATA_PAGINATION.ITEMS_FIELD,
                 totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
                 paginationParams: {
-                    pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM, // OData OFFSET parameter
-                    offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM, // OData OFFSET parameter
-                    countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM // OData OFFSET parameter
+                    pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+                    offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
+                    countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
                 }
             }
         }, options);
     }
     /**
-     * Gets a task by ID
+     * Starts a process execution (job)
      *
-     * @param id - The ID of the task to retrieve
+     * @param request - Process start request body
+     * @param folderId - Required folder ID
      * @param options - Optional query parameters
-     * @param folderId - Optional folder ID
-     * @returns Promise resolving to the task (form tasks will return form-specific data)
+     * @returns Promise resolving to the created jobs
      *
      * @example
      * ```typescript
-     * // Get task by ID
-     * const task = await sdk.tasks.getById(123);
+     * // Start a process by process key
+     * const jobs = await sdk.processes.start({
+     *   processKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+     * }, 123); // folderId is required
      *
-     * // If the task is a form task, it will automatically return form-specific data
+     * // Start a process by name with specific robots
+     * const jobs = await sdk.processes.start({
+     *   processName: "MyProcess"
+     * }, 123); // folderId is required
      * ```
      */
-    async getById(id, options = {}, folderId) {
+    async start(request, folderId, options = {}) {
         const headers = createHeaders({ [FOLDER_ID]: folderId });
-        // prefix all keys in options
-        const keysToPrefix = Object.keys(options);
-        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
-        const response = await this.get(TASK_ENDPOINTS.GET_BY_ID(id), {
-            params: apiOptions,
-            headers
+        // Transform processKey/processName to releaseKey/releaseName for API compatibility
+        const apiRequest = { ...request };
+        // Create a reverse mapping using ProcessMap
+        const reversedPropertiesMap = reverseMap(ProcessMap);
+        // Apply transformations for any client properties found in the request
+        Object.entries(reversedPropertiesMap).forEach(([clientKey, apiKey]) => {
+            if (clientKey in apiRequest) {
+                apiRequest[apiKey] = apiRequest[clientKey];
+                delete apiRequest[clientKey];
+            }
         });
-        // Transform response from PascalCase to camelCase and normalize time fields
-        const transformedTask = transformData(pascalToCamelCaseKeys(response.data), TaskTimeMap);
-        // Check if this is a form task and get form-specific data if it is
-        if (transformedTask.type === exports.TaskType.Form) {
-            const formOptions = { expandOnFormLayout: true };
-            return this.getFormTaskById(id, folderId || transformedTask.organizationUnitId, formOptions);
-        }
-        return createTaskWithMethods(applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }), this);
-    }
-    /**
-     * Assigns tasks to users
-     *
-     * @param taskAssignments - Single task assignment or array of task assignments
-     * @param folderId - Optional folder ID
-     * @returns Promise resolving to array of task assignment results
-     *
-     * @example
-     * ```typescript
-     * // Assign a single task to a user by ID
-     * const result = await sdk.tasks.assign({
-     *   taskId: 123,
-     *   userId: 456
-     * });
-     *
-     * // Assign a single task to a user by email
-     * const result = await sdk.tasks.assign({
-     *   taskId: 123,
-     *   userNameOrEmail: "user@example.com"
-     * });
-     *
-     * // Assign multiple tasks
-     * const result = await sdk.tasks.assign([
-     *   {
-     *     taskId: 123,
-     *     userId: 456
-     *   },
-     *   {
-     *     taskId: 789,
-     *     userNameOrEmail: "user@example.com"
-     *   }
-     * ]);
-     * ```
-     */
-    async assign(taskAssignments, folderId) {
-        const headers = createHeaders({ [FOLDER_ID]: folderId });
-        // Normalize input to array
-        const assignmentArray = Array.isArray(taskAssignments) ? taskAssignments : [taskAssignments];
-        const options = {
-            taskAssignments: assignmentArray
-        };
-        // Convert options to PascalCase for API
-        const pascalOptions = camelToPascalCaseKeys(options);
-        const response = await this.post(TASK_ENDPOINTS.ASSIGN_TASKS, pascalOptions, { headers });
-        // Transform response from PascalCase to camelCase
-        const transformedResponse = pascalToCamelCaseKeys(response.data);
-        // Process OData array response - empty array = success, non-empty = error
-        return processODataArrayResponse(transformedResponse, assignmentArray);
-    }
-    /**
-     * Reassigns tasks to new users
-     *
-     * @param taskAssignments - Single task assignment or array of task assignments
-     * @param folderId - Optional folder ID
-     * @returns Promise resolving to array of task assignment results
-     *
-     * @example
-     * ```typescript
-     * // Reassign a single task to a user by ID
-     * const result = await sdk.tasks.reassign({
-     *   taskId: 123,
-     *   userId: 456
-     * });
-     *
-     * // Reassign a single task to a user by email
-     * const result = await sdk.tasks.reassign({
-     *   taskId: 123,
-     *   userNameOrEmail: "user@example.com"
-     * });
-     *
-     * // Reassign multiple tasks
-     * const result = await sdk.tasks.reassign([
-     *   {
-     *     taskId: 123,
-     *     userId: 456
-     *   },
-     *   {
-     *     taskId: 789,
-     *     userNameOrEmail: "user@example.com"
-     *   }
-     * ]);
-     * ```
-     */
-    async reassign(taskAssignments, folderId) {
-        const headers = createHeaders({ [FOLDER_ID]: folderId });
-        // Normalize input to array
-        const assignmentArray = Array.isArray(taskAssignments) ? taskAssignments : [taskAssignments];
-        const options = {
-            taskAssignments: assignmentArray
+        // Convert to PascalCase for API
+        const pascalOptions = camelToPascalCaseKeys(apiRequest);
+        // Create the request object according to API spec
+        const requestBody = {
+            startInfo: pascalOptions
         };
-        // Convert options to PascalCase for API
-        const pascalOptions = camelToPascalCaseKeys(options);
-        const response = await this.post(TASK_ENDPOINTS.REASSIGN_TASKS, pascalOptions, { headers });
-        // Transform response from PascalCase to camelCase
-        const transformedResponse = pascalToCamelCaseKeys(response.data);
-        // Process OData array response - empty array = success, non-empty = error
-        return processODataArrayResponse(transformedResponse, assignmentArray);
+        // Prefix all query parameter keys with '$' for OData
+        const keysToPrefix = Object.keys(options);
+        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+        const response = await this.post(PROCESS_ENDPOINTS.START_PROCESS, requestBody, {
+            params: apiOptions,
+            headers
+        });
+        const transformedProcess = response.data?.value.map(process => transformData(pascalToCamelCaseKeys(process), ProcessMap));
+        return transformedProcess;
     }
     /**
-     * Unassigns tasks (removes current assignees)
+     * Gets a single process by ID
      *
-     * @param taskIds - Single task ID or array of task IDs to unassign
-     * @param folderId - Optional folder ID
-     * @returns Promise resolving to array of task assignment results
+     * @param id - Process ID
+     * @param folderId - Required folder ID
+     * @param options - Optional query parameters
+     * @returns Promise resolving to a single process
      *
      * @example
      * ```typescript
-     * // Unassign a single task
-     * const result = await sdk.tasks.unassign(123);
-     *
-     * // Unassign multiple tasks
-     * const result = await sdk.tasks.unassign([123, 456, 789]);
+     * // Get process by ID
+     * const process = await sdk.processes.getById(123, 456);
      * ```
      */
-    async unassign(taskIds, folderId) {
+    async getById(id, folderId, options = {}) {
         const headers = createHeaders({ [FOLDER_ID]: folderId });
-        // Normalize input to array
-        const taskIdArray = Array.isArray(taskIds) ? taskIds : [taskIds];
-        const options = {
-            taskIds: taskIdArray
-        };
-        const response = await this.post(TASK_ENDPOINTS.UNASSIGN_TASKS, options, { headers });
-        // Transform response from PascalCase to camelCase
-        const transformedResponse = pascalToCamelCaseKeys(response.data);
-        // Process OData array response - empty array = success, non-empty = error
-        // Return the task IDs that were unassigned
-        return processODataArrayResponse(transformedResponse, taskIdArray.map(id => ({ taskId: id })));
+        const keysToPrefix = Object.keys(options);
+        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+        const response = await this.get(PROCESS_ENDPOINTS.GET_BY_ID(id), {
+            headers,
+            params: apiOptions
+        });
+        const transformedProcess = transformData(pascalToCamelCaseKeys(response.data), ProcessMap);
+        return transformedProcess;
+    }
+}
+__decorate([
+    track('Processes.GetAll')
+], ProcessService.prototype, "getAll", null);
+__decorate([
+    track('Processes.Start')
+], ProcessService.prototype, "start", null);
+__decorate([
+    track('Processes.GetById')
+], ProcessService.prototype, "getById", null);
+
+/**
+ * Maps fields for Queue entities to ensure consistent naming
+ */
+const QueueMap = {
+    creationTime: 'createdTime',
+    organizationUnitId: 'folderId',
+    organizationUnitFullyQualifiedName: 'folderName'
+};
+
+/**
+ * Service for interacting with UiPath Orchestrator Queues API
+ */
+class QueueService extends FolderScopedService {
+    /**
+     * @hideconstructor
+     */
+    constructor(config, executionContext, tokenManager) {
+        super(config, executionContext, tokenManager);
     }
     /**
-     * Completes a task with the specified type and data
+     * Gets all queues across folders with optional filtering and folder scoping
      *
-     * @param completionType - The type of task (Form, App, or Generic)
-     * @param options - The completion options
-     * @param folderId - Required folder ID
-     * @returns Promise resolving to void
+     * The method returns either:
+     * - An array of queues (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options - Query options including optional folderId
+     * @returns Promise resolving to an array of queues or paginated result
      *
      * @example
      * ```typescript
-     * // Complete an app task
-     * await sdk.tasks.complete(TaskType.App, {
-     *   taskId: 456,
-     *   data: {},
-     *   action: "submit"
-     * }, 123); // folderId is required
+     * // Standard array return
+     * const queues = await sdk.queues.getAll();
      *
-     * // Complete an external task
-     * await sdk.tasks.complete(TaskType.ExternalTask, {
-     *   taskId: 789
-     * }, 123); // folderId is required
+     * // Get queues within a specific folder
+     * const queues = await sdk.queues.getAll({
+     *   folderId: 123
+     * });
+     *
+     * // Get queues with filtering
+     * const queues = await sdk.queues.getAll({
+     *   filter: "name eq 'MyQueue'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.queues.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.queues.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.queues.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
      * ```
      */
-    async complete(completionType, options, folderId) {
-        const headers = createHeaders({ [FOLDER_ID]: folderId });
-        let endpoint;
-        switch (completionType) {
-            case exports.TaskType.Form:
-                endpoint = TASK_ENDPOINTS.COMPLETE_FORM_TASK;
-                break;
-            case exports.TaskType.App:
-                endpoint = TASK_ENDPOINTS.COMPLETE_APP_TASK;
-                break;
-            default:
-                endpoint = TASK_ENDPOINTS.COMPLETE_GENERIC_TASK;
-                break;
-        }
-        // CompleteAppTask returns 204 no content
-        await this.post(endpoint, options, { headers });
-        // Return success with the request context data
-        return {
-            success: true,
-            data: options
-        };
+    async getAll(options) {
+        // Transformation function for queues
+        const transformQueueResponse = (queue) => transformData(pascalToCamelCaseKeys(queue), QueueMap);
+        return PaginationHelpers.getAll({
+            serviceAccess: this.createPaginationServiceAccess(),
+            getEndpoint: (folderId) => folderId ? QUEUE_ENDPOINTS.GET_BY_FOLDER : QUEUE_ENDPOINTS.GET_ALL,
+            getByFolderEndpoint: QUEUE_ENDPOINTS.GET_BY_FOLDER,
+            transformFn: transformQueueResponse,
+            pagination: {
+                paginationType: PaginationType.OFFSET,
+                itemsField: ODATA_PAGINATION.ITEMS_FIELD,
+                totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
+                paginationParams: {
+                    pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+                    offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
+                    countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
+                }
+            }
+        }, options);
     }
     /**
-     * Gets a form task by ID (private method)
+     * Gets a single queue by ID
      *
-     * @param id - The ID of the form task to retrieve
+     * @param id - Queue ID
      * @param folderId - Required folder ID
-     * @param options - Optional query parameters
-     * @returns Promise resolving to the form task
+     * @returns Promise resolving to a queue definition
+     *
+     * @example
+     * ```typescript
+     * // Get queue by ID
+     * const queue = await sdk.queues.getById(123, 456);
+     * ```
      */
-    async getFormTaskById(id, folderId, options = {}) {
+    async getById(id, folderId, options = {}) {
         const headers = createHeaders({ [FOLDER_ID]: folderId });
-        const response = await this.get(TASK_ENDPOINTS.GET_TASK_FORM_BY_ID, {
-            params: {
-                taskId: id,
-                ...options
-            },
-            headers
+        const keysToPrefix = Object.keys(options);
+        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+        const response = await this.get(QUEUE_ENDPOINTS.GET_BY_ID(id), {
+            headers,
+            params: apiOptions
         });
-        const transformedFormTask = transformData(response.data, TaskTimeMap);
-        return createTaskWithMethods(applyDataTransforms(transformedFormTask, { field: 'status', valueMap: TaskStatusMap }), this);
+        return transformData(pascalToCamelCaseKeys(response.data), QueueMap);
     }
 }
 __decorate([
-    track('Tasks.Create')
-], TaskService.prototype, "create", null);
-__decorate([
-    track('Tasks.GetUsers')
-], TaskService.prototype, "getUsers", null);
-__decorate([
-    track('Tasks.GetAll')
-], TaskService.prototype, "getAll", null);
-__decorate([
-    track('Tasks.GetById')
-], TaskService.prototype, "getById", null);
-__decorate([
-    track('Tasks.Assign')
-], TaskService.prototype, "assign", null);
-__decorate([
-    track('Tasks.Reassign')
-], TaskService.prototype, "reassign", null);
-__decorate([
-    track('Tasks.Unassign')
-], TaskService.prototype, "unassign", null);
+    track('Queues.GetAll')
+], QueueService.prototype, "getAll", null);
 __decorate([
-    track('Tasks.Complete')
-], TaskService.prototype, "complete", null);
+    track('Queues.GetById')
+], QueueService.prototype, "getById", null);
 
 function validateConfig(config) {
     if (!config.baseUrl || !config.orgName || !config.tenantName) {
@@ -5039,25 +5791,31 @@ class UiPath {
     }
     /**
      * Initialize the SDK based on the provided configuration.
-     * This method is only required for OAuth-based authentication.
+     * This method handles both OAuth flow initiation and completion automatically.
      * For secret-based authentication, initialization is automatic.
      */
     async initialize() {
-        // If already initialized or using secret auth, return immediately
-        if (this.initialized || hasSecretConfig(this.config)) {
+        // For secret-based auth, it's already initialized in constructor
+        if (hasSecretConfig(this.config)) {
             return;
         }
         try {
-            // If the OAuth flow redirects, the promise from `authenticate` will not resolve,
-            // and execution will stop here.
-            const success = await this.authService.authenticate(this.config);
-            if (!success || !this.authService.hasValidToken()) {
-                // If authenticate() returns false, it means a valid token could not be obtained.
-                // This could be due to invalid config or a failure in the OAuth callback.
-                // We don't throw an error for the initial OAuth redirect because that won't return.
-                throw new Error('Failed to obtain a valid authentication token.');
+            // Check for OAuth callback first
+            if (AuthService.isInOAuthCallback()) {
+                if (await this.completeOAuth()) {
+                    return;
+                }
+            }
+            // Check if already authenticated
+            if (this.isAuthenticated()) {
+                this.initialized = true;
+                return;
+            }
+            // Start new OAuth flow
+            await this.authService.authenticate(this.config);
+            if (this.isAuthenticated()) {
+                this.initialized = true;
             }
-            this.initialized = true;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
@@ -5070,6 +5828,38 @@ class UiPath {
     isInitialized() {
         return this.initialized;
     }
+    /**
+     * Check if we're in an OAuth callback state
+     */
+    isInOAuthCallback() {
+        return AuthService.isInOAuthCallback();
+    }
+    /**
+     * Complete OAuth authentication flow (only call if isInOAuthCallback() is true)
+     */
+    async completeOAuth() {
+        if (!AuthService.isInOAuthCallback()) {
+            throw new Error('Not in OAuth callback state. Call initialize() first to start OAuth flow.');
+        }
+        try {
+            const success = await this.authService.authenticate(this.config);
+            if (success && this.isAuthenticated()) {
+                this.initialized = true;
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+            throw new Error(`Failed to complete OAuth: ${errorMessage}`);
+        }
+    }
+    /**
+     * Check if the user is authenticated (has valid token)
+     */
+    isAuthenticated() {
+        return this.authService.hasValidToken();
+    }
     /**
      * Get the current authentication token
      */
@@ -5097,6 +5887,15 @@ class UiPath {
                  * Access to Process Instances service
                  */
                 instances: this.getService(ProcessInstancesService)
+            }),
+            /**
+             * Access to Maestro Cases service
+             */
+            cases: Object.assign(this.getService(CasesService), {
+                /**
+                 * Access to Case Instances service
+                 */
+                instances: this.getService(CaseInstancesService)
             })
         };
     }
@@ -5326,6 +6125,7 @@ exports.UiPath = UiPath;
 exports.UiPathError = UiPathError;
 exports.VERSION = VERSION;
 exports.ValidationError = ValidationError;
+exports.createCaseInstanceWithMethods = createCaseInstanceWithMethods;
 exports.createEntityWithMethods = createEntityWithMethods;
 exports.createProcessInstanceWithMethods = createProcessInstanceWithMethods;
 exports.createTaskWithMethods = createTaskWithMethods;