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

package/dist/index.d.ts

@@ -1569,6 +1569,842 @@ type ProcessInstanceGetResponse = RawProcessInstanceGetResponse & ProcessInstanc
  */
 declare function createProcessInstanceWithMethods(instanceData: RawProcessInstanceGetResponse, service: ProcessInstancesServiceModel): ProcessInstanceGetResponse;
 
+/**
+ * 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 {
+    /**
+     * @returns Promise resolving to array of Case objects
+     * {@link CaseGetAllResponse}
+     * @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[]>;
+}
+
+/**
+ * Case Instance Types
+ * Types and interfaces for Maestro case instance management
+ */
+
+/**
+ * Response for getting a single case instance
+ */
+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;
+    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[];
+    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;
+}
+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;
+}
+/**
+ * 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
+ */
+type TaskCompleteOptions = {
+    type: TaskType.External;
+    data?: any;
+    action?: string;
+} | {
+    type: Exclude<TaskType, TaskType.External>;
+    data: any;
+    action: string;
+};
+/**
+ * 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}
+     */
+    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>>;
+    /**
+     * 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 NonPaginatedResponse or a paginated result
+     */
+    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>
+     * );
+     *
+     * if (result.success) {
+     *   console.log(`Instance ${result.data.instanceId} now has status: ${result.data.status}`);
+     * }
+     *
+     * // Close with a comment
+     * const result = await sdk.maestro.cases.instances.close(
+     *   <instanceId>,
+     *   <folderKey>,
+     *   { comment: <comment> }
+     * );
+     *
+     * // Close multiple faulted instances
+     * const instances = await sdk.maestro.cases.instances.getAll({
+     *   latestRunStatus: "Faulted"
+     * });
+     *
+     * for (const instance of instances.items) {
+     *   const result = await sdk.maestro.cases.instances.close(
+     *     instance.instanceId,
+     *     instance.folderKey,
+     *     { comment: <comment> }
+     *   );
+     *
+     *   if (result.success) {
+     *     console.log(`Closed instance: ${result.data.instanceId}`);
+     *   }
+     * }
+     * ```
+     */
+    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>>;
+}
+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
  */
@@ -1667,53 +2503,256 @@ declare class ProcessInstancesService extends BaseService implements ProcessInst
      * @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>>;
+    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>;
+}
+
+/**
+ * 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 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
+     * 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?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    pause(instanceId: string, folderKey: string, options?: CaseInstanceOperationOptions): Promise<OperationResponse<CaseInstanceOperationResponse>>;
     /**
-     * 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
+     * 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?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    resume(instanceId: string, folderKey: string, options?: CaseInstanceOperationOptions): Promise<OperationResponse<CaseInstanceOperationResponse>>;
     /**
-     * Parses BPMN XML to extract variable metadata from uipath:inputOutput elements
+     * 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
-     * @param bpmnXml The BPMN XML string
-     * @returns Map of variable ID to metadata
      */
-    private parseBpmnVariables;
+    private createExecutionMap;
     /**
-     * Extracts element names from BPMN XML and maps them to their element IDs
+     * Create a map of binding IDs to their values
+     * @param caseJsonResponse - The case JSON response
+     * @returns Map of binding ID to binding object
      * @private
-     * @param bpmnXml The BPMN XML string
-     * @returns Map of elementId to element name
      */
-    private getVariableSource;
+    private createBindingsMap;
     /**
-     * Enriches global variables with metadata from BPMN
+     * 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
-     * @param globals The raw globals object from API response
-     * @param variableMetadata The parsed BPMN variable metadata
-     * @returns Array of global variables
      */
-    private transformGlobalVariables;
+    private resolveBinding;
     /**
-     * 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>
+     * 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
      */
-    getVariables(instanceId: string, folderKey: string, options?: ProcessInstanceGetVariablesOptions): Promise<ProcessInstanceGetVariablesResponse>;
+    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>>;
 }
 
 /**
@@ -2688,593 +3727,340 @@ type ProcessGetAllOptions = RequestOptions & PaginationOptions & {
 /**
  * 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
-     */
-    folderId?: number;
-};
-type QueueGetByIdOptions = BaseOptions;
+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
@@ -3550,7 +4336,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 +4344,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
      */
@@ -3576,6 +4374,15 @@ declare class UiPath {
              */
             instances: ProcessInstancesService;
         };
+        /**
+         * Access to Maestro Cases service
+         */
+        cases: CasesService & {
+            /**
+             * Access to Case Instances service
+             */
+            instances: CaseInstancesService;
+        };
     };
     /**
      * Access to Entity service
@@ -3884,7 +4691,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.14";
 declare const VERSION = "Version";
 declare const SERVICE = "Service";
 declare const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -3899,5 +4706,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, EntityFieldDataType, EntityType, ErrorType, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, 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, SLADurationUnit, ServerError, StageTaskType, StartStrategy, StopStrategy, TargetFramework, TaskActivityType, TaskPriority, TaskSlaCriteria, TaskSlaStatus, TaskSourceName, TaskStatus, TaskType, UNKNOWN, UiPath, UiPathError, VERSION, ValidationError, createCaseInstanceWithMethods, createEntityWithMethods, createProcessInstanceWithMethods, 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, BucketGetWriteUriOptions, 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, ProcessInstanceExecutionHistoryResponse, ProcessInstanceGetAllOptions, ProcessInstanceGetAllWithPaginationOptions, ProcessInstanceGetResponse, ProcessInstanceGetVariablesOptions, ProcessInstanceGetVariablesResponse, ProcessInstanceMethods, ProcessInstanceOperationOptions, ProcessInstanceOperationResponse, ProcessInstanceRun, ProcessInstancesServiceModel, ProcessProperties, ProcessServiceModel, ProcessStartRequest, ProcessStartResponse, QueryParams, QueueGetAllOptions, QueueGetByIdOptions, QueueGetResponse, QueueServiceModel, RawCaseInstanceGetResponse, RawEntityGetResponse, 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 };