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

package/dist/index.d.ts

@@ -1077,7 +1077,7 @@ declare class EntityService extends BaseService implements EntityServiceModel {
 /**
  * Process information with instance statistics
  */
-interface MaestroProcessGetAllResponse {
+interface RawMaestroProcessGetAllResponse {
     /** Unique key identifying the process */
     processKey: string;
     /** Package identifier */
@@ -1114,6 +1114,68 @@ interface MaestroProcessGetAllResponse {
     cancelingCount: number;
 }
 
+/**
+ * Process Incident Status
+ */
+declare enum ProcessIncidentStatus {
+    Open = "Open",
+    Closed = "Closed"
+}
+/**
+ * Process Incident Type
+ */
+declare enum ProcessIncidentType {
+    System = "System",
+    User = "User",
+    Deployment = "Deployment"
+}
+/**
+ * Process Incident Severity
+ */
+declare enum ProcessIncidentSeverity {
+    Error = "Error",
+    Warning = "Warning"
+}
+/**
+ * Process Incident Debug Mode
+ */
+declare enum DebugMode {
+    None = "None",
+    Default = "Default",
+    StepByStep = "StepByStep",
+    SingleStep = "SingleStep"
+}
+/**
+ * Process Incident Get Response
+ */
+interface ProcessIncidentGetResponse {
+    instanceId: string;
+    elementId: string;
+    folderKey: string;
+    processKey: string;
+    incidentId: string;
+    incidentStatus: ProcessIncidentStatus;
+    incidentType: ProcessIncidentType | null;
+    errorCode: string;
+    errorMessage: string;
+    errorTime: string;
+    errorDetails: string;
+    debugMode: DebugMode;
+    incidentSeverity: ProcessIncidentSeverity | null;
+    incidentElementActivityType: string;
+    incidentElementActivityName: string;
+}
+/**
+ * Process Incident Summary Get Response
+ */
+interface ProcessIncidentGetAllResponse {
+    count: number;
+    errorMessage: string;
+    errorCode: string;
+    firstOccuranceTime: string;
+    processKey: string;
+}
+
 /**
  * Maestro Process Models
  * Model classes for Maestro processes
@@ -1126,24 +1188,66 @@ interface MaestroProcessGetAllResponse {
  */
 interface MaestroProcessesServiceModel {
     /**
-     * @returns Promise resolving to array of MaestroProcess objects
+     * @returns Promise resolving to array of MaestroProcess objects with methods
      * {@link MaestroProcessGetAllResponse}
      * @example
      * ```typescript
      * // Get all processes
      * const processes = await sdk.maestro.processes.getAll();
      *
-     * // Access process information
+     * // Access process information and incidents
      * for (const process of processes) {
      *   console.log(`Process: ${process.processKey}`);
      *   console.log(`Running instances: ${process.runningCount}`);
      *   console.log(`Faulted instances: ${process.faultedCount}`);
+     *
+     *   // Get incidents for this process
+     *   const incidents = await process.getIncidents();
+     *   console.log(`Incidents: ${incidents.length}`);
      * }
      *
      * ```
      */
     getAll(): Promise<MaestroProcessGetAllResponse[]>;
+    /**
+     * Get incidents for a specific process
+     *
+     * @param processKey The key of the process to get incidents for
+     * @param folderKey The folder key for authorization
+     * @returns Promise resolving to array of incidents for the process
+     * {@link ProcessIncidentGetResponse}
+     * @example
+     * ```typescript
+     * // Get incidents for a specific process
+     * const incidents = await sdk.maestro.processes.getIncidents('<processKey>', '<folderKey>');
+     *
+     * // Access incident details
+     * for (const incident of incidents) {
+     *   console.log(`Element: ${incident.incidentElementActivityName} (${incident.incidentElementActivityType})`);
+     *   console.log(`Status: ${incident.incidentStatus}`);
+     *   console.log(`Error: ${incident.errorMessage}`);
+     * }
+     * ```
+     */
+    getIncidents(processKey: string, folderKey: string): Promise<ProcessIncidentGetResponse[]>;
+}
+interface ProcessMethods {
+    /**
+     * Gets incidents for this process
+     *
+     * @returns Promise resolving to array of process incidents
+     */
+    getIncidents(): Promise<ProcessIncidentGetResponse[]>;
 }
+type MaestroProcessGetAllResponse = RawMaestroProcessGetAllResponse & ProcessMethods;
+/**
+ * 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
+ */
+declare function createProcessWithMethods(processData: MaestroProcessGetAllResponse, service: MaestroProcessesServiceModel): MaestroProcessGetAllResponse;
 
 /**
  * Constants used throughout the pagination system
@@ -1453,32 +1557,23 @@ interface ProcessInstancesServiceModel {
      *   <folderKey>
      * );
      *
-     * if (result.success) {
-     *   console.log(`Instance ${result.data.instanceId} now has status: ${result.data.status}`);
-     * }
+     * or
      *
-     * // Cancel with a comment
-     * const result = await sdk.maestro.processes.instances.cancel(
+     * const instance = await sdk.maestro.processes.instances.getById(
      *   <instanceId>,
-     *   <folderKey>,
-     *   { comment: <comment> }
+     *   <folderKey>
      * );
+     * const result = await instance.cancel();
      *
-     * // Cancel multiple faulted instances
-     * const instances = await sdk.maestro.processes.instances.getAll({
-     *   latestRunStatus: "Faulted"
+     * console.log(`Cancelled: ${result.success}`);
+     *
+     * // Cancel with a comment
+     * const result = await instance.cancel({
+     *   comment: 'Cancelling due to invalid input data'
      * });
      *
-     * for (const instance of instances.items) {
-     *   const result = await sdk.maestro.processes.instances.cancel(
-     *     instance.instanceId,
-     *     instance.folderKey,
-     *     { comment: <comment> }
-     *   );
-     *
-     *   if (result.success) {
-     *     console.log(`Cancelled instance: ${result.data.instanceId}`);
-     *   }
+     * if (result.success) {
+     *   console.log(`Instance ${result.data.instanceId} status: ${result.data.status}`);
      * }
      * ```
      */
@@ -1535,6 +1630,27 @@ interface ProcessInstancesServiceModel {
      * ```
      */
     getVariables(instanceId: string, folderKey: string, options?: ProcessInstanceGetVariablesOptions): Promise<ProcessInstanceGetVariablesResponse>;
+    /**
+     * 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 resolving to array of incidents for the processinstance
+     * {@link ProcessIncidentGetResponse}
+     * @example
+     * ```typescript
+     * // Get incidents for a specific instance
+     * const incidents = await sdk.maestro.processes.instances.getIncidents('<instanceId>', '<folderKey>');
+     *
+     * // Access process incident details
+     * for (const incident of incidents) {
+     *   console.log(`Element: ${incident.incidentElementActivityName} (${incident.incidentElementActivityType})`);
+     *   console.log(`Severity: ${incident.incidentSeverity}`);
+     *   console.log(`Error: ${incident.errorMessage}`);
+     * }
+     * ```
+     */
+    getIncidents(instanceId: string, folderKey: string): Promise<ProcessIncidentGetResponse[]>;
 }
 interface ProcessInstanceMethods {
     /**
@@ -1558,6 +1674,31 @@ interface ProcessInstanceMethods {
      * @returns Promise resolving to operation result
      */
     resume(options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Gets incidents for this process instance
+     *
+     * @returns Promise resolving to array of incidents for this instance
+     */
+    getIncidents(): Promise<ProcessIncidentGetResponse[]>;
+    /**
+     * Gets execution history (spans) for this process instance
+     *
+     * @returns Promise resolving to execution history
+     */
+    getExecutionHistory(): Promise<ProcessInstanceExecutionHistoryResponse[]>;
+    /**
+     * Gets BPMN XML file for this process instance
+     *
+     * @returns Promise resolving to BPMN XML file
+     */
+    getBpmn(): Promise<BpmnXmlString>;
+    /**
+     * Gets global variables for this process instance
+     *
+     * @param options - Optional options including parentElementId to filter by parent element
+     * @returns Promise resolving to variables response with elements and globals
+     */
+    getVariables(options?: ProcessInstanceGetVariablesOptions): Promise<ProcessInstanceGetVariablesResponse>;
 }
 type ProcessInstanceGetResponse = RawProcessInstanceGetResponse & ProcessInstanceMethods;
 /**
@@ -1570,177 +1711,1476 @@ type ProcessInstanceGetResponse = RawProcessInstanceGetResponse & ProcessInstanc
 declare function createProcessInstanceWithMethods(instanceData: RawProcessInstanceGetResponse, service: ProcessInstancesServiceModel): ProcessInstanceGetResponse;
 
 /**
- * Service for interacting with Maestro Processes
+ * Service for managing UiPath Maestro Process incidents
+ *
+ * Maestro Process incidents helps you identify, investigate, and resolve errors that occur during process execution. [UiPath Maestro Process Incidents Guide](https://docs.uipath.com/maestro/automation-cloud/latest/user-guide/all-incidents-view)
  */
-declare class MaestroProcessesService extends BaseService implements MaestroProcessesServiceModel {
-    /**
-     * @hideconstructor
-     */
-    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+interface ProcessIncidentsServiceModel {
     /**
-     * Get all processes with their instance statistics
-     * @returns Promise resolving to array of MaestroProcess objects
+     * Get all process incidents across all folders
      *
+     * @returns Promise resolving to array of process incident
+     * {@link ProcessIncidentGetAllResponse}
      * @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}`);
+     * // 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}`);
      * }
-     *
      * ```
      */
-    getAll(): Promise<MaestroProcessGetAllResponse[]>;
+    getAll(): Promise<ProcessIncidentGetAllResponse[]>;
 }
 
-declare class ProcessInstancesService extends BaseService implements ProcessInstancesServiceModel {
-    /**
-     * @hideconstructor
-     */
-    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+/**
+ * Maestro Cases Types
+ * Types and interfaces for Maestro case management
+ */
+/**
+ * Case information with instance statistics
+ */
+interface CaseGetAllResponse {
+    /** Unique key identifying the case process */
+    processKey: string;
+    /** Package identifier */
+    packageId: string;
+    /** Case name */
+    name: string;
+    /** Folder key of the folder where case process is located */
+    folderKey: string;
+    /** Name of the folder where case process is located */
+    folderName: string;
+    /** Available package versions */
+    packageVersions: string[];
+    /** Total number of versions */
+    versionCount: number;
+    /** Case instance count - pending */
+    pendingCount: number;
+    /** Case instance count - running */
+    runningCount: number;
+    /** Case instance count - completed */
+    completedCount: number;
+    /** Case instance count - paused */
+    pausedCount: number;
+    /** Case instance count - cancelled */
+    cancelledCount: number;
+    /** Case instance count - faulted */
+    faultedCount: number;
+    /** Case instance count - retrying */
+    retryingCount: number;
+    /** Case instance count - resuming */
+    resumingCount: number;
+    /** Case instance count - pausing */
+    pausingCount: number;
+    /** Case instance count - canceling */
+    cancelingCount: number;
+}
+
+/**
+ * Maestro Cases Models
+ * Model classes for Maestro cases
+ */
+
+/**
+ * Service for managing UiPath Maestro Cases
+ *
+ * UiPath Maestro Case Management describes solutions that help manage and automate the full flow of complex E2E scenarios.
+ */
+interface CasesServiceModel {
     /**
-     * Get all process instances with optional filtering and pagination
-     *
-     * The method returns either:
-     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
-     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
-     *
-     * @param options Query parameters for filtering instances and pagination
-     * @returns Promise resolving to process instances or paginated result
-     *
+     * @returns Promise resolving to array of Case objects
+     * {@link CaseGetAllResponse}
      * @example
      * ```typescript
-     * // Get all instances (non-paginated)
-     * const instances = await sdk.maestro.processes.instances.getAll();
-     *
-     * // Cancel faulted instances using methods directly on instances
-     * for (const instance of instances.items) {
-     *   if (instance.latestRunStatus === 'Faulted') {
-     *     await instance.cancel({ comment: 'Cancelling faulted instance' });
-     *   }
+     * // Get all case management processes
+     * const cases = await sdk.maestro.cases.getAll();
+     *
+     * // 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}`);
      * }
      *
-     * // With filtering
-     * const instances = await sdk.maestro.processes.instances.getAll({
-     *   processKey: 'MyProcess'
-     * });
-     *
-     * // First page with pagination
-     * const page1 = await sdk.maestro.processes.instances.getAll({ pageSize: 10 });
-     *
-     * // Navigate using cursor
-     * if (page1.hasNextPage) {
-     *   const page2 = await sdk.maestro.processes.instances.getAll({ cursor: page1.nextCursor });
-     * }
      * ```
      */
-    getAll<T extends ProcessInstanceGetAllWithPaginationOptions = ProcessInstanceGetAllWithPaginationOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessInstanceGetResponse> : NonPaginatedResponse<ProcessInstanceGetResponse>>;
-    /**
-     * Get a process instance by ID with operation methods (cancel, pause, resume)
-     * @param id The ID of the instance to retrieve
-     * @param folderKey The folder key for authorization
-     * @returns Promise<ProcessInstanceGetResponse>
-     */
-    getById(id: string, folderKey: string): Promise<ProcessInstanceGetResponse>;
-    /**
-     * Get execution history (spans) for a process instance
-     * @param instanceId The ID of the instance to get history for
-     * @returns Promise<ProcessInstanceExecutionHistoryResponse[]>
-     */
-    getExecutionHistory(instanceId: string): Promise<ProcessInstanceExecutionHistoryResponse[]>;
-    /**
-     * Get BPMN XML file for a process instance
-     * @param instanceId The ID of the instance to get BPMN for
-     * @param folderKey The folder key for authorization
-     * @returns Promise<BpmnXmlString> The BPMN XML contents as a string
-     */
-    getBpmn(instanceId: string, folderKey: string): Promise<BpmnXmlString>;
-    /**
-     * Cancel a process instance
-     * @param instanceId The ID of the instance to cancel
-     * @param folderKey The folder key for authorization
-     * @param options Optional cancellation options with comment
-     * @returns Promise resolving to operation result with updated instance data
-     */
-    cancel(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
-    /**
-     * Pause a process instance
-     * @param instanceId The ID of the instance to pause
-     * @param folderKey The folder key for authorization
-     * @param options Optional pause options with comment
-     * @returns Promise resolving to operation result with updated instance data
-     */
-    pause(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
-    /**
-     * Resume a process instance
-     * @param instanceId The ID of the instance to resume
-     * @param folderKey The folder key for authorization
-     * @param options Optional resume options with comment
-     * @returns Promise resolving to operation result with updated instance data
-     */
-    resume(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
-    /**
-     * Parses BPMN XML to extract variable metadata from uipath:inputOutput elements
-     * @private
-     * @param bpmnXml The BPMN XML string
-     * @returns Map of variable ID to metadata
-     */
-    private parseBpmnVariables;
-    /**
-     * Extracts element names from BPMN XML and maps them to their element IDs
-     * @private
-     * @param bpmnXml The BPMN XML string
-     * @returns Map of elementId to element name
-     */
-    private getVariableSource;
-    /**
-     * Enriches global variables with metadata from BPMN
-     * @private
-     * @param globals The raw globals object from API response
-     * @param variableMetadata The parsed BPMN variable metadata
-     * @returns Array of global variables
-     */
-    private transformGlobalVariables;
-    /**
-     * Get global variables for a process instance
-     * @param instanceId The ID of the instance to get variables for
-     * @param folderKey The folder key for authorization
-     * @param options Optional options including parentElementId to filter by parent element
-     * @returns Promise<ProcessInstanceGetVariablesResponse>
-     */
-    getVariables(instanceId: string, folderKey: string, options?: ProcessInstanceGetVariablesOptions): Promise<ProcessInstanceGetVariablesResponse>;
+    getAll(): Promise<CaseGetAllResponse[]>;
 }
 
 /**
- * Base service for services that need folder-specific functionality
+ * Case Instance Types
+ * Types and interfaces for Maestro case instance management
  */
-declare class FolderScopedService extends BaseService {
-    constructor(config: Config, executionContext: ExecutionContext, tokenManager: 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
-     */
-    protected _getByFolder<T, R = T>(endpoint: string, folderId: number, options?: Record<string, any>, transformFn?: (item: T) => R): Promise<R[]>;
-}
 
 /**
- * Enum for Asset Value Scope
+ * Response for getting a single case instance
  */
-declare enum AssetValueScope {
-    Global = "Global",
-    PerRobot = "PerRobot"
-}
-/**
+interface RawCaseInstanceGetResponse {
+    instanceId: string;
+    packageKey: string;
+    packageId: string;
+    packageVersion: string;
+    latestRunId: string;
+    latestRunStatus: string;
+    processKey: string;
+    folderKey: string;
+    userId: number;
+    instanceDisplayName: string;
+    startedByUser: string;
+    source: string;
+    creatorUserKey: string;
+    startedTime: string;
+    completedTime: string;
+    instanceRuns: CaseInstanceRun[];
+    caseAppConfig?: CaseAppConfig;
+    caseType?: string;
+    caseTitle?: string;
+}
+/**
+ * Case instance run information
+ */
+interface CaseInstanceRun {
+    runId: string;
+    status: string;
+    startedTime: string;
+    completedTime: string;
+}
+/**
+ * Query options for getting case instances
+ */
+interface CaseInstanceGetAllOptions {
+    packageId?: string;
+    packageVersion?: string;
+    processKey?: string;
+    errorCode?: string;
+}
+/**
+ * Query options for getting case instances with pagination support
+ */
+type CaseInstanceGetAllWithPaginationOptions = CaseInstanceGetAllOptions & PaginationOptions;
+/**
+ * Request for case instance operations (close, pause, resume)
+ */
+interface CaseInstanceOperationOptions {
+    comment?: string;
+}
+/**
+ * Response for case instance operations (close, pause, resume)
+ */
+interface CaseInstanceOperationResponse {
+    instanceId: string;
+    status: string;
+}
+/**
+ * Case App Configuration Overview
+ */
+interface CaseAppOverview {
+    title: string;
+    details: string;
+}
+/**
+ * Case App Configuration from case JSON
+ */
+interface CaseAppConfig {
+    caseSummary?: string;
+    overview?: CaseAppOverview[];
+}
+/**
+ * Case stage task type
+ */
+declare enum StageTaskType {
+    EXTERNAL_AGENT = "external-agent",
+    RPA = "rpa",
+    AGENTIC_PROCESS = "process",
+    AGENT = "agent",
+    ACTION = "action",
+    API_WORKFLOW = "api-workflow"
+}
+/**
+ * Stage task information
+ */
+interface StageTask {
+    id: string;
+    name: string;
+    completedTime: string;
+    startedTime: string;
+    status: string;
+    type: StageTaskType;
+}
+/**
+ * Escalation recipient scope
+ */
+declare enum EscalationRecipientScope {
+    USER = "user",
+    USER_GROUP = "usergroup"
+}
+/**
+ * Escalation rule recipient information
+ */
+interface EscalationRecipient {
+    /** Type of recipient (user or usergroup) */
+    scope: EscalationRecipientScope;
+    /** Identifier for a user/usergroup */
+    target: string;
+    /** The email id of the user/usergroup */
+    value: string;
+}
+/**
+ * Escalation action type
+ */
+declare enum EscalationActionType {
+    NOTIFICATION = "notification"
+}
+/**
+ * Escalation rule action configuration
+ */
+interface EscalationAction {
+    type: EscalationActionType;
+    recipients: EscalationRecipient[];
+}
+/**
+ * Escalation rule trigger type
+ */
+declare enum EscalationTriggerType {
+    SLA_BREACHED = "sla-breached",
+    AT_RISK = "at-risk"
+}
+/**
+ * Escalation rule trigger metadata
+ */
+interface EscalationTriggerMetadata {
+    type?: EscalationTriggerType;
+    atRiskPercentage?: number;
+}
+/**
+ * Escalation rule configuration
+ */
+interface EscalationRule {
+    triggerInfo: EscalationTriggerMetadata;
+    action?: EscalationAction;
+}
+/**
+ * SLA duration unit
+ */
+declare enum SLADurationUnit {
+    HOURS = "h",
+    DAYS = "d",
+    WEEKS = "w",
+    MONTHS = "m"
+}
+/**
+ * SLA configuration for stages
+ */
+interface StageSLA {
+    length?: number;
+    duration?: SLADurationUnit;
+    escalationRule?: EscalationRule[];
+}
+/**
+ * Stage information from case instances
+ */
+interface CaseGetStageResponse {
+    id: string;
+    name: string;
+    sla?: StageSLA;
+    status: string;
+    tasks: StageTask[][];
+}
+/**
+ * Case element execution metadata
+ */
+interface ElementExecutionMetadata {
+    completedTime: string | null;
+    elementId: string;
+    elementName: string;
+    parentElementId: string | null;
+    startedTime: string;
+    /** Element status (e.g., "Completed", "Faulted", "Running") */
+    status: string;
+    processKey: string;
+    /** External reference link, eg link to the HITL task in Action Center */
+    externalLink: string;
+    /** List of element runs for the element */
+    elementRuns: ElementRunMetadata[];
+}
+/**
+ * Response for getting case instance element executions
+ */
+interface CaseInstanceExecutionHistoryResponse {
+    creationUserKey: string | null;
+    folderKey: string;
+    instanceDisplayName: string;
+    instanceId: string;
+    packageId: string;
+    packageKey: string;
+    packageVersion: string;
+    processKey: string;
+    source: string;
+    /** Element status (e.g., "Completed", "Faulted", "Running", "Pausing", "Canceling") */
+    status: string;
+    startedTime: string;
+    completedTime: string | null;
+    elementExecutions: ElementExecutionMetadata[];
+}
+/**
+ * Element run metadata
+ */
+interface ElementRunMetadata {
+    status: string;
+    startedTime: string;
+    completedTime: string | null;
+    elementRunId: string;
+    parentElementRunId: string | null;
+}
+
+interface UserLoginInfo {
+    name: string;
+    surname: string;
+    userName: string;
+    emailAddress: string;
+    displayName: string;
+    id: number;
+}
+declare enum TaskType {
+    Form = "FormTask",
+    External = "ExternalTask",
+    App = "AppTask"
+}
+declare enum TaskPriority {
+    Low = "Low",
+    Medium = "Medium",
+    High = "High",
+    Critical = "Critical"
+}
+declare enum TaskStatus {
+    Unassigned = "Unassigned",
+    Pending = "Pending",
+    Completed = "Completed"
+}
+declare enum TaskSlaCriteria {
+    TaskCreated = "TaskCreated",
+    TaskAssigned = "TaskAssigned",
+    TaskCompleted = "TaskCompleted"
+}
+declare enum TaskSlaStatus {
+    OverdueLater = "OverdueLater",
+    OverdueSoon = "OverdueSoon",
+    Overdue = "Overdue",
+    CompletedInTime = "CompletedInTime"
+}
+declare enum TaskSourceName {
+    Agent = "Agent",
+    Workflow = "Workflow",
+    Maestro = "Maestro",
+    Default = "Default"
+}
+interface TaskSource {
+    sourceName: TaskSourceName;
+    sourceId: string;
+    taskSourceMetadata: Record<string, unknown>;
+}
+/**
+ * Task activity types
+ */
+declare enum TaskActivityType {
+    Created = "Created",
+    Assigned = "Assigned",
+    Reassigned = "Reassigned",
+    Unassigned = "Unassigned",
+    Saved = "Saved",
+    Forwarded = "Forwarded",
+    Completed = "Completed",
+    Commented = "Commented",
+    Deleted = "Deleted",
+    BulkSaved = "BulkSaved",
+    BulkCompleted = "BulkCompleted",
+    FirstOpened = "FirstOpened"
+}
+/**
+ * Tag information for tasks
+ */
+interface Tag {
+    name: string;
+    displayName: string;
+    displayValue: string;
+}
+/**
+ * Task activity information
+ */
+interface TaskActivity {
+    task?: RawTaskGetResponse;
+    organizationUnitId: number;
+    taskId: number;
+    taskKey: string;
+    activityType: TaskActivityType;
+    creatorUserId: number;
+    targetUserId: number | null;
+    creationTime: string;
+}
+interface TaskSlaDetail {
+    expiryTime?: string;
+    startCriteria?: TaskSlaCriteria;
+    endCriteria?: TaskSlaCriteria;
+    status?: TaskSlaStatus;
+}
+interface TaskAssignment {
+    assignee?: UserLoginInfo;
+    task?: RawTaskGetResponse;
+    id?: number;
+}
+/**
+ * Base interface containing common fields shared across all task response types
+ */
+interface TaskBaseResponse {
+    status: TaskStatus;
+    title: string;
+    type: TaskType;
+    priority: TaskPriority;
+    folderId: number;
+    key: string;
+    isDeleted: boolean;
+    creationTime: string;
+    id: number;
+    action: string | null;
+    externalTag: string | null;
+    lastAssignedTime: string | null;
+    completionTime: string | null;
+    parentOperationId: string | null;
+    deleterUserId: number | null;
+    deletionTime: string | null;
+    lastModificationTime: string | null;
+}
+interface TaskCreateOptions {
+    title: string;
+    priority?: TaskPriority;
+}
+interface RawTaskCreateResponse extends TaskBaseResponse {
+    waitJobState: JobState | null;
+    assignedToUser: UserLoginInfo | null;
+    taskSlaDetails: TaskSlaDetail[] | null;
+    completedByUser: UserLoginInfo | null;
+    taskAssignees: UserLoginInfo[] | null;
+    processingTime: number | null;
+    data: Record<string, unknown> | null;
+}
+interface RawTaskGetResponse extends TaskBaseResponse {
+    isCompleted: boolean;
+    encrypted: boolean;
+    bulkFormLayoutId: number | null;
+    formLayoutId: number | null;
+    taskSlaDetail: TaskSlaDetail | null;
+    taskAssigneeName: string | null;
+    lastModifierUserId: number | null;
+    assignedToUser: UserLoginInfo | null;
+    creatorUser?: UserLoginInfo;
+    lastModifierUser?: UserLoginInfo;
+    taskAssignments?: TaskAssignment[];
+    activities?: TaskActivity[];
+    tags?: Tag[];
+    formLayout?: Record<string, unknown>;
+    actionLabel?: string | null;
+    taskSlaDetails?: TaskSlaDetail[] | null;
+    completedByUser?: UserLoginInfo | null;
+    taskAssignmentCriteria?: string;
+    taskAssignees?: UserLoginInfo[] | null;
+    taskSource?: TaskSource | null;
+    processingTime?: number | null;
+    data?: Record<string, unknown> | null;
+}
+/**
+ * Options for task assignment operations when called from a task instance
+ * Requires either userId or userNameOrEmail, but not both
+ */
+type TaskAssignOptions = {
+    userId: number;
+    userNameOrEmail?: never;
+} | {
+    userId?: never;
+    userNameOrEmail: string;
+};
+/**
+ * Options for task assignment operations when called from the service
+ * Extends TaskAssignOptions with the required taskId field
+ */
+type TaskAssignmentOptions = {
+    taskId: number;
+} & TaskAssignOptions;
+interface TasksUnassignOptions {
+    taskIds: number[];
+}
+interface TaskAssignmentResponse {
+    taskId?: number;
+    userId?: number;
+    errorCode?: number;
+    errorMessage?: string;
+    userNameOrEmail?: string;
+}
+/**
+ * Options for completing a task
+ */
+type TaskCompleteOptions = {
+    type: TaskType.External;
+    data?: any;
+    action?: string;
+} | {
+    type: Exclude<TaskType, TaskType.External>;
+    data: any;
+    action: string;
+};
+/**
+ * Options for completing a task when called from the service
+ * Extends TaskCompleteOptions with the required taskId field
+ */
+type TaskCompletionOptions = TaskCompleteOptions & {
+    taskId: number;
+};
+/**
+ * Options for getting tasks across folders
+ */
+type TaskGetAllOptions = RequestOptions & PaginationOptions & {
+    /**
+     * Optional folder ID to filter tasks by folder
+     */
+    folderId?: number;
+};
+/**
+ * Query options for getting a task by ID
+ */
+type TaskGetByIdOptions = BaseOptions;
+/**
+ * Options for getting users with task permissions
+ */
+type TaskGetUsersOptions = RequestOptions & PaginationOptions;
+
+/**
+ * Service for managing UiPath Action Center
+ *
+ * Tasks are task-based automation components that can be integrated into applications and processes. They represent discrete units of work that can be triggered and monitored through the UiPath API. [UiPath Action Center Guide](https://docs.uipath.com/automation-cloud/docs/actions)
+ *
+*/
+interface TaskServiceModel {
+    /**
+     * Gets all tasks across folders with optional filtering
+     *
+     * @param options - Query options including optional folderId and pagination options
+     * @returns Promise resolving to either an array of tasks NonPaginatedResponse<TaskGetResponse> or a PaginatedResponse<TaskGetResponse> when pagination options are used.
+     * {@link TaskGetResponse}
+     *  @example
+     * ```typescript
+     * // Standard array return
+     * const tasks = await sdk.tasks.getAll();
+     *
+     * // Get tasks within a specific folder
+     * const tasks = await sdk.tasks.getAll({
+     *   folderId: 123
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.tasks.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.tasks.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.tasks.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends TaskGetAllOptions = TaskGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
+    /**
+     * Gets a task by ID
+     * IMPORTANT: For form tasks, folderId must be provided.
+     * @param id - The ID of the task to retrieve
+     * @param options - Optional query parameters
+     * @param folderId - Optional folder ID (REQUIRED for form tasks)
+     * @returns Promise resolving to the task
+     * {@link TaskGetResponse}
+     * @example
+     * ```typescript
+     * // Get a task by ID
+     * const task = await sdk.tasks.getById(<taskId>);
+     *
+     * // Get a form task by ID
+     * const formTask = await sdk.tasks.getById(<taskId>, <folderId>);
+     *
+     * // Access form task properties
+     * console.log(formTask.formLayout);
+     * ```
+     */
+    getById(id: number, options?: TaskGetByIdOptions, folderId?: number): Promise<TaskGetResponse>;
+    /**
+     * Creates a new task
+     *
+     * @param options - The task to be created
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to the created task
+     * {@link TaskCreateResponse}
+     * @example
+     * ```typescript
+     * import { TaskPriority } from '@uipath/uipath-typescript';
+     * const task = await sdk.tasks.create({
+     *   title: "My Task",
+     *   priority: TaskPriority.Medium
+     * }, <folderId>); // folderId is required
+     * ```
+     */
+    create(options: TaskCreateOptions, folderId: number): Promise<TaskCreateResponse>;
+    /**
+     * Assigns tasks to users
+     *
+     * @param options - Single task assignment or array of task assignments
+     * @returns Promise resolving to array of task assignment results
+     * {@link TaskAssignmentResponse}
+     * @example
+     * ```typescript
+     * // Assign a single task to a user by ID
+     * const result = await sdk.tasks.assign({
+     *   taskId: <taskId>,
+     *   userId: <userId>
+     * });
+     *
+     * or
+     *
+     * const task = await sdk.tasks.getById(<taskId>);
+     * const result = await task.assign({
+     *   userId: <userId>
+     * });
+     *
+     * // Assign a single task to a user by email
+     * const result = await sdk.tasks.assign({
+     *   taskId: <taskId>,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Assign multiple tasks
+     * const result = await sdk.tasks.assign([
+     *   { taskId: <taskId1>, userId: <userId> },
+     *   { taskId: <taskId2>, userNameOrEmail: "user@example.com" }
+     * ]);
+     * ```
+     */
+    assign(options: TaskAssignmentOptions | TaskAssignmentOptions[]): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Reassigns tasks to new users
+     *
+     * @param options - Single task assignment or array of task assignments
+     * @returns Promise resolving to array of task assignment results
+     * {@link TaskAssignmentResponse}
+     * @example
+     * ```typescript
+     * // Reassign a single task to a user by ID
+     * const result = await sdk.tasks.reassign({
+     *   taskId: <taskId>,
+     *   userId: <userId>
+     * });
+     *
+     * or
+     *
+     * const task = await sdk.tasks.getById(<taskId>);
+     * const result = await task.reassign({
+     *   userId: <userId>
+     * });
+     *
+     * // Reassign a single task to a user by email
+     * const result = await sdk.tasks.reassign({
+     *   taskId: <taskId>,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Reassign multiple tasks
+     * const result = await sdk.tasks.reassign([
+     *   { taskId: <taskId1>, userId: <userId> },
+     *   { taskId: <taskId2>, userNameOrEmail: "user@example.com" }
+     * ]);
+     * ```
+     */
+    reassign(options: TaskAssignmentOptions | TaskAssignmentOptions[]): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Unassigns tasks (removes current assignees)
+     *
+     * @param taskId - Single task ID or array of task IDs to unassign
+     * @returns Promise resolving to array of task assignment results
+     * {@link TaskAssignmentResponse}
+     * @example
+     * ```typescript
+     * // Unassign a single task
+     * const result = await sdk.tasks.unassign(<taskId>);
+     *
+     * or
+     *
+     * const task = await sdk.tasks.getById(<taskId>);
+     * const result = await task.unassign();
+     *
+     * // Unassign multiple tasks
+     * const result = await sdk.tasks.unassign([<taskId1>, <taskId2>, <taskId3>]);
+     * ```
+     */
+    unassign(taskId: number | number[]): Promise<OperationResponse<{
+        taskId: number;
+    }[] | TaskAssignmentResponse[]>>;
+    /**
+     * Completes a task with the specified type and data
+     *
+     * @param options - The completion options including task type, taskId, data, and action
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to completion result
+     * {@link TaskCompleteOptions}
+     * @example
+     * ```typescript
+     * // Complete an app task
+     * await sdk.tasks.complete({
+     *   type: TaskType.App,
+     *   taskId: <taskId>,
+     *   data: {},
+     *   action: "submit"
+     * }, <folderId>); // folderId is required
+     *
+     * // Complete an external task
+     * await sdk.tasks.complete({
+     *   type: TaskType.External,
+     *   taskId: <taskId>
+     * }, <folderId>); // folderId is required
+     * ```
+     */
+    complete(options: TaskCompletionOptions, folderId: number): Promise<OperationResponse<TaskCompletionOptions>>;
+    /**
+     * Gets users in the given folder who have Tasks.View and Tasks.Edit permissions
+     * Returns a NonPaginatedResponse with data and totalCount when no pagination parameters are provided,
+     * or a PaginatedResponse 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 either an array of users NonPaginatedResponse<UserLoginInfo> or a PaginatedResponse<UserLoginInfo> when pagination options are used.
+     * {@link UserLoginInfo}
+     * @example
+     * ```typescript
+     * // Get users from a folder
+     * const users = await sdk.tasks.getUsers(<folderId>);
+     *
+     * // Access user properties
+     * console.log(users.items[0].name);
+     * console.log(users.items[0].emailAddress);
+     * ```
+     */
+    getUsers<T extends TaskGetUsersOptions = TaskGetUsersOptions>(folderId: number, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<UserLoginInfo> : NonPaginatedResponse<UserLoginInfo>>;
+}
+interface TaskMethods {
+    /**
+     * Assigns this task to a user or users
+     *
+     * @param options - Assignment options (requires at least one of: userId, userNameOrEmail)
+     * @returns Promise resolving to task assignment results
+     */
+    assign(options: TaskAssignOptions): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Reassigns this task to a new user
+     *
+     * @param options - Assignment options (requires at least one of: userId, userNameOrEmail)
+     * @returns Promise resolving to task assignment results
+     */
+    reassign(options: TaskAssignOptions): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Unassigns this task (removes current assignee)
+     *
+     * @returns Promise resolving to task assignment results
+     */
+    unassign(): Promise<OperationResponse<{
+        taskId: number;
+    }[] | TaskAssignmentResponse[]>>;
+    /**
+     * Completes this task with optional data and action
+     *
+     * @param options - Completion options
+     * @returns Promise resolving to completion result
+     */
+    complete(options: TaskCompleteOptions): Promise<OperationResponse<TaskCompletionOptions>>;
+}
+type TaskGetResponse = RawTaskGetResponse & TaskMethods;
+type TaskCreateResponse = RawTaskCreateResponse & TaskMethods;
+/**
+ * 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
+ */
+declare function createTaskWithMethods(taskData: RawTaskGetResponse | RawTaskCreateResponse, service: TaskServiceModel): TaskGetResponse | TaskCreateResponse;
+
+/**
+ * Service model for managing Maestro Case Instances
+ *
+ * Maestro case instances are the running instances of Maestro cases.
+ */
+interface CaseInstancesServiceModel {
+    /**
+     * Get all case instances with optional filtering and pagination
+     *
+     * @param options Query parameters for filtering instances and pagination
+     * @returns Promise resolving to either an array of case instances NonPaginatedResponse<CaseInstanceGetResponse> or a PaginatedResponse<CaseInstanceGetResponse> when pagination options are used.
+     * {@link CaseInstanceGetResponse}
+     * @example
+     * ```typescript
+     * // Get all case instances (non-paginated)
+     * const instances = await sdk.maestro.cases.instances.getAll();
+     *
+     * // Cancel/Close faulted instances using methods directly on instances
+     * for (const instance of instances.items) {
+     *   if (instance.latestRunStatus === 'Faulted') {
+     *     await instance.close({ comment: 'Closing faulted case instance' });
+     *   }
+     * }
+     *
+     * // With filtering
+     * const instances = await sdk.maestro.cases.instances.getAll({
+     *   processKey: 'MyCaseProcess'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.maestro.cases.instances.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.maestro.cases.instances.getAll({ cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getAll<T extends CaseInstanceGetAllWithPaginationOptions = CaseInstanceGetAllWithPaginationOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<CaseInstanceGetResponse> : NonPaginatedResponse<CaseInstanceGetResponse>>;
+    /**
+     * Get a specific case instance by ID
+     * @param instanceId - The case instance ID
+     * @param folderKey - Required folder key
+     * @returns Promise resolving to case instance with methods
+     * {@link CaseInstanceGetResponse}
+     * @example
+     * ```typescript
+     * // Get a specific case instance
+     * const instance = await sdk.maestro.cases.instances.getById(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     *
+     * // Access instance properties
+     * console.log(`Status: ${instance.latestRunStatus}`);
+     *
+     * ```
+     */
+    getById(instanceId: string, folderKey: string): Promise<CaseInstanceGetResponse>;
+    /**
+     * Close/Cancel a case instance
+     * @param instanceId - The ID of the instance to cancel
+     * @param folderKey - Required folder key
+     * @param options - Optional close options with comment
+     * @returns Promise resolving to operation result with instance data
+     * @example
+     * ```typescript
+     * // Close a case instance
+     * const result = await sdk.maestro.cases.instances.close(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     *
+     * or
+     *
+     * const instance = await sdk.maestro.cases.instances.getById(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     * const result = await instance.close();
+     *
+     * console.log(`Closed: ${result.success}`);
+     *
+     * // Close with a comment
+     * const result = await instance.close({
+     *   comment: 'Closing due to invalid input data'
+     * });
+     *
+     * if (result.success) {
+     *   console.log(`Instance ${result.data.instanceId} status: ${result.data.status}`);
+     * }
+     * ```
+     */
+    close(instanceId: string, folderKey: string, options?: CaseInstanceOperationOptions): Promise<OperationResponse<CaseInstanceOperationResponse>>;
+    /**
+     * 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 instance data
+     */
+    pause(instanceId: string, folderKey: string, options?: CaseInstanceOperationOptions): Promise<OperationResponse<CaseInstanceOperationResponse>>;
+    /**
+     * 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 instance data
+     */
+    resume(instanceId: string, folderKey: string, options?: CaseInstanceOperationOptions): Promise<OperationResponse<CaseInstanceOperationResponse>>;
+    /**
+     * 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
+     * {@link CaseInstanceExecutionHistoryResponse}
+     * @example
+     * ```typescript
+     * // Get execution history for a case instance
+     * const history = await sdk.maestro.cases.instances.getExecutionHistory(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     *
+     * // Access element executions
+     * if (history.elementExecutions) {
+     *   for (const execution of history.elementExecutions) {
+     *     console.log(`Element: ${execution.elementName} - Status: ${execution.status}`);
+     *   }
+     * }
+     * ```
+     */
+    getExecutionHistory(instanceId: string, folderKey: string): Promise<CaseInstanceExecutionHistoryResponse>;
+    /**
+     * Get stages and its associated tasks information for a case instance
+     * @param caseInstanceId - The ID of the case instance
+     * @param folderKey - Required folder key
+     * @returns Promise resolving to an array of case stages with their tasks and status
+     * @example
+     * ```typescript
+     * // Get stages for a case instance
+     * const stages = await sdk.maestro.cases.instances.getStages(
+     *   <caseInstanceId>,
+     *   <folderKey>
+     * );
+     *
+     * // Iterate through stages
+     * for (const stage of stages) {
+     *   console.log(`Stage: ${stage.name} - Status: ${stage.status}`);
+     *
+     *   // Check tasks in the stage
+     *   for (const taskGroup of stage.tasks) {
+     *     for (const task of taskGroup) {
+     *       console.log(`  Task: ${task.name} - Status: ${task.status}`);
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    getStages(caseInstanceId: string, folderKey: string): Promise<CaseGetStageResponse[]>;
+    /**
+     * Get human in the loop tasks associated with a case instance
+     *
+     * The method returns either:
+     * - An array of tasks (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param 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
+     * @example
+     * ```typescript
+     * // Get all tasks for a case instance (non-paginated)
+     * const tasks = await sdk.maestro.cases.instances.getActionTasks(
+     *   <caseInstanceId>,
+     * );
+     *
+     * // First page with pagination
+     * const page1 = await sdk.maestro.cases.instances.getActionTasks(
+     *   <caseInstanceId>,
+     *   { pageSize: 10 }
+     * );
+     * // Iterate through tasks
+     * for (const task of page1.items) {
+     *   console.log(`Task: ${task.title}`);
+     *   console.log(`Task: ${task.status}`);
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.maestro.cases.instances.getActionTasks(
+     *   <caseInstanceId>,
+     *   {
+     *     jumpToPage: 5,
+     *     pageSize: 10
+     *   }
+     * );
+     * ```
+     */
+    getActionTasks<T extends TaskGetAllOptions = TaskGetAllOptions>(caseInstanceId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
+}
+interface CaseInstanceMethods {
+    /**
+     * Closes/cancels this case instance
+     *
+     * @param options - Optional close options with comment
+     * @returns Promise resolving to operation result
+     */
+    close(options?: CaseInstanceOperationOptions): Promise<OperationResponse<CaseInstanceOperationResponse>>;
+    /**
+     * Pauses this case instance
+     *
+     * @param options - Optional pause options with comment
+     * @returns Promise resolving to operation result
+     */
+    pause(options?: CaseInstanceOperationOptions): Promise<OperationResponse<CaseInstanceOperationResponse>>;
+    /**
+     * Resumes this case instance
+     *
+     * @param options - Optional resume options with comment
+     * @returns Promise resolving to operation result
+     */
+    resume(options?: CaseInstanceOperationOptions): Promise<OperationResponse<CaseInstanceOperationResponse>>;
+    /**
+     * Gets execution history for this case instance
+     *
+     * @returns Promise resolving to instance execution history
+     */
+    getExecutionHistory(): Promise<CaseInstanceExecutionHistoryResponse>;
+    /**
+     * Gets stages and their associated tasks for this case instance
+     *
+     * @returns Promise resolving to an array of case stages with their tasks and status
+     */
+    getStages(): Promise<CaseGetStageResponse[]>;
+    /**
+     * Gets human in the loop tasks associated with this case instance
+     *
+     * @param options - Optional filtering and pagination options
+     * @returns Promise resolving to human in the loop tasks associated with the case instance
+     */
+    getActionTasks<T extends TaskGetAllOptions = TaskGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
+}
+type CaseInstanceGetResponse = RawCaseInstanceGetResponse & CaseInstanceMethods;
+/**
+ * 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
+ */
+declare function createCaseInstanceWithMethods(instanceData: RawCaseInstanceGetResponse, service: CaseInstancesServiceModel): CaseInstanceGetResponse;
+
+/**
+ * Service for interacting with Maestro Processes
+ */
+declare class MaestroProcessesService extends BaseService implements MaestroProcessesServiceModel {
+    private processInstancesService;
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: 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}`);
+     * }
+     *
+     * ```
+     */
+    getAll(): Promise<MaestroProcessGetAllResponse[]>;
+    /**
+     * Get incidents for a specific process
+     */
+    getIncidents(processKey: string, folderKey: string): Promise<ProcessIncidentGetResponse[]>;
+}
+
+declare class ProcessInstancesService extends BaseService implements ProcessInstancesServiceModel {
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * Get all process instances with optional filtering and pagination
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options Query parameters for filtering instances and pagination
+     * @returns Promise resolving to process instances or paginated result
+     *
+     * @example
+     * ```typescript
+     * // Get all instances (non-paginated)
+     * const instances = await sdk.maestro.processes.instances.getAll();
+     *
+     * // Cancel faulted instances using methods directly on instances
+     * for (const instance of instances.items) {
+     *   if (instance.latestRunStatus === 'Faulted') {
+     *     await instance.cancel({ comment: 'Cancelling faulted instance' });
+     *   }
+     * }
+     *
+     * // With filtering
+     * const instances = await sdk.maestro.processes.instances.getAll({
+     *   processKey: 'MyProcess'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.maestro.processes.instances.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.maestro.processes.instances.getAll({ cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getAll<T extends ProcessInstanceGetAllWithPaginationOptions = ProcessInstanceGetAllWithPaginationOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessInstanceGetResponse> : NonPaginatedResponse<ProcessInstanceGetResponse>>;
+    /**
+     * Get a process instance by ID with operation methods (cancel, pause, resume)
+     * @param id The ID of the instance to retrieve
+     * @param folderKey The folder key for authorization
+     * @returns Promise<ProcessInstanceGetResponse>
+     */
+    getById(id: string, folderKey: string): Promise<ProcessInstanceGetResponse>;
+    /**
+     * Get execution history (spans) for a process instance
+     * @param instanceId The ID of the instance to get history for
+     * @returns Promise<ProcessInstanceExecutionHistoryResponse[]>
+     */
+    getExecutionHistory(instanceId: string): Promise<ProcessInstanceExecutionHistoryResponse[]>;
+    /**
+     * Get BPMN XML file for a process instance
+     * @param instanceId The ID of the instance to get BPMN for
+     * @param folderKey The folder key for authorization
+     * @returns Promise<BpmnXmlString> The BPMN XML contents as a string
+     */
+    getBpmn(instanceId: string, folderKey: string): Promise<BpmnXmlString>;
+    /**
+     * Cancel a process instance
+     * @param instanceId The ID of the instance to cancel
+     * @param folderKey The folder key for authorization
+     * @param options Optional cancellation options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    cancel(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Pause a process instance
+     * @param instanceId The ID of the instance to pause
+     * @param folderKey The folder key for authorization
+     * @param options Optional pause options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    pause(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Resume a process instance
+     * @param instanceId The ID of the instance to resume
+     * @param folderKey The folder key for authorization
+     * @param options Optional resume options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    resume(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Parses BPMN XML to extract variable metadata from uipath:inputOutput elements
+     * @private
+     * @param bpmnXml The BPMN XML string
+     * @returns Map of variable ID to metadata
+     */
+    private parseBpmnVariables;
+    /**
+     * Extracts element names from BPMN XML and maps them to their element IDs
+     * @private
+     * @param bpmnXml The BPMN XML string
+     * @returns Map of elementId to element name
+     */
+    private getVariableSource;
+    /**
+     * Enriches global variables with metadata from BPMN
+     * @private
+     * @param globals The raw globals object from API response
+     * @param variableMetadata The parsed BPMN variable metadata
+     * @returns Array of global variables
+     */
+    private transformGlobalVariables;
+    /**
+     * Get global variables for a process instance
+     * @param instanceId The ID of the instance to get variables for
+     * @param folderKey The folder key for authorization
+     * @param options Optional options including parentElementId to filter by parent element
+     * @returns Promise<ProcessInstanceGetVariablesResponse>
+     */
+    getVariables(instanceId: string, folderKey: string, options?: ProcessInstanceGetVariablesOptions): Promise<ProcessInstanceGetVariablesResponse>;
+    /**
+     * 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[]>
+     */
+    getIncidents(instanceId: string, folderKey: string): Promise<ProcessIncidentGetResponse[]>;
+}
+
+/**
+ * Service class for Maestro Process Incidents
+ */
+declare class ProcessIncidentsService extends BaseService implements ProcessIncidentsServiceModel {
+    /**
+     * 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}`);
+     * }
+     * ```
+     */
+    getAll(): Promise<ProcessIncidentGetAllResponse[]>;
+}
+
+/**
+ * Service for interacting with UiPath Maestro Cases
+ */
+declare class CasesService extends BaseService implements CasesServiceModel {
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * Get all case management processes with their instance statistics
+     * @returns Promise resolving to array of Case objects
+     *
+     * @example
+     * ```typescript
+     * // Get all case management processes
+     * const cases = await sdk.maestro.cases.getAll();
+     *
+     * // 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}`);
+     * }
+     *
+     * ```
+     */
+    getAll(): Promise<CaseGetAllResponse[]>;
+    /**
+     * Extract a readable case name from the packageId
+     * @param packageId - The full package identifier
+     * @returns A human-readable case name
+     * @private
+     */
+    private extractCaseName;
+}
+
+declare class CaseInstancesService extends BaseService implements CaseInstancesServiceModel {
+    private taskService;
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * Get all case instances with optional filtering and pagination
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options -Query parameters for filtering instances and pagination
+     * @returns Promise resolving to case instances or paginated result
+     *
+     * @example
+     * ```typescript
+     * // Get all case instances (non-paginated)
+     * const instances = await sdk.maestro.cases.instances.getAll();
+     *
+     * // Close faulted instances using methods directly on instances
+     * for (const instance of instances.items) {
+     *   if (instance.latestRunStatus === 'Faulted') {
+     *     await instance.close({ comment: 'Closing faulted case instance' });
+     *   }
+     * }
+     *
+     * // With filtering
+     * const instances = await sdk.maestro.cases.instances.getAll({
+     *   processKey: 'MyCaseProcess'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.maestro.cases.instances.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.maestro.cases.instances.getAll({ cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getAll<T extends CaseInstanceGetAllWithPaginationOptions = CaseInstanceGetAllWithPaginationOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<CaseInstanceGetResponse> : NonPaginatedResponse<CaseInstanceGetResponse>>;
+    /**
+     * 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>
+     */
+    getById(instanceId: string, folderKey: string): Promise<CaseInstanceGetResponse>;
+    /**
+     * Enhance a single case instance with case JSON data
+     * @param instance - The case instance to enhance
+     * @returns Promise resolving to enhanced instance
+     * @private
+     */
+    private enhanceInstanceWithCaseJson;
+    /**
+     * 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
+     */
+    private enhanceInstancesWithCaseJson;
+    /**
+     * 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
+     */
+    private getCaseJson;
+    /**
+     * 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
+     */
+    close(instanceId: string, folderKey: string, options?: CaseInstanceOperationOptions): Promise<OperationResponse<CaseInstanceOperationResponse>>;
+    /**
+     * 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
+     */
+    pause(instanceId: string, folderKey: string, options?: CaseInstanceOperationOptions): Promise<OperationResponse<CaseInstanceOperationResponse>>;
+    /**
+     * 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
+     */
+    resume(instanceId: string, folderKey: string, options?: CaseInstanceOperationOptions): Promise<OperationResponse<CaseInstanceOperationResponse>>;
+    /**
+     * 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
+     * // Get execution history for a case instance
+     * const history = await sdk.maestro.cases.instances.getExecutionHistory(
+     *   'instance-id',
+     *   'folder-key'
+     * );
+     * ```
+     */
+    getExecutionHistory(instanceId: string, folderKey: string): Promise<CaseInstanceExecutionHistoryResponse>;
+    /**
+     * 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
+     */
+    getStages(caseInstanceId: string, folderKey: string): Promise<CaseGetStageResponse[]>;
+    /**
+     * Create a map of element ID to execution data
+     * @param executionHistory - The execution history response
+     * @returns Map of elementId to execution metadata
+     * @private
+     */
+    private createExecutionMap;
+    /**
+     * Create a map of binding IDs to their values
+     * @param caseJsonResponse - The case JSON response
+     * @returns Map of binding ID to binding object
+     * @private
+     */
+    private createBindingsMap;
+    /**
+     * 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
+     */
+    private resolveBinding;
+    /**
+     * 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
+     */
+    private processTasks;
+    /**
+     * 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
+     */
+    private createStageFromNode;
+    /**
+     * 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
+     */
+    getActionTasks<T extends TaskGetAllOptions = TaskGetAllOptions>(caseInstanceId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
+}
+
+/**
+ * Base service for services that need folder-specific functionality
+ */
+declare class FolderScopedService extends BaseService {
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: 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
+     */
+    protected _getByFolder<T, R = T>(endpoint: string, folderId: number, options?: Record<string, any>, transformFn?: (item: T) => R): Promise<R[]>;
+}
+
+/**
+ * Enum for Asset Value Scope
+ */
+declare enum AssetValueScope {
+    Global = "Global",
+    PerRobot = "PerRobot"
+}
+/**
  * Enum for Asset Value Type
  */
 declare enum AssetValueType {
@@ -1983,15 +3423,6 @@ interface BucketGetUriOptions extends BaseOptions {
  * Request options for getting a read URI for a file in a bucket
  */
 type BucketGetReadUriOptions = BucketGetUriOptions;
-/**
- * Request options for getting a write URI for a file in a bucket
- */
-interface BucketGetWriteUriOptions extends BucketGetUriOptions {
-    /**
-     * ContentType for S3 access policy
-     */
-    contentType?: string;
-}
 /**
  * Request options for getting files in a bucket
  */
@@ -2059,11 +3490,6 @@ interface BucketUploadFileOptions {
      * File content to upload
      */
     content: Blob | Buffer | File;
-    /**
-     * Optional MIME type of the file
-     * If not provided, it will be auto-detected
-     */
-    contentType?: string;
 }
 /**
  * Response from file upload operations
@@ -2207,14 +3633,13 @@ interface BucketServiceModel {
      *   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: <bucketId>,
      *   folderId: <folderId>,
      *   path: '/folder/example.txt',
      *   content: buffer,
-     *   contentType: 'text/plain'
      * });
      * ```
      */
@@ -2331,36 +3756,38 @@ declare class BucketService extends FolderScopedService implements BucketService
      *   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
      * });
      * ```
      */
     uploadFile(options: BucketUploadFileOptions): Promise<BucketUploadResponse>;
     /**
-     * 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'
+     * });
+     * ```
      */
-    private _determineContentType;
+    getReadUri(options: BucketGetReadUriOptions): Promise<BucketGetUriResponse>;
     /**
      * 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
      */
     private _uploadToUri;
@@ -2374,27 +3801,10 @@ declare class BucketService extends FolderScopedService implements BucketService
      * @returns Promise resolving to blob file access information
      */
     private _getUri;
-    /**
-     * 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'
-     * });
-     * ```
-     */
-    getReadUri(options: BucketGetReadUriOptions): Promise<BucketGetUriResponse>;
     /**
      * 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
      */
     private _getWriteUri;
@@ -2681,600 +4091,347 @@ interface ProcessGetResponse extends ProcessProperties, FolderProperties {
  */
 type ProcessGetAllOptions = RequestOptions & PaginationOptions & {
     /**
-     * Optional folder ID to filter processes by folder
-     */
-    folderId?: number;
-};
-/**
- * Options for getting a single process by ID
- */
-type ProcessGetByIdOptions = BaseOptions;
-
-/**
- * Service for managing and executing UiPath Automation Processes.
- *
- * Processes (also known as automations or workflows) are the core units of automation in UiPath, representing sequences of activities that perform specific business tasks. [UiPath Processes Guide](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/about-processes)
- */
-interface ProcessServiceModel {
-    /**
-     * Gets all processes across folders with optional filtering
-     * Returns a NonPaginatedResponse with data and totalCount when no pagination parameters are provided,
-     * or a PaginatedResponse when any pagination parameter is provided
-     *
-     * @param options - Query options including optional folderId and pagination options
-     * @returns Promise resolving to either an array of processes NonPaginatedResponse<ProcessGetResponse> or a PaginatedResponse<ProcessGetResponse> when pagination options are used.
-     * {@link ProcessGetResponse}
-     * @example
-     * ```typescript
-     * // Standard array return
-     * const processes = await sdk.processes.getAll();
-     *
-     * // Get processes within a specific folder
-     * const processes = await sdk.processes.getAll({
-     *   folderId: <folderId>
-     * });
-     *
-     * // Get processes with filtering
-     * const processes = await sdk.processes.getAll({
-     *   filter: "name eq 'MyProcess'"
-     * });
-     *
-     * // First page with pagination
-     * const page1 = await sdk.processes.getAll({ pageSize: 10 });
-     *
-     * // Navigate using cursor
-     * if (page1.hasNextPage) {
-     *   const page2 = await sdk.processes.getAll({ cursor: page1.nextCursor });
-     * }
-     *
-     * // Jump to specific page
-     * const page5 = await sdk.processes.getAll({
-     *   jumpToPage: 5,
-     *   pageSize: 10
-     * });
-     * ```
-     */
-    getAll<T extends ProcessGetAllOptions = ProcessGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessGetResponse> : NonPaginatedResponse<ProcessGetResponse>>;
-    /**
-     * 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
-     * {@link ProcessGetResponse}
-     * @example
-     * ```typescript
-     * // Get process by ID
-     * const process = await sdk.processes.getById(<processId>, <folderId>);
-     * ```
-     */
-    getById(id: number, folderId: number, options?: ProcessGetByIdOptions): Promise<ProcessGetResponse>;
-    /**
-     * Starts a process with the specified configuration
-     *
-     * @param request - Process start configuration
-     * @param folderId - Required folder ID
-     * @param options - Optional request options
-     * @returns Promise resolving to array of started process instances
-     * {@link ProcessStartResponse}
-     * @example
-     * ```typescript
-     * // Start a process by process key
-     * const process = await sdk.processes.start({
-     *   processKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
-     * }, <folderId>); // folderId is required
-     *
-     * // Start a process by name with specific robots
-     * const process = await sdk.processes.start({
-     *   processName: "MyProcess"
-     * }, <folderId>); // folderId is required
-     * ```
-     */
-    start(request: ProcessStartRequest, folderId: number, options?: RequestOptions): Promise<ProcessStartResponse[]>;
-}
-
-/**
- * Service for interacting with UiPath Orchestrator Processes API
- */
-declare class ProcessService extends BaseService implements ProcessServiceModel {
-    /**
-     * @hideconstructor
-     */
-    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
-    /**
-     * Gets all processes across folders with optional filtering and folder scoping
-     *
-     * 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)
-     *
-     * @param options - Query options including optional folderId
-     * @returns Promise resolving to an array of processes or paginated result
-     *
-     * @example
-     * ```typescript
-     * // Standard array return
-     * const processes = await sdk.processes.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.processes.getAll({ pageSize: 10 });
-     *
-     * // Navigate using cursor
-     * if (page1.hasNextPage) {
-     *   const page2 = await sdk.processes.getAll({ cursor: page1.nextCursor });
-     * }
-     *
-     * // Jump to specific page
-     * const page5 = await sdk.processes.getAll({
-     *   jumpToPage: 5,
-     *   pageSize: 10
-     * });
-     * ```
-     */
-    getAll<T extends ProcessGetAllOptions = ProcessGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessGetResponse> : NonPaginatedResponse<ProcessGetResponse>>;
-    /**
-     * 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
-     *
-     * @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
-     * ```
-     */
-    start(request: ProcessStartRequest, folderId: number, options?: RequestOptions): Promise<ProcessStartResponse[]>;
-    /**
-     * 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
-     *
-     * @example
-     * ```typescript
-     * // Get process by ID
-     * const process = await sdk.processes.getById(123, 456);
-     * ```
-     */
-    getById(id: number, folderId: number, options?: ProcessGetByIdOptions): Promise<ProcessGetResponse>;
-}
-
-/**
- * Interface for queue response
- */
-interface QueueGetResponse {
-    key: string;
-    name: string;
-    id: number;
-    description: string;
-    maxNumberOfRetries: number;
-    acceptAutomaticallyRetry: boolean;
-    retryAbandonedItems: boolean;
-    enforceUniqueReference: boolean;
-    encrypted: boolean;
-    specificDataJsonSchema: string | null;
-    outputDataJsonSchema: string | null;
-    analyticsDataJsonSchema: string | null;
-    createdTime: string;
-    processScheduleId: number | null;
-    slaInMinutes: number;
-    riskSlaInMinutes: number;
-    releaseId: number | null;
-    isProcessInCurrentFolder: boolean | null;
-    foldersCount: number;
-    folderId: number;
-    folderName: string;
-}
-/**
- * Options for getting queues across folders
- */
-type QueueGetAllOptions = RequestOptions & PaginationOptions & {
-    /**
-     * Optional folder ID to filter queues by folder
+     * Optional folder ID to filter processes by folder
      */
     folderId?: number;
 };
-type QueueGetByIdOptions = BaseOptions;
+/**
+ * Options for getting a single process by ID
+ */
+type ProcessGetByIdOptions = BaseOptions;
 
 /**
- * Service for managing UiPath Queues
+ * Service for managing and executing UiPath Automation Processes.
  *
- * Queues are a fundamental component of UiPath automation that enable distributed and scalable processing of work items. [UiPath Queues Guide](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/about-queues-and-transactions)
+ * Processes (also known as automations or workflows) are the core units of automation in UiPath, representing sequences of activities that perform specific business tasks. [UiPath Processes Guide](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/about-processes)
  */
-interface QueueServiceModel {
+interface ProcessServiceModel {
     /**
-     * Gets all queues across folders with optional filtering and folder scoping
+     * Gets all processes across folders with optional filtering
+     * Returns a NonPaginatedResponse with data and totalCount when no pagination parameters are provided,
+     * or a PaginatedResponse when any pagination parameter is provided
      *
-     * @signature getAll(options?) → Promise&lt;QueueGetResponse[]&gt;
-     * @param options Query options including optional folderId and pagination options
-     * @returns Promise resolving to either an array of queues NonPaginatedResponse<QueueGetResponse> or a PaginatedResponse<QueueGetResponse> when pagination options are used.
-     * {@link QueueGetResponse}
+     * @param options - Query options including optional folderId and pagination options
+     * @returns Promise resolving to either an array of processes NonPaginatedResponse<ProcessGetResponse> or a PaginatedResponse<ProcessGetResponse> when pagination options are used.
+     * {@link ProcessGetResponse}
      * @example
      * ```typescript
      * // Standard array return
-     * const queues = await sdk.queues.getAll();
+     * const processes = await sdk.processes.getAll();
      *
-     * // Get queues within a specific folder
-     * const queues = await sdk.queues.getAll({
+     * // Get processes within a specific folder
+     * const processes = await sdk.processes.getAll({
      *   folderId: <folderId>
      * });
      *
-     * // Get queues with filtering
-     * const queues = await sdk.queues.getAll({
-     *   filter: "name eq 'MyQueue'"
+     * // Get processes with filtering
+     * const processes = await sdk.processes.getAll({
+     *   filter: "name eq 'MyProcess'"
      * });
      *
      * // First page with pagination
-     * const page1 = await sdk.queues.getAll({ pageSize: 10 });
+     * const page1 = await sdk.processes.getAll({ pageSize: 10 });
      *
      * // Navigate using cursor
      * if (page1.hasNextPage) {
-     *   const page2 = await sdk.queues.getAll({ cursor: page1.nextCursor });
+     *   const page2 = await sdk.processes.getAll({ cursor: page1.nextCursor });
      * }
      *
      * // Jump to specific page
-     * const page5 = await sdk.queues.getAll({
+     * const page5 = await sdk.processes.getAll({
      *   jumpToPage: 5,
      *   pageSize: 10
      * });
      * ```
      */
-    getAll<T extends QueueGetAllOptions = QueueGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<QueueGetResponse> : NonPaginatedResponse<QueueGetResponse>>;
+    getAll<T extends ProcessGetAllOptions = ProcessGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessGetResponse> : NonPaginatedResponse<ProcessGetResponse>>;
     /**
-     * Gets a single queue by ID
+     * Gets a single process by ID
      *
-     * @param id - Queue ID
+     * @param id - Process ID
      * @param folderId - Required folder ID
-     * @returns Promise resolving to a queue definition
+     * @param options - Optional query parameters
+     * @returns Promise resolving to a single process
+     * {@link ProcessGetResponse}
      * @example
      * ```typescript
-     * // Get queue by ID
-     * const queue = await sdk.queues.getById(<queueId>, <folderId>);
+     * // Get process by ID
+     * const process = await sdk.processes.getById(<processId>, <folderId>);
      * ```
      */
-    getById(id: number, folderId: number, options?: QueueGetByIdOptions): Promise<QueueGetResponse>;
+    getById(id: number, folderId: number, options?: ProcessGetByIdOptions): Promise<ProcessGetResponse>;
+    /**
+     * Starts a process with the specified configuration
+     *
+     * @param request - Process start configuration
+     * @param folderId - Required folder ID
+     * @param options - Optional request options
+     * @returns Promise resolving to array of started process instances
+     * {@link ProcessStartResponse}
+     * @example
+     * ```typescript
+     * // Start a process by process key
+     * const process = await sdk.processes.start({
+     *   processKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+     * }, <folderId>); // folderId is required
+     *
+     * // Start a process by name with specific robots
+     * const process = await sdk.processes.start({
+     *   processName: "MyProcess"
+     * }, <folderId>); // folderId is required
+     * ```
+     */
+    start(request: ProcessStartRequest, folderId: number, options?: RequestOptions): Promise<ProcessStartResponse[]>;
 }
 
 /**
- * Service for interacting with UiPath Orchestrator Queues API
+ * Service for interacting with UiPath Orchestrator Processes API
  */
-declare class QueueService extends FolderScopedService implements QueueServiceModel {
+declare class ProcessService extends BaseService implements ProcessServiceModel {
     /**
      * @hideconstructor
      */
     constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
     /**
-     * Gets all queues 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 queues (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
-     * @returns Promise resolving to an array of queues or paginated result
+     * @returns Promise resolving to an array of processes or paginated result
      *
      * @example
      * ```typescript
      * // Standard array return
-     * const queues = await sdk.queues.getAll();
+     * const processes = await sdk.processes.getAll();
      *
-     * // Get queues within a specific folder
-     * const queues = await sdk.queues.getAll({
+     * // Get processes within a specific folder
+     * const processes = await sdk.processes.getAll({
      *   folderId: 123
      * });
      *
-     * // Get queues with filtering
-     * const queues = await sdk.queues.getAll({
-     *   filter: "name eq 'MyQueue'"
+     * // Get processes with filtering
+     * const processes = await sdk.processes.getAll({
+     *   filter: "name eq 'MyProcess'"
      * });
      *
      * // First page with pagination
-     * const page1 = await sdk.queues.getAll({ pageSize: 10 });
+     * const page1 = await sdk.processes.getAll({ pageSize: 10 });
      *
      * // Navigate using cursor
      * if (page1.hasNextPage) {
-     *   const page2 = await sdk.queues.getAll({ cursor: page1.nextCursor });
+     *   const page2 = await sdk.processes.getAll({ cursor: page1.nextCursor });
      * }
      *
      * // Jump to specific page
-     * const page5 = await sdk.queues.getAll({
+     * const page5 = await sdk.processes.getAll({
      *   jumpToPage: 5,
      *   pageSize: 10
      * });
      * ```
      */
-    getAll<T extends QueueGetAllOptions = QueueGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<QueueGetResponse> : NonPaginatedResponse<QueueGetResponse>>;
+    getAll<T extends ProcessGetAllOptions = ProcessGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessGetResponse> : NonPaginatedResponse<ProcessGetResponse>>;
     /**
-     * Gets a single queue by ID
+     * Starts a process execution (job)
      *
-     * @param id - Queue ID
+     * @param request - Process start request body
      * @param folderId - Required folder ID
-     * @returns Promise resolving to a queue definition
+     * @param options - Optional query parameters
+     * @returns Promise resolving to the created jobs
      *
      * @example
      * ```typescript
-     * // Get queue by ID
-     * const queue = await sdk.queues.getById(123, 456);
-     * ```
-     */
-    getById(id: number, folderId: number, options?: QueueGetByIdOptions): Promise<QueueGetResponse>;
-}
-
-interface UserLoginInfo {
-    name: string;
-    surname: string;
-    userName: string;
-    emailAddress: string;
-    displayName: string;
-    id: number;
-}
-declare enum TaskType {
-    Form = "FormTask",
-    External = "ExternalTask",
-    App = "AppTask"
-}
-declare enum TaskPriority {
-    Low = "Low",
-    Medium = "Medium",
-    High = "High",
-    Critical = "Critical"
-}
-declare enum TaskStatus {
-    Unassigned = "Unassigned",
-    Pending = "Pending",
-    Completed = "Completed"
-}
-declare enum TaskSlaCriteria {
-    TaskCreated = "TaskCreated",
-    TaskAssigned = "TaskAssigned",
-    TaskCompleted = "TaskCompleted"
-}
-declare enum TaskSlaStatus {
-    OverdueLater = "OverdueLater",
-    OverdueSoon = "OverdueSoon",
-    Overdue = "Overdue",
-    CompletedInTime = "CompletedInTime"
-}
-declare enum TaskSourceName {
-    Agent = "Agent",
-    Workflow = "Workflow",
-    Maestro = "Maestro",
-    Default = "Default"
-}
-interface TaskSource {
-    sourceName: TaskSourceName;
-    sourceId: string;
-    taskSourceMetadata: Record<string, unknown>;
-}
-interface TaskSlaDetail {
-    expiryTime?: string;
-    startCriteria?: TaskSlaCriteria;
-    endCriteria?: TaskSlaCriteria;
-    status?: TaskSlaStatus;
-}
-interface TaskAssignment {
-    assignee?: UserLoginInfo;
-    task?: RawTaskGetResponse;
-    id?: number;
-}
-/**
- * Base interface containing common fields shared across all task response types
- */
-interface TaskBaseResponse {
-    status: TaskStatus;
-    title: string;
-    type: TaskType;
-    priority: TaskPriority;
-    organizationUnitId: number;
-    key: string;
-    isDeleted: boolean;
-    creationTime: string;
-    creatorUserId: number;
-    id: number;
-    action: string | null;
-    assignedToUserId: number | null;
-    externalTag: string | null;
-    lastAssignedTime: string | null;
-    completionTime: string | null;
-    parentOperationId: string | null;
-    deleterUserId: number | null;
-    deletionTime: string | null;
-    lastModificationTime: string | null;
-}
-interface TaskCreateOptions {
-    title: string;
-    priority?: TaskPriority;
-}
-interface RawTaskCreateResponse extends TaskBaseResponse {
-    waitJobState: JobState | null;
-    assignedToUser: UserLoginInfo | null;
-    taskSlaDetails: TaskSlaDetail[] | null;
-    completedByUser: UserLoginInfo | null;
-    taskAssignees: UserLoginInfo[] | null;
-    processingTime: number | null;
-    data: Record<string, unknown> | null;
-}
-interface RawTaskGetResponse extends TaskBaseResponse {
-    isCompleted: boolean;
-    encrypted: boolean;
-    bulkFormLayoutId: number | null;
-    formLayoutId: number | null;
-    taskSlaDetail: TaskSlaDetail | null;
-    taskAssigneeName: string | null;
-    lastModifierUserId: number | null;
-    assignedToUser?: UserLoginInfo;
-    creatorUser?: UserLoginInfo;
-    lastModifierUser?: UserLoginInfo;
-    taskAssignments?: TaskAssignment[];
-    formLayout?: Record<string, unknown>;
-    actionLabel?: string | null;
-    taskSlaDetails?: TaskSlaDetail[] | null;
-    completedByUser?: UserLoginInfo | null;
-    taskAssignmentCriteria?: string;
-    taskAssignees?: UserLoginInfo[] | null;
-    taskSource?: TaskSource | null;
-    processingTime?: number | null;
-    data?: Record<string, unknown> | null;
-}
-interface TaskAssignmentOptions {
-    taskId: number;
-    userId: number;
-    userNameOrEmail?: string;
-}
-interface TasksUnassignOptions {
-    taskIds: number[];
-}
-interface TaskAssignmentResponse {
-    taskId?: number;
-    userId?: number;
-    errorCode?: number;
-    errorMessage?: string;
-    userNameOrEmail?: string;
-}
-interface TaskCompletionOptions {
-    taskId: number;
-    data?: any;
-    action?: string;
+     * // 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
+     * ```
+     */
+    start(request: ProcessStartRequest, folderId: number, options?: RequestOptions): Promise<ProcessStartResponse[]>;
+    /**
+     * 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
+     *
+     * @example
+     * ```typescript
+     * // Get process by ID
+     * const process = await sdk.processes.getById(123, 456);
+     * ```
+     */
+    getById(id: number, folderId: number, options?: ProcessGetByIdOptions): Promise<ProcessGetResponse>;
 }
+
 /**
- * Options for task assignment operations in the Task class
- * At least one identification parameter is required
- */
-type TaskAssignOptions = {
-    userId: number;
-    userNameOrEmail?: string;
-} | {
-    userId?: number;
-    userNameOrEmail: string;
-};
-/**
- * Options for completing a task
+ * Interface for queue response
  */
-type TaskCompleteOptions = {
-    type: TaskType.External;
-    data?: any;
-    action?: string;
-} | {
-    type: Exclude<TaskType, TaskType.External>;
-    data: any;
-    action: string;
-};
+interface QueueGetResponse {
+    key: string;
+    name: string;
+    id: number;
+    description: string;
+    maxNumberOfRetries: number;
+    acceptAutomaticallyRetry: boolean;
+    retryAbandonedItems: boolean;
+    enforceUniqueReference: boolean;
+    encrypted: boolean;
+    specificDataJsonSchema: string | null;
+    outputDataJsonSchema: string | null;
+    analyticsDataJsonSchema: string | null;
+    createdTime: string;
+    processScheduleId: number | null;
+    slaInMinutes: number;
+    riskSlaInMinutes: number;
+    releaseId: number | null;
+    isProcessInCurrentFolder: boolean | null;
+    foldersCount: number;
+    folderId: number;
+    folderName: string;
+}
 /**
- * Options for getting tasks across folders
+ * Options for getting queues across folders
  */
-type TaskGetAllOptions = RequestOptions & PaginationOptions & {
+type QueueGetAllOptions = RequestOptions & PaginationOptions & {
     /**
-     * Optional folder ID to filter tasks by folder
+     * Optional folder ID to filter queues by folder
      */
     folderId?: number;
 };
-/**
- * Query options for getting a task by ID
- */
-type TaskGetByIdOptions = BaseOptions;
-/**
- * Options for getting users with task permissions
- */
-type TaskGetUsersOptions = RequestOptions & PaginationOptions;
+type QueueGetByIdOptions = BaseOptions;
 
 /**
- * Service for managing UiPath Action Center
- *
- * Tasks are task-based automation components that can be integrated into applications and processes. They represent discrete units of work that can be triggered and monitored through the UiPath API. [UiPath Action Center Guide](https://docs.uipath.com/automation-cloud/docs/actions)
+ * Service for managing UiPath Queues
  *
-*/
-interface TaskServiceModel {
+ * Queues are a fundamental component of UiPath automation that enable distributed and scalable processing of work items. [UiPath Queues Guide](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/about-queues-and-transactions)
+ */
+interface QueueServiceModel {
     /**
-     * Gets all tasks across folders with optional filtering
+     * Gets all queues across folders with optional filtering and folder scoping
      *
-     * @param options - Query options including optional folderId and pagination options
-     * @returns Promise resolving to either an array of tasks NonPaginatedResponse<TaskGetResponse> or a PaginatedResponse<TaskGetResponse> when pagination options are used.
-     * {@link TaskGetResponse}
+     * @signature getAll(options?) → Promise&lt;QueueGetResponse[]&gt;
+     * @param options Query options including optional folderId and pagination options
+     * @returns Promise resolving to either an array of queues NonPaginatedResponse<QueueGetResponse> or a PaginatedResponse<QueueGetResponse> when pagination options are used.
+     * {@link QueueGetResponse}
+     * @example
+     * ```typescript
+     * // Standard array return
+     * const queues = await sdk.queues.getAll();
+     *
+     * // Get queues within a specific folder
+     * const queues = await sdk.queues.getAll({
+     *   folderId: <folderId>
+     * });
+     *
+     * // 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
+     * });
+     * ```
      */
-    getAll<T extends TaskGetAllOptions = TaskGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
-    getById(id: number, options?: TaskGetByIdOptions, folderId?: number): Promise<TaskGetResponse>;
-    create(options: TaskCreateOptions, folderId: number): Promise<TaskCreateResponse>;
-    assign(options: TaskAssignmentOptions | TaskAssignmentOptions[], folderId?: number): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
-    reassign(options: TaskAssignmentOptions | TaskAssignmentOptions[], folderId?: number): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
-    unassign(taskId: number | number[], folderId?: number): Promise<OperationResponse<{
-        taskId: number;
-    }[] | TaskAssignmentResponse[]>>;
-    complete(taskType: TaskType, options: TaskCompletionOptions, folderId: number): Promise<OperationResponse<TaskCompletionOptions>>;
+    getAll<T extends QueueGetAllOptions = QueueGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<QueueGetResponse> : NonPaginatedResponse<QueueGetResponse>>;
     /**
-     * Gets users in the given folder who have Tasks.View and Tasks.Edit permissions
-     * Returns a NonPaginatedResponse with data and totalCount when no pagination parameters are provided,
-     * or a PaginatedResponse when any pagination parameter is provided
+     * Gets a single queue by ID
      *
-     * @param folderId - The folder ID to get users from
-     * @param options - Optional query and pagination parameters
-     * @returns Promise resolving to NonPaginatedResponse or a paginated result
+     * @param id - Queue ID
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to a queue definition
+     * @example
+     * ```typescript
+     * // Get queue by ID
+     * const queue = await sdk.queues.getById(<queueId>, <folderId>);
+     * ```
      */
-    getUsers<T extends TaskGetUsersOptions = TaskGetUsersOptions>(folderId: number, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<UserLoginInfo> : NonPaginatedResponse<UserLoginInfo>>;
+    getById(id: number, folderId: number, options?: QueueGetByIdOptions): Promise<QueueGetResponse>;
 }
-interface TaskMethods {
+
+/**
+ * Service for interacting with UiPath Orchestrator Queues API
+ */
+declare class QueueService extends FolderScopedService implements QueueServiceModel {
     /**
-     * Assigns this task to a user or users
-     *
-     * @param options - Assignment options (requires at least one of: userId, userNameOrEmail)
-     * @returns Promise resolving to task assignment results
+     * @hideconstructor
      */
-    assign(options: TaskAssignOptions): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
     /**
-     * Reassigns this task to a new user
+     * Gets all queues across folders with optional filtering and folder scoping
      *
-     * @param options - Assignment options (requires at least one of: userId, userNameOrEmail)
-     * @returns Promise resolving to task assignment results
-     */
-    reassign(options: TaskAssignOptions): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
-    /**
-     * Unassigns this task (removes current assignee)
+     * 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)
      *
-     * @returns Promise resolving to task assignment results
+     * @param options - Query options including optional folderId
+     * @returns Promise resolving to an array of queues or paginated result
+     *
+     * @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
+     * });
+     *
+     * // 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
+     * });
+     * ```
      */
-    unassign(): Promise<OperationResponse<{
-        taskId: number;
-    }[] | TaskAssignmentResponse[]>>;
+    getAll<T extends QueueGetAllOptions = QueueGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<QueueGetResponse> : NonPaginatedResponse<QueueGetResponse>>;
     /**
-     * Completes this task with optional data and action
+     * Gets a single queue by ID
      *
-     * @param options - Completion options
-     * @returns Promise resolving to completion result
+     * @param id - Queue ID
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to a queue definition
+     *
+     * @example
+     * ```typescript
+     * // Get queue by ID
+     * const queue = await sdk.queues.getById(123, 456);
+     * ```
      */
-    complete(options: TaskCompleteOptions): Promise<OperationResponse<TaskCompletionOptions>>;
+    getById(id: number, folderId: number, options?: QueueGetByIdOptions): Promise<QueueGetResponse>;
 }
-type TaskGetResponse = RawTaskGetResponse & TaskMethods;
-type TaskCreateResponse = RawTaskCreateResponse & TaskMethods;
-/**
- * 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
- */
-declare function createTaskWithMethods(taskData: RawTaskGetResponse | RawTaskCreateResponse, service: TaskServiceModel): TaskGetResponse | TaskCreateResponse;
 
 /**
  * Service for interacting with UiPath Tasks API
@@ -3375,10 +4532,11 @@ declare class TaskService extends BaseService implements TaskServiceModel {
     getAll<T extends TaskGetAllOptions = TaskGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
     /**
      * 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
@@ -3394,7 +4552,6 @@ declare class TaskService extends BaseService implements TaskServiceModel {
      * 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
@@ -3424,12 +4581,11 @@ declare class TaskService extends BaseService implements TaskServiceModel {
      * ]);
      * ```
      */
-    assign(taskAssignments: TaskAssignmentOptions | TaskAssignmentOptions[], folderId?: number): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    assign(taskAssignments: TaskAssignmentOptions | TaskAssignmentOptions[]): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
     /**
      * 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
@@ -3459,12 +4615,11 @@ declare class TaskService extends BaseService implements TaskServiceModel {
      * ]);
      * ```
      */
-    reassign(taskAssignments: TaskAssignmentOptions | TaskAssignmentOptions[], folderId?: number): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    reassign(taskAssignments: TaskAssignmentOptions | TaskAssignmentOptions[]): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
     /**
      * 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
@@ -3476,33 +4631,34 @@ declare class TaskService extends BaseService implements TaskServiceModel {
      * const result = await sdk.tasks.unassign([123, 456, 789]);
      * ```
      */
-    unassign(taskIds: number | number[], folderId?: number): Promise<OperationResponse<{
+    unassign(taskIds: number | number[]): Promise<OperationResponse<{
         taskId: number;
     }[] | TaskAssignmentResponse[]>>;
     /**
      * 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
      * ```
      */
-    complete(completionType: TaskType, options: TaskCompletionOptions, folderId: number): Promise<OperationResponse<TaskCompletionOptions>>;
+    complete(options: TaskCompletionOptions, folderId: number): Promise<OperationResponse<TaskCompletionOptions>>;
     /**
      * Gets a form task by ID (private method)
      *
@@ -3520,6 +4676,13 @@ declare class TaskService extends BaseService implements TaskServiceModel {
      * @private
      */
     private processTaskParameters;
+    /**
+     * Adds default expand parameters to options
+     * @param options - The options object to add default expand to
+     * @returns Options with default expand parameters added
+     * @private
+     */
+    private addDefaultExpand;
 }
 
 interface BaseConfig {
@@ -3550,7 +4713,7 @@ declare class UiPath {
     constructor(config: UiPathSDKConfig);
     /**
      * 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.
      */
     initialize(): Promise<void>;
@@ -3558,6 +4721,18 @@ declare class UiPath {
      * Check if the SDK has been initialized
      */
     isInitialized(): boolean;
+    /**
+     * Check if we're in an OAuth callback state
+     */
+    isInOAuthCallback(): boolean;
+    /**
+     * Complete OAuth authentication flow (only call if isInOAuthCallback() is true)
+     */
+    completeOAuth(): Promise<boolean>;
+    /**
+     * Check if the user is authenticated (has valid token)
+     */
+    isAuthenticated(): boolean;
     /**
      * Get the current authentication token
      */
@@ -3575,6 +4750,19 @@ declare class UiPath {
              * Access to Process Instances service
              */
             instances: ProcessInstancesService;
+            /**
+             * Access to Process Incidents service
+             */
+            incidents: ProcessIncidentsService;
+        };
+        /**
+         * Access to Maestro Cases service
+         */
+        cases: CasesService & {
+            /**
+             * Access to Case Instances service
+             */
+            instances: CaseInstancesService;
         };
     };
     /**
@@ -3884,7 +5072,7 @@ declare const telemetryClient: TelemetryClient;
  * SDK Telemetry constants
  */
 declare 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";
-declare const SDK_VERSION = "1.0.0-beta.13";
+declare const SDK_VERSION = "1.0.0-beta.15";
 declare const VERSION = "Version";
 declare const SERVICE = "Service";
 declare const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -3899,5 +5087,5 @@ declare const SDK_LOGGER_NAME = "uipath-ts-sdk-telemetry";
 declare const SDK_RUN_EVENT = "Sdk.Run";
 declare const UNKNOWN = "";
 
-export { APP_NAME, AssetValueScope, AssetValueType, AuthenticationError, AuthorizationError, BucketOptions, CLOUD_CLIENT_ID, CLOUD_ORGANIZATION_NAME, CLOUD_REDIRECT_URI, CLOUD_ROLE_NAME, CLOUD_TENANT_NAME, CLOUD_URL, CONNECTION_STRING, DEFAULT_ITEMS_FIELD, DEFAULT_PAGE_SIZE, DEFAULT_TOTAL_COUNT_FIELD, DataDirectionType, EntityFieldDataType, EntityType, ErrorType, FieldDisplayType, HttpStatus, JobPriority, JobState, JobType, JoinType, MAX_PAGE_SIZE, NetworkError, NotFoundError, PackageSourceType, PackageType, RateLimitError, ReferenceType, RemoteControlAccess, RobotSize, SDK_LOGGER_NAME, SDK_RUN_EVENT, SDK_SERVICE_NAME, SDK_VERSION, SERVICE, ServerError, StartStrategy, StopStrategy, TargetFramework, TaskPriority, TaskSlaCriteria, TaskSlaStatus, TaskSourceName, TaskStatus, TaskType, UNKNOWN, UiPath, UiPathError, VERSION, ValidationError, createEntityWithMethods, createProcessInstanceWithMethods, createTaskWithMethods, getErrorDetails, getLimitedPageSize, isAuthenticationError, isAuthorizationError, isNetworkError, isNotFoundError, isRateLimitError, isServerError, isUiPathError, isValidationError, telemetryClient, track, trackEvent };
-export type { ArgumentMetadata, AssetGetAllOptions, AssetGetByIdOptions, AssetGetResponse, AssetServiceModel, BaseOptions, BlobItem, BodyOptions, BpmnXmlString, BucketGetAllOptions, BucketGetByIdOptions, BucketGetFileMetaDataOptions, BucketGetFileMetaDataResponse, BucketGetFileMetaDataWithPaginationOptions, BucketGetReadUriOptions, BucketGetResponse, BucketGetUriOptions, BucketGetUriResponse, BucketGetWriteUriOptions, BucketServiceModel, BucketUploadFileOptions, BucketUploadResponse, CollectionResponse, Config, CustomKeyValuePair, ElementMetaData, EntityDeleteOptions, EntityDeleteResponse, EntityGetRecordsByIdOptions, EntityGetResponse, EntityInsertOptions, EntityInsertResponse, EntityMethods, EntityOperationOptions, EntityOperationResponse, EntityRecord, EntityServiceModel, EntityUpdateOptions, EntityUpdateResponse, ExternalConnection, ExternalField, ExternalFieldMapping, ExternalObject, ExternalSourceFields, FailureRecord, Field, FieldDataType, FieldMetaData, FolderProperties, GlobalVariableMetaData, HasPaginationOptions, Headers, HttpMethod, JobAttachment, JobError, Machine, MaestroProcessGetAllResponse, MaestroProcessesServiceModel, NonPaginatedResponse, OperationResponse, PaginatedResponse, PaginationCursor, PaginationMetadata, PaginationMethodUnion, PaginationOptions, ProcessGetAllOptions, ProcessGetByIdOptions, ProcessGetResponse, ProcessInstanceExecutionHistoryResponse, ProcessInstanceGetAllOptions, ProcessInstanceGetAllWithPaginationOptions, ProcessInstanceGetResponse, ProcessInstanceGetVariablesOptions, ProcessInstanceGetVariablesResponse, ProcessInstanceMethods, ProcessInstanceOperationOptions, ProcessInstanceOperationResponse, ProcessInstanceRun, ProcessInstancesServiceModel, ProcessProperties, ProcessServiceModel, ProcessStartRequest, ProcessStartResponse, QueryParams, QueueGetAllOptions, QueueGetByIdOptions, QueueGetResponse, QueueServiceModel, RawEntityGetResponse, RawProcessInstanceGetResponse, RawTaskCreateResponse, RawTaskGetResponse, RequestOptions, RequestSpec, ResponseDictionary, ResponseType, RetryOptions, RobotMetadata, SourceJoinCriteria, TaskAssignOptions, TaskAssignment, TaskAssignmentOptions, TaskAssignmentResponse, TaskBaseResponse, TaskCompleteOptions, TaskCompletionOptions, TaskCreateOptions, TaskCreateResponse, TaskGetAllOptions, TaskGetByIdOptions, TaskGetResponse, TaskGetUsersOptions, TaskMethods, TaskServiceModel, TaskSlaDetail, TaskSource, TasksUnassignOptions, TimeoutOptions, UserLoginInfo };
+export { APP_NAME, AssetValueScope, AssetValueType, AuthenticationError, AuthorizationError, BucketOptions, CLOUD_CLIENT_ID, CLOUD_ORGANIZATION_NAME, CLOUD_REDIRECT_URI, CLOUD_ROLE_NAME, CLOUD_TENANT_NAME, CLOUD_URL, CONNECTION_STRING, DEFAULT_ITEMS_FIELD, DEFAULT_PAGE_SIZE, DEFAULT_TOTAL_COUNT_FIELD, DataDirectionType, DebugMode, EntityFieldDataType, EntityType, ErrorType, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, FieldDisplayType, HttpStatus, JobPriority, JobState, JobType, JoinType, MAX_PAGE_SIZE, NetworkError, NotFoundError, PackageSourceType, PackageType, ProcessIncidentSeverity, ProcessIncidentStatus, ProcessIncidentType, RateLimitError, ReferenceType, RemoteControlAccess, RobotSize, SDK_LOGGER_NAME, SDK_RUN_EVENT, SDK_SERVICE_NAME, SDK_VERSION, SERVICE, SLADurationUnit, ServerError, StageTaskType, StartStrategy, StopStrategy, TargetFramework, TaskActivityType, TaskPriority, TaskSlaCriteria, TaskSlaStatus, TaskSourceName, TaskStatus, TaskType, UNKNOWN, UiPath, UiPathError, VERSION, ValidationError, createCaseInstanceWithMethods, createEntityWithMethods, createProcessInstanceWithMethods, createProcessWithMethods, createTaskWithMethods, getErrorDetails, getLimitedPageSize, isAuthenticationError, isAuthorizationError, isNetworkError, isNotFoundError, isRateLimitError, isServerError, isUiPathError, isValidationError, telemetryClient, track, trackEvent };
+export type { ArgumentMetadata, AssetGetAllOptions, AssetGetByIdOptions, AssetGetResponse, AssetServiceModel, BaseConfig, BaseOptions, BlobItem, BodyOptions, BpmnXmlString, BucketGetAllOptions, BucketGetByIdOptions, BucketGetFileMetaDataOptions, BucketGetFileMetaDataResponse, BucketGetFileMetaDataWithPaginationOptions, BucketGetReadUriOptions, BucketGetResponse, BucketGetUriOptions, BucketGetUriResponse, BucketServiceModel, BucketUploadFileOptions, BucketUploadResponse, CaseAppConfig, CaseAppOverview, CaseGetAllResponse, CaseGetStageResponse, CaseInstanceExecutionHistoryResponse, CaseInstanceGetAllOptions, CaseInstanceGetAllWithPaginationOptions, CaseInstanceGetResponse, CaseInstanceMethods, CaseInstanceOperationOptions, CaseInstanceOperationResponse, CaseInstanceRun, CaseInstancesServiceModel, CasesServiceModel, CollectionResponse, CustomKeyValuePair, ElementExecutionMetadata, ElementMetaData, ElementRunMetadata, EntityDeleteOptions, EntityDeleteResponse, EntityGetRecordsByIdOptions, EntityGetResponse, EntityInsertOptions, EntityInsertResponse, EntityMethods, EntityOperationOptions, EntityOperationResponse, EntityRecord, EntityServiceModel, EntityUpdateOptions, EntityUpdateResponse, EscalationAction, EscalationRecipient, EscalationRule, EscalationTriggerMetadata, ExternalConnection, ExternalField, ExternalFieldMapping, ExternalObject, ExternalSourceFields, FailureRecord, Field, FieldDataType, FieldMetaData, FolderProperties, GlobalVariableMetaData, HasPaginationOptions, Headers, HttpMethod, JobAttachment, JobError, Machine, MaestroProcessGetAllResponse, MaestroProcessesServiceModel, NonPaginatedResponse, OAuthFields, OperationResponse, PaginatedResponse, PaginationCursor, PaginationMetadata, PaginationMethodUnion, PaginationOptions, ProcessGetAllOptions, ProcessGetByIdOptions, ProcessGetResponse, ProcessIncidentGetAllResponse, ProcessIncidentGetResponse, ProcessIncidentsServiceModel, ProcessInstanceExecutionHistoryResponse, ProcessInstanceGetAllOptions, ProcessInstanceGetAllWithPaginationOptions, ProcessInstanceGetResponse, ProcessInstanceGetVariablesOptions, ProcessInstanceGetVariablesResponse, ProcessInstanceMethods, ProcessInstanceOperationOptions, ProcessInstanceOperationResponse, ProcessInstanceRun, ProcessInstancesServiceModel, ProcessMethods, ProcessProperties, ProcessServiceModel, ProcessStartRequest, ProcessStartResponse, QueryParams, QueueGetAllOptions, QueueGetByIdOptions, QueueGetResponse, QueueServiceModel, RawCaseInstanceGetResponse, RawEntityGetResponse, RawMaestroProcessGetAllResponse, RawProcessInstanceGetResponse, RawTaskCreateResponse, RawTaskGetResponse, RequestOptions, RequestSpec, ResponseDictionary, ResponseType, RetryOptions, RobotMetadata, SourceJoinCriteria, StageSLA, StageTask, Tag, TaskActivity, TaskAssignOptions, TaskAssignment, TaskAssignmentOptions, TaskAssignmentResponse, TaskBaseResponse, TaskCompleteOptions, TaskCompletionOptions, TaskCreateOptions, TaskCreateResponse, TaskGetAllOptions, TaskGetByIdOptions, TaskGetResponse, TaskGetUsersOptions, TaskMethods, TaskServiceModel, TaskSlaDetail, TaskSource, TasksUnassignOptions, TimeoutOptions, UiPathSDKConfig, UserLoginInfo };