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

package/dist/{index.js → index.cjs}

@@ -2,28 +2,8 @@
 
 var zod = require('zod');
 var sdkLogs = require('@opentelemetry/sdk-logs');
-var mimeTypes = require('mime-types');
 var axios = require('axios');
 
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var mimeTypes__namespace = /*#__PURE__*/_interopNamespaceDefault(mimeTypes);
-
 zod.z.object({
     baseUrl: zod.z.string().url().default('https://cloud.uipath.com'),
     orgName: zod.z.string().min(1),
@@ -581,7 +561,7 @@ class ErrorFactory {
      * Creates appropriate error instance based on HTTP status code
      */
     static createFromHttpStatus(statusCode, errorInfo) {
-        const { message, requestId, details } = errorInfo;
+        const { message, requestId } = errorInfo;
         // Map status codes to error types
         switch (statusCode) {
             case HttpStatus.BAD_REQUEST:
@@ -999,6 +979,8 @@ function createHeaders(headersObj) {
  * Prefix used for OData query parameters
  */
 const ODATA_PREFIX = '$';
+const UNKNOWN$1 = 'Unknown';
+const NO_INSTANCE = 'no-instance';
 /**
  * OData pagination constants
  */
@@ -1491,12 +1473,12 @@ class PaginationHelpers {
             throw new Error('jumpToPage is not supported for token-based pagination. Use cursor-based navigation instead.');
         }
         // Get processed parameters
-        return PaginationHelpers.getRequestParameters(options);
+        return PaginationHelpers.getRequestParameters(options, paginationType);
     }
     /**
      * Convert a unified pagination options to service-specific parameters
      */
-    static getRequestParameters(options) {
+    static getRequestParameters(options, paginationType) {
         // Handle jumpToPage
         if (options.jumpToPage !== undefined) {
             const jumpToPageOptions = {
@@ -1509,7 +1491,8 @@ class PaginationHelpers {
         if (!options.cursor) {
             const firstPageOptions = {
                 pageSize: options.pageSize,
-                pageNumber: 1
+                // Only set pageNumber for OFFSET pagination
+                pageNumber: paginationType === PaginationType.OFFSET ? 1 : undefined
             };
             return filterUndefined(firstPageOptions);
         }
@@ -1800,7 +1783,7 @@ class BaseService {
             pageInfo: {
                 hasMore,
                 totalCount,
-                currentPage: params.pageNumber || 1,
+                currentPage: params.pageNumber,
                 pageSize: params.pageSize,
                 continuationToken
             },
@@ -2107,6 +2090,11 @@ const MAESTRO_ENDPOINTS = {
         PAUSE: (instanceId) => `pims_/api/v1/instances/${instanceId}/pause`,
         RESUME: (instanceId) => `pims_/api/v1/instances/${instanceId}/resume`,
     },
+    INCIDENTS: {
+        GET_ALL: 'pims_/api/v1/incidents/summary',
+        GET_BY_PROCESS: (processKey) => `pims_/api/v1/incidents/process/${processKey}`,
+        GET_BY_INSTANCE: (instanceId) => `pims_/api/v1/instances/${instanceId}/incidents`,
+    },
     CASES: {
         GET_CASE_JSON: (instanceId) => `pims_/api/v1/cases/${instanceId}/case-json`,
         GET_ELEMENT_EXECUTIONS: (instanceId) => `pims_/api/v1alpha1/element-executions/case-instances/${instanceId}`,
@@ -2380,12 +2368,17 @@ class AuthService extends BaseService {
         }
         else {
             // In Node.js environment
-            const crypto = require('crypto');
-            return crypto.randomBytes(32)
-                .toString('base64')
-                .replace(/\+/g, '-')
-                .replace(/\//g, '_')
-                .replace(/=/g, '');
+            try {
+                const crypto = require('crypto');
+                return crypto.randomBytes(32)
+                    .toString('base64')
+                    .replace(/\+/g, '-')
+                    .replace(/\//g, '_')
+                    .replace(/=/g, '');
+            }
+            catch (e) {
+                throw new Error("crypto not available in browser");
+            }
         }
     }
     /**
@@ -2400,13 +2393,18 @@ class AuthService extends BaseService {
         }
         else {
             // In Node.js environment
-            const crypto = require('crypto');
-            return crypto.createHash('sha256')
-                .update(codeVerifier)
-                .digest('base64')
-                .replace(/\+/g, '-')
-                .replace(/\//g, '_')
-                .replace(/=/g, '');
+            try {
+                const crypto = require('crypto');
+                return crypto.createHash('sha256')
+                    .update(codeVerifier)
+                    .digest('base64')
+                    .replace(/\+/g, '-')
+                    .replace(/\//g, '_')
+                    .replace(/=/g, '');
+            }
+            catch (e) {
+                throw new Error("crypto not available in browser");
+            }
         }
     }
     /**
@@ -2733,7 +2731,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.14";
+const SDK_VERSION = "1.0.0-beta.16";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -3046,76 +3044,6 @@ class EntityService extends BaseService {
         // Return the entity metadata with methods attached
         return createEntityWithMethods(metadata, this);
     }
-    /**
-     * Orchestrates all field mapping transformations
-     *
-     * @param metadata - Entity metadata to transform
-     * @private
-     */
-    applyFieldMappings(metadata) {
-        this.mapFieldTypes(metadata);
-        this.mapExternalFields(metadata);
-    }
-    /**
-     * Maps SQL field types to friendly EntityFieldTypes
-     *
-     * @param metadata - Entity metadata with fields
-     * @private
-     */
-    mapFieldTypes(metadata) {
-        if (!metadata.fields?.length)
-            return;
-        metadata.fields = metadata.fields.map(field => {
-            // Rename sqlType to fieldDataType
-            let transformedField = transformData(field, EntityMap);
-            // Map SQL field type to friendly name
-            if (transformedField.fieldDataType?.name) {
-                const sqlTypeName = transformedField.fieldDataType.name;
-                if (EntityFieldTypeMap[sqlTypeName]) {
-                    transformedField.fieldDataType.name = EntityFieldTypeMap[sqlTypeName];
-                }
-            }
-            this.transformNestedReferences(transformedField);
-            return transformedField;
-        });
-    }
-    /**
-     * Transforms nested reference objects in field metadata
-     */
-    transformNestedReferences(field) {
-        if (field.referenceEntity) {
-            field.referenceEntity = transformData(field.referenceEntity, EntityMap);
-        }
-        if (field.referenceChoiceSet) {
-            field.referenceChoiceSet = transformData(field.referenceChoiceSet, EntityMap);
-        }
-        if (field.referenceField?.definition) {
-            field.referenceField.definition = transformData(field.referenceField.definition, EntityMap);
-        }
-    }
-    /**
-     * Maps external field names to consistent naming
-     *
-     * @param metadata - Entity metadata with externalFields
-     * @private
-     */
-    mapExternalFields(metadata) {
-        if (!metadata.externalFields?.length)
-            return;
-        metadata.externalFields = metadata.externalFields.map(externalSource => {
-            if (externalSource.fields?.length) {
-                externalSource.fields = externalSource.fields.map(field => {
-                    const transformedField = transformData(field, EntityMap);
-                    if (transformedField.fieldMetaData) {
-                        transformedField.fieldMetaData = transformData(transformedField.fieldMetaData, EntityMap);
-                        this.transformNestedReferences(transformedField.fieldMetaData);
-                    }
-                    return transformedField;
-                });
-            }
-            return externalSource;
-        });
-    }
     /**
      * Gets entity records by entity ID
      *
@@ -3150,7 +3078,6 @@ class EntityService extends BaseService {
         return PaginationHelpers.getAll({
             serviceAccess: this.createPaginationServiceAccess(),
             getEndpoint: () => DATA_FABRIC_ENDPOINTS.ENTITY.GET_ENTITY_RECORDS(entityId),
-            transformFn: (item) => pascalToCamelCaseKeys(item),
             pagination: {
                 paginationType: PaginationType.OFFSET,
                 itemsField: ENTITY_PAGINATION.ITEMS_FIELD,
@@ -3297,6 +3224,76 @@ class EntityService extends BaseService {
         });
         return entities;
     }
+    /**
+     * Orchestrates all field mapping transformations
+     *
+     * @param metadata - Entity metadata to transform
+     * @private
+     */
+    applyFieldMappings(metadata) {
+        this.mapFieldTypes(metadata);
+        this.mapExternalFields(metadata);
+    }
+    /**
+     * Maps SQL field types to friendly EntityFieldTypes
+     *
+     * @param metadata - Entity metadata with fields
+     * @private
+     */
+    mapFieldTypes(metadata) {
+        if (!metadata.fields?.length)
+            return;
+        metadata.fields = metadata.fields.map(field => {
+            // Rename sqlType to fieldDataType
+            let transformedField = transformData(field, EntityMap);
+            // Map SQL field type to friendly name
+            if (transformedField.fieldDataType?.name) {
+                const sqlTypeName = transformedField.fieldDataType.name;
+                if (EntityFieldTypeMap[sqlTypeName]) {
+                    transformedField.fieldDataType.name = EntityFieldTypeMap[sqlTypeName];
+                }
+            }
+            this.transformNestedReferences(transformedField);
+            return transformedField;
+        });
+    }
+    /**
+     * Transforms nested reference objects in field metadata
+     */
+    transformNestedReferences(field) {
+        if (field.referenceEntity) {
+            field.referenceEntity = transformData(field.referenceEntity, EntityMap);
+        }
+        if (field.referenceChoiceSet) {
+            field.referenceChoiceSet = transformData(field.referenceChoiceSet, EntityMap);
+        }
+        if (field.referenceField?.definition) {
+            field.referenceField.definition = transformData(field.referenceField.definition, EntityMap);
+        }
+    }
+    /**
+     * Maps external field names to consistent naming
+     *
+     * @param metadata - Entity metadata with externalFields
+     * @private
+     */
+    mapExternalFields(metadata) {
+        if (!metadata.externalFields?.length)
+            return;
+        metadata.externalFields = metadata.externalFields.map(externalSource => {
+            if (externalSource.fields?.length) {
+                externalSource.fields = externalSource.fields.map(field => {
+                    const transformedField = transformData(field, EntityMap);
+                    if (transformedField.fieldMetaData) {
+                        transformedField.fieldMetaData = transformData(transformedField.fieldMetaData, EntityMap);
+                        this.transformNestedReferences(transformedField.fieldMetaData);
+                    }
+                    return transformedField;
+                });
+            }
+            return externalSource;
+        });
+    }
 }
 __decorate([
     track('Entities.GetById')
@@ -3318,46 +3315,161 @@ __decorate([
 ], EntityService.prototype, "getAll", null);
 
 /**
- * Service for interacting with Maestro Processes
+ * Maestro Process Models
+ * Model classes for Maestro processes
  */
-class MaestroProcessesService extends BaseService {
+/**
+ * Creates methods for a process object
+ *
+ * @param processData - The process data (response from API)
+ * @param service - The process service instance
+ * @returns Object containing process methods
+ */
+function createProcessMethods(processData, service) {
+    return {
+        async getIncidents() {
+            if (!processData.processKey)
+                throw new Error('Process key is undefined');
+            if (!processData.folderKey)
+                throw new Error('Folder key is undefined');
+            return service.getIncidents(processData.processKey, processData.folderKey);
+        }
+    };
+}
+/**
+ * Creates an actionable process by combining API process data with operational methods.
+ *
+ * @param processData - The process data from API
+ * @param service - The process service instance
+ * @returns A process object with added methods
+ */
+function createProcessWithMethods(processData, service) {
+    const methods = createProcessMethods(processData, service);
+    return Object.assign({}, processData, methods);
+}
+
+/**
+ * Maps fields for Incident entities
+ */
+const ProcessIncidentMap = {
+    errorTimeUtc: 'errorTime'
+};
+/**
+ * Maps fields for Incident Summary entities
+ */
+const ProcessIncidentSummaryMap = {
+    firstTimeUtc: 'firstOccuranceTime'
+};
+
+/**
+* Helpers for fetching BPMN XML and extracting element details used to annotate responses
+*/
+class BpmnHelpers {
     /**
-     * @hideconstructor
+     * Parse BPMN XML and extract element id → {name,type} used for incidents
      */
-    constructor(config, executionContext, tokenManager) {
-        super(config, executionContext, tokenManager);
+    static parseBpmnElementsForIncidents(bpmnXml) {
+        const elementInfo = {};
+        try {
+            // Find <bpmn:...> start tags and capture the element type.
+            // Then read 'id' and 'name' attributes from each tag.
+            const bpmnOpenTagRegex = /<bpmn:([A-Za-z][\w.-]*)\b[^>]*>/g;
+            for (const tagMatch of bpmnXml.matchAll(bpmnOpenTagRegex)) {
+                const [fullTag, elementType] = tagMatch;
+                // Extract attributes from the current tag text.
+                const idMatch = /\bid\s*=\s*"([^"]*)"/.exec(fullTag);
+                if (!idMatch) {
+                    continue;
+                }
+                const elementId = idMatch[1];
+                const nameMatch = /\bname\s*=\s*"([^"]*)"/.exec(fullTag);
+                const name = nameMatch ? nameMatch[1] : '';
+                // Convert BPMN element type to human-readable format
+                const activityType = this.formatActivityTypeForIncidents(elementType);
+                const activityName = name || elementId;
+                elementInfo[elementId] = {
+                    type: activityType,
+                    name: activityName
+                };
+            }
+        }
+        catch (error) {
+            console.warn('Failed to parse BPMN XML for incidents:', error);
+        }
+        return elementInfo;
     }
     /**
-     * Get all processes with their instance statistics
-     * @returns Promise resolving to array of MaestroProcess objects
-     *
-     * @example
-     * ```typescript
-     * // Get all processes
-     * const processes = await sdk.maestro.processes.getAll();
-     *
-     * // Access process information
-     * for (const process of processes) {
-     *   console.log(`Process: ${process.processKey}`);
-     *   console.log(`Running instances: ${process.runningCount}`);
-     *   console.log(`Faulted instances: ${process.faultedCount}`);
-     * }
-     *
-     * ```
+     * Format BPMN element type to human-readable activity type for incidents
      */
-    async getAll() {
-        const response = await this.get(MAESTRO_ENDPOINTS.PROCESSES.GET_ALL);
-        // Extract processes array from response data and add name field
-        const processes = response.data?.processes || [];
-        return processes.map(process => ({
-            ...process,
-            name: process.packageId
+    static formatActivityTypeForIncidents(elementType) {
+        // Convert camelCase BPMN element types to human-readable format
+        // e.g., "serviceTask" -> "Service Task", "exclusiveGateway" -> "Exclusive Gateway"
+        return elementType
+            .replace(/([A-Z])/g, ' $1') // Add space before uppercase letters
+            .replace(/^./, str => str.toUpperCase()) // Capitalize first letter
+            .trim(); // Remove any leading/trailing spaces
+    }
+    /**
+     * Fetch BPMN via getBpmn and add element name/type to each incident
+     */
+    static async enrichIncidentsWithBpmnData(incidents, folderKey, service) {
+        // Check if all incidents have the same instanceId
+        const uniqueInstanceIds = [...new Set(incidents.map(i => i.instanceId))];
+        if (uniqueInstanceIds.length === 1) {
+            // Single instance optimization (in case of process instance incidents)
+            const elementInfo = await this.getBpmnElementInfo(uniqueInstanceIds[0], folderKey, service);
+            return incidents.map((incident) => this.transformIncidentWithBpmn(incident, elementInfo));
+        }
+        else {
+            // Multiple instances optimization (in case of process incidents)
+            return this.enrichMultipleInstanceIncidents(incidents, folderKey, service);
+        }
+    }
+    /**
+     * When incidents span multiple instances, fetch BPMN per instance and annotate
+     */
+    static async enrichMultipleInstanceIncidents(incidents, folderKey, service) {
+        const groups = incidents.reduce((acc, incident) => {
+            const id = incident.instanceId || NO_INSTANCE;
+            (acc[id] = acc[id] || []).push(incident);
+            return acc;
+        }, {});
+        const results = await Promise.all(Object.entries(groups).map(async (entry) => {
+            const [instanceId, groupIncidents] = entry;
+            const elementInfo = await this.getBpmnElementInfo(instanceId, folderKey, service);
+            return groupIncidents.map((incident) => this.transformIncidentWithBpmn(incident, elementInfo));
         }));
+        return results.flat();
+    }
+    /**
+     * Retrieve BPMN XML for an instance and derive element id → {name,type}
+     */
+    static async getBpmnElementInfo(instanceId, folderKey, service) {
+        if (!instanceId || instanceId === NO_INSTANCE) {
+            return {};
+        }
+        try {
+            const bpmnXml = await service.getBpmn(instanceId, folderKey);
+            return this.parseBpmnElementsForIncidents(bpmnXml);
+        }
+        catch (error) {
+            console.warn(`Failed to get BPMN for instance ${instanceId}:`, error);
+            return {};
+        }
+    }
+    /**
+     * Transform a raw incident by attaching element name/type from BPMN
+     */
+    static transformIncidentWithBpmn(incident, elementInfo) {
+        const element = elementInfo[incident.elementId];
+        const transformed = transformData(incident, ProcessIncidentMap);
+        return {
+            ...transformed,
+            incidentElementActivityType: element?.type || UNKNOWN$1,
+            incidentElementActivityName: element?.name || UNKNOWN$1
+        };
     }
 }
-__decorate([
-    track('MaestroProcesses.GetAll')
-], MaestroProcessesService.prototype, "getAll", null);
 
 /**
  * Creates methods for a process instance
@@ -3371,17 +3483,49 @@ function createProcessInstanceMethods(instanceData, service) {
         async cancel(options) {
             if (!instanceData.instanceId)
                 throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
             return service.cancel(instanceData.instanceId, instanceData.folderKey, options);
         },
         async pause(options) {
             if (!instanceData.instanceId)
                 throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
             return service.pause(instanceData.instanceId, instanceData.folderKey, options);
         },
         async resume(options) {
             if (!instanceData.instanceId)
                 throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
             return service.resume(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async getIncidents() {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
+            return service.getIncidents(instanceData.instanceId, instanceData.folderKey);
+        },
+        async getExecutionHistory() {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            return service.getExecutionHistory(instanceData.instanceId);
+        },
+        async getBpmn() {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
+            return service.getBpmn(instanceData.instanceId, instanceData.folderKey);
+        },
+        async getVariables(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Process instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Process instance folder key is undefined');
+            return service.getVariables(instanceData.instanceId, instanceData.folderKey, options);
         }
     };
 }
@@ -3397,6 +3541,42 @@ function createProcessInstanceWithMethods(instanceData, service) {
     return Object.assign({}, instanceData, methods);
 }
 
+/**
+ * Process Incident Status
+ */
+exports.ProcessIncidentStatus = void 0;
+(function (ProcessIncidentStatus) {
+    ProcessIncidentStatus["Open"] = "Open";
+    ProcessIncidentStatus["Closed"] = "Closed";
+})(exports.ProcessIncidentStatus || (exports.ProcessIncidentStatus = {}));
+/**
+ * Process Incident Type
+ */
+exports.ProcessIncidentType = void 0;
+(function (ProcessIncidentType) {
+    ProcessIncidentType["System"] = "System";
+    ProcessIncidentType["User"] = "User";
+    ProcessIncidentType["Deployment"] = "Deployment";
+})(exports.ProcessIncidentType || (exports.ProcessIncidentType = {}));
+/**
+ * Process Incident Severity
+ */
+exports.ProcessIncidentSeverity = void 0;
+(function (ProcessIncidentSeverity) {
+    ProcessIncidentSeverity["Error"] = "Error";
+    ProcessIncidentSeverity["Warning"] = "Warning";
+})(exports.ProcessIncidentSeverity || (exports.ProcessIncidentSeverity = {}));
+/**
+ * Process Incident Debug Mode
+ */
+exports.DebugMode = void 0;
+(function (DebugMode) {
+    DebugMode["None"] = "None";
+    DebugMode["Default"] = "Default";
+    DebugMode["StepByStep"] = "StepByStep";
+    DebugMode["SingleStep"] = "SingleStep";
+})(exports.DebugMode || (exports.DebugMode = {}));
+
 /**
  * Case Instance Types
  * Types and interfaces for Maestro case instance management
@@ -3459,17 +3639,42 @@ function createCaseInstanceMethods(instanceData, service) {
         async close(options) {
             if (!instanceData.instanceId)
                 throw new Error('Case instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Case instance folder key is undefined');
             return service.close(instanceData.instanceId, instanceData.folderKey, options);
         },
         async pause(options) {
             if (!instanceData.instanceId)
                 throw new Error('Case instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Case instance folder key is undefined');
             return service.pause(instanceData.instanceId, instanceData.folderKey, options);
         },
         async resume(options) {
             if (!instanceData.instanceId)
                 throw new Error('Case instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Case instance folder key is undefined');
             return service.resume(instanceData.instanceId, instanceData.folderKey, options);
+        },
+        async getExecutionHistory() {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Case instance folder key is undefined');
+            return service.getExecutionHistory(instanceData.instanceId, instanceData.folderKey);
+        },
+        async getStages() {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            if (!instanceData.folderKey)
+                throw new Error('Case instance folder key is undefined');
+            return service.getStages(instanceData.instanceId, instanceData.folderKey);
+        },
+        async getActionTasks(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            return service.getActionTasks(instanceData.instanceId, options);
         }
     };
 }
@@ -3767,6 +3972,19 @@ class ProcessInstancesService extends BaseService {
         };
         return variablesResponse;
     }
+    /**
+     * Get incidents for a process instance
+     * @param instanceId The ID of the instance to get incidents for
+     * @param folderKey The folder key for authorization
+     * @returns Promise<ProcessIncidentGetResponse[]>
+     */
+    async getIncidents(instanceId, folderKey) {
+        const rawResponse = await this.get(MAESTRO_ENDPOINTS.INCIDENTS.GET_BY_INSTANCE(instanceId), {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        // Filter out excluded fields and transform response, then enrich with BPMN data
+        return BpmnHelpers.enrichIncidentsWithBpmnData(rawResponse.data || [], folderKey, this);
+    }
 }
 __decorate([
     track('ProcessInstances.GetAll')
@@ -3792,6 +4010,101 @@ __decorate([
 __decorate([
     track('ProcessInstances.GetVariables')
 ], ProcessInstancesService.prototype, "getVariables", null);
+__decorate([
+    track('ProcessInstances.GetIncidents')
+], ProcessInstancesService.prototype, "getIncidents", null);
+
+/**
+ * Service for interacting with Maestro Processes
+ */
+class MaestroProcessesService extends BaseService {
+    /**
+     * @hideconstructor
+     */
+    constructor(config, executionContext, tokenManager) {
+        super(config, executionContext, tokenManager);
+        this.processInstancesService = new ProcessInstancesService(config, executionContext, tokenManager);
+    }
+    /**
+     * Get all processes with their instance statistics
+     * @returns Promise resolving to array of MaestroProcess objects
+     *
+     * @example
+     * ```typescript
+     * // Get all processes
+     * const processes = await sdk.maestro.processes.getAll();
+     *
+     * // Access process information
+     * for (const process of processes) {
+     *   console.log(`Process: ${process.processKey}`);
+     *   console.log(`Running instances: ${process.runningCount}`);
+     *   console.log(`Faulted instances: ${process.faultedCount}`);
+     * }
+     *
+     * ```
+     */
+    async getAll() {
+        const response = await this.get(MAESTRO_ENDPOINTS.PROCESSES.GET_ALL);
+        // Extract processes array from response data and add name field
+        const processes = response.data?.processes || [];
+        const processesWithName = processes.map(process => ({
+            ...process,
+            name: process.packageId
+        }));
+        // Add methods to each process
+        return processesWithName.map(process => createProcessWithMethods(process, this));
+    }
+    /**
+     * Get incidents for a specific process
+     */
+    async getIncidents(processKey, folderKey) {
+        const rawResponse = await this.get(MAESTRO_ENDPOINTS.INCIDENTS.GET_BY_PROCESS(processKey), {
+            headers: createHeaders({ [FOLDER_KEY]: folderKey })
+        });
+        // Fetch BPMN XML and add element name/type to each incident
+        return BpmnHelpers.enrichIncidentsWithBpmnData(rawResponse.data || [], folderKey, this.processInstancesService);
+    }
+}
+__decorate([
+    track('MaestroProcesses.GetAll')
+], MaestroProcessesService.prototype, "getAll", null);
+__decorate([
+    track('MaestroProcesses.GetIncidents')
+], MaestroProcessesService.prototype, "getIncidents", null);
+
+/**
+ * Service class for Maestro Process Incidents
+ */
+class ProcessIncidentsService extends BaseService {
+    /**
+     * Get all process incidents across all folders
+     *
+     * @returns Promise resolving to array of process incident
+     * {@link ProcessIncidentGetAllResponse}
+     * @example
+     * ```typescript
+     * // Get all process incidents across all folders
+     * const incidents = await sdk.maestro.processes.incidents.getAll();
+     *
+     * // Access process incident information
+     * for (const incident of incidents) {
+     *   console.log(`Process: ${incident.processKey}`);
+     *   console.log(`Error: ${incident.errorMessage}`);
+     *   console.log(`Count: ${incident.count}`);
+     *   console.log(`First occurrence: ${incident.firstOccuranceTime}`);
+     * }
+     * ```
+     */
+    async getAll() {
+        const rawResponse = await this.get(MAESTRO_ENDPOINTS.INCIDENTS.GET_ALL);
+        // Transform field names  
+        const data = rawResponse.data || [];
+        return data.map(incident => transformData(incident, ProcessIncidentSummaryMap));
+    }
+}
+__decorate([
+    track('ProcessIncidents.getAll')
+], ProcessIncidentsService.prototype, "getAll", null);
 
 /**
  * Internal types for Maestro Cases
@@ -3987,35 +4300,32 @@ function createTaskMethods(taskData, service) {
         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);
+            const assignmentOptions = 'userId' in options && options.userId !== undefined
+                ? { taskId: taskData.id, userId: options.userId }
+                : { taskId: taskData.id, userNameOrEmail: options.userNameOrEmail };
+            return service.assign(assignmentOptions);
         },
         async reassign(options) {
             if (!taskData.id)
                 throw new Error('Task ID is undefined');
-            const assignmentOptions = {
-                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);
+            const assignmentOptions = 'userId' in options && options.userId !== undefined
+                ? { taskId: taskData.id, userId: options.userId }
+                : { taskId: taskData.id, userNameOrEmail: options.userNameOrEmail };
+            return service.reassign(assignmentOptions);
         },
         async unassign() {
             if (!taskData.id)
                 throw new Error('Task ID is undefined');
-            return service.unassign(taskData.id, taskData.organizationUnitId);
+            return service.unassign(taskData.id);
         },
         async complete(options) {
             if (!taskData.id)
                 throw new Error('Task ID is undefined');
-            const folderId = taskData.organizationUnitId;
+            const folderId = taskData.folderId;
             if (!folderId)
                 throw new Error('Folder ID is required');
-            return service.complete(options.type, {
+            return service.complete({
+                type: options.type,
                 taskId: taskData.id,
                 data: options.data,
                 action: options.action
@@ -4052,6 +4362,10 @@ const TaskMap = {
     creationTime: 'createdTime',
     organizationUnitId: 'folderId'
 };
+/**
+ * Default expand parameters
+ */
+const DEFAULT_TASK_EXPAND = 'AssignedToUser,CreatorUser,LastModifierUser';
 
 /**
  * Service for interacting with UiPath Tasks API
@@ -4070,7 +4384,8 @@ class TaskService extends BaseService {
          * @private
          */
         this.processTaskParameters = (options, folderId) => {
-            const processedOptions = { ...options };
+            // Add default expand parameters
+            const processedOptions = this.addDefaultExpand(options);
             if (folderId) {
                 // Create or add to existing filter for folder-specific queries
                 if (processedOptions.filter) {
@@ -4229,10 +4544,11 @@ class TaskService extends BaseService {
     }
     /**
      * Gets a task by ID
+     * IMPORTANT: For form tasks, folderId must be provided.
      *
      * @param id - The ID of the task to retrieve
      * @param options - Optional query parameters
-     * @param folderId - Optional folder ID
+     * @param folderId - Optional folder ID (REQUIRED for form tasks)
      * @returns Promise resolving to the task (form tasks will return form-specific data)
      *
      * @example
@@ -4245,9 +4561,11 @@ class TaskService extends BaseService {
      */
     async getById(id, options = {}, folderId) {
         const headers = createHeaders({ [FOLDER_ID]: folderId });
+        // Add default expand parameters
+        const modifiedOptions = this.addDefaultExpand(options);
         // prefix all keys in options
-        const keysToPrefix = Object.keys(options);
-        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+        const keysToPrefix = Object.keys(modifiedOptions);
+        const apiOptions = addPrefixToKeys(modifiedOptions, ODATA_PREFIX, keysToPrefix);
         const response = await this.get(TASK_ENDPOINTS.GET_BY_ID(id), {
             params: apiOptions,
             headers
@@ -4257,7 +4575,7 @@ class TaskService extends BaseService {
         // 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 this.getFormTaskById(id, folderId || transformedTask.folderId, formOptions);
         }
         return createTaskWithMethods(applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }), this);
     }
@@ -4265,7 +4583,6 @@ class TaskService extends BaseService {
      * 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
@@ -4295,8 +4612,7 @@ class TaskService extends BaseService {
      * ]);
      * ```
      */
-    async assign(taskAssignments, folderId) {
-        const headers = createHeaders({ [FOLDER_ID]: folderId });
+    async assign(taskAssignments) {
         // Normalize input to array
         const assignmentArray = Array.isArray(taskAssignments) ? taskAssignments : [taskAssignments];
         const options = {
@@ -4304,7 +4620,7 @@ class TaskService extends BaseService {
         };
         // Convert options to PascalCase for API
         const pascalOptions = camelToPascalCaseKeys(options);
-        const response = await this.post(TASK_ENDPOINTS.ASSIGN_TASKS, pascalOptions, { headers });
+        const response = await this.post(TASK_ENDPOINTS.ASSIGN_TASKS, pascalOptions);
         // Transform response from PascalCase to camelCase
         const transformedResponse = pascalToCamelCaseKeys(response.data);
         // Process OData array response - empty array = success, non-empty = error
@@ -4314,7 +4630,6 @@ class TaskService extends BaseService {
      * 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
@@ -4344,8 +4659,7 @@ class TaskService extends BaseService {
      * ]);
      * ```
      */
-    async reassign(taskAssignments, folderId) {
-        const headers = createHeaders({ [FOLDER_ID]: folderId });
+    async reassign(taskAssignments) {
         // Normalize input to array
         const assignmentArray = Array.isArray(taskAssignments) ? taskAssignments : [taskAssignments];
         const options = {
@@ -4353,7 +4667,7 @@ class TaskService extends BaseService {
         };
         // Convert options to PascalCase for API
         const pascalOptions = camelToPascalCaseKeys(options);
-        const response = await this.post(TASK_ENDPOINTS.REASSIGN_TASKS, pascalOptions, { headers });
+        const response = await this.post(TASK_ENDPOINTS.REASSIGN_TASKS, pascalOptions);
         // Transform response from PascalCase to camelCase
         const transformedResponse = pascalToCamelCaseKeys(response.data);
         // Process OData array response - empty array = success, non-empty = error
@@ -4363,7 +4677,6 @@ class TaskService extends BaseService {
      * 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
@@ -4375,14 +4688,13 @@ class TaskService extends BaseService {
      * const result = await sdk.tasks.unassign([123, 456, 789]);
      * ```
      */
-    async unassign(taskIds, folderId) {
-        const headers = createHeaders({ [FOLDER_ID]: folderId });
+    async unassign(taskIds) {
         // Normalize input to array
         const taskIdArray = Array.isArray(taskIds) ? taskIds : [taskIds];
         const options = {
             taskIds: taskIdArray
         };
-        const response = await this.post(TASK_ENDPOINTS.UNASSIGN_TASKS, options, { headers });
+        const response = await this.post(TASK_ENDPOINTS.UNASSIGN_TASKS, options);
         // Transform response from PascalCase to camelCase
         const transformedResponse = pascalToCamelCaseKeys(response.data);
         // Process OData array response - empty array = success, non-empty = error
@@ -4392,30 +4704,31 @@ class TaskService extends BaseService {
     /**
      * 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 options - The completion options including task type, taskId, data, and action
      * @param folderId - Required folder ID
-     * @returns Promise resolving to void
+     * @returns Promise resolving to completion result
      *
      * @example
      * ```typescript
      * // Complete an app task
-     * await sdk.tasks.complete(TaskType.App, {
+     * await sdk.tasks.complete({
+     *   type: TaskType.App,
      *   taskId: 456,
      *   data: {},
      *   action: "submit"
      * }, 123); // folderId is required
      *
      * // Complete an external task
-     * await sdk.tasks.complete(TaskType.ExternalTask, {
+     * await sdk.tasks.complete({
+     *   type: TaskType.External,
      *   taskId: 789
      * }, 123); // folderId is required
      * ```
      */
-    async complete(completionType, options, folderId) {
+    async complete(options, folderId) {
         const headers = createHeaders({ [FOLDER_ID]: folderId });
         let endpoint;
-        switch (completionType) {
+        switch (options.type) {
             case exports.TaskType.Form:
                 endpoint = TASK_ENDPOINTS.COMPLETE_FORM_TASK;
                 break;
@@ -4454,6 +4767,19 @@ class TaskService extends BaseService {
         const transformedFormTask = transformData(response.data, TaskMap);
         return createTaskWithMethods(applyDataTransforms(transformedFormTask, { field: 'status', valueMap: TaskStatusMap }), this);
     }
+    /**
+     * Adds default expand parameters to options
+     * @param options - The options object to add default expand to
+     * @returns Options with default expand parameters added
+     * @private
+     */
+    addDefaultExpand(options) {
+        const processedOptions = { ...options };
+        processedOptions.expand = processedOptions.expand
+            ? `${DEFAULT_TASK_EXPAND},${processedOptions.expand}`
+            : DEFAULT_TASK_EXPAND;
+        return processedOptions;
+    }
 }
 __decorate([
     track('Tasks.Create')
@@ -5046,17 +5372,6 @@ const BucketMap = {
     verb: 'httpMethod'
 };
 
-// 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
@@ -5229,19 +5544,18 @@ class BucketService extends FolderScopedService {
      *   content: file
      * });
      *
-     * // In Node env with explicit content type
+     * // In Node env with Buffer
      * 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'
+     *   content: buffer
      * });
      * ```
      */
     async uploadFile(options) {
-        const { bucketId, folderId, path, content, contentType } = options;
+        const { bucketId, folderId, path, content } = options;
         if (!bucketId) {
             throw new ValidationError({ message: 'bucketId is required for uploadFile' });
         }
@@ -5255,19 +5569,13 @@ class BucketService extends FolderScopedService {
             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);
+            const response = await this._uploadToUri(uriResponse, content);
             return {
                 success: response.status >= 200 && response.status < 300,
                 statusCode: response.status
@@ -5278,61 +5586,42 @@ class BucketService extends FolderScopedService {
         }
     }
     /**
-     * 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
+     * Gets a direct download URL for a file in the bucket
      *
-     * @param content - The file content
-     * @param path - The file path
-     * @returns The determined content type or default
+     * @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 _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;
+    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);
     }
     /**
      * 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) {
+    async _uploadToUri(uriResponse, content) {
         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 {
@@ -5404,41 +5693,16 @@ class BucketService extends FolderScopedService {
         }
         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
+     * @param options - Contains bucketId, folderId, file path, optional expiry time
      * @returns Promise resolving to blob file access information
      */
     async _getWriteUri(options) {
-        const { bucketId, folderId, path, expiryInMinutes, contentType, ...restOptions } = options;
+        const { bucketId, folderId, path, expiryInMinutes, ...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);
@@ -5581,11 +5845,9 @@ class ProcessService extends BaseService {
                 delete apiRequest[clientKey];
             }
         });
-        // Convert to PascalCase for API
-        const pascalOptions = camelToPascalCaseKeys(apiRequest);
         // Create the request object according to API spec
         const requestBody = {
-            startInfo: pascalOptions
+            startInfo: apiRequest
         };
         // Prefix all query parameter keys with '$' for OData
         const keysToPrefix = Object.keys(options);
@@ -5886,7 +6148,11 @@ class UiPath {
                 /**
                  * Access to Process Instances service
                  */
-                instances: this.getService(ProcessInstancesService)
+                instances: this.getService(ProcessInstancesService),
+                /**
+                 * Access to Process Incidents service
+                 */
+                incidents: this.getService(ProcessIncidentsService)
             }),
             /**
              * Access to Maestro Cases service
@@ -6128,6 +6394,7 @@ exports.ValidationError = ValidationError;
 exports.createCaseInstanceWithMethods = createCaseInstanceWithMethods;
 exports.createEntityWithMethods = createEntityWithMethods;
 exports.createProcessInstanceWithMethods = createProcessInstanceWithMethods;
+exports.createProcessWithMethods = createProcessWithMethods;
 exports.createTaskWithMethods = createTaskWithMethods;
 exports.getErrorDetails = getErrorDetails;
 exports.getLimitedPageSize = getLimitedPageSize;