@uipath/uipath-typescript 1.0.0-beta.18 → 1.0.0

package/dist/cases/index.d.ts

@@ -0,0 +1,1397 @@
+import { IUiPath } from '../core/index';
+
+/**
+ * Simplified universal pagination cursor
+ * Used to fetch next/previous pages
+ */
+interface PaginationCursor {
+    /** Opaque string containing all information needed to fetch next page */
+    value: string;
+}
+/**
+ * Discriminated union for pagination methods - ensures cursor and jumpToPage are mutually exclusive
+ */
+type PaginationMethodUnion = {
+    cursor?: PaginationCursor;
+    jumpToPage?: never;
+} | {
+    cursor?: never;
+    jumpToPage?: number;
+} | {
+    cursor?: never;
+    jumpToPage?: never;
+};
+/**
+ * Pagination options. Users cannot specify both cursor and jumpToPage.
+ */
+type PaginationOptions = {
+    /** Size of the page to fetch (items per page) */
+    pageSize?: number;
+} & PaginationMethodUnion;
+/**
+ * Paginated response containing items and navigation information
+ */
+interface PaginatedResponse<T> {
+    /** The items in the current page */
+    items: T[];
+    /** Total count of items across all pages (if available) */
+    totalCount?: number;
+    /** Whether more pages are available */
+    hasNextPage: boolean;
+    /** Cursor to fetch the next page (if available) */
+    nextCursor?: PaginationCursor;
+    /** Cursor to fetch the previous page (if available) */
+    previousCursor?: PaginationCursor;
+    /** Current page number (1-based, if available) */
+    currentPage?: number;
+    /** Total number of pages (if available) */
+    totalPages?: number;
+    /** Whether this pagination type supports jumping to arbitrary pages */
+    supportsPageJump: boolean;
+}
+/**
+ * Response for non-paginated calls that includes both data and total count
+ */
+interface NonPaginatedResponse<T> {
+    items: T[];
+    totalCount?: number;
+}
+/**
+ * Helper type for defining paginated method overloads
+ * Creates a union type of all ways pagination can be triggered
+ */
+type HasPaginationOptions<T> = (T & {
+    pageSize: number;
+}) | (T & {
+    cursor: PaginationCursor;
+}) | (T & {
+    jumpToPage: number;
+});
+
+/**
+ * Standardized result interface for all operation methods (pause, cancel, complete, update, upload, etc.)
+ * Success responses include data from the request context or API response
+ */
+interface OperationResponse<TData> {
+    /**
+     * Whether the operation was successful
+     */
+    success: boolean;
+    /**
+     * Response data (can contain error details in case of failure)
+     */
+    data: TData;
+}
+interface BaseOptions {
+    expand?: string;
+    select?: string;
+}
+/**
+ * Common request options interface used across services for querying data
+ */
+interface RequestOptions extends BaseOptions {
+    filter?: string;
+    orderby?: string;
+}
+
+/**
+ * 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.
+ *
+ * ### Usage
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ```typescript
+ * import { Cases } from '@uipath/uipath-typescript/cases';
+ *
+ * const cases = new Cases(sdk);
+ * const allCases = await cases.getAll();
+ * ```
+ */
+interface CasesServiceModel {
+    /**
+     * @returns Promise resolving to array of Case objects
+     * {@link CaseGetAllResponse}
+     * @example
+     * ```typescript
+     * // Get all case management processes
+     * const allCases = await cases.getAll();
+     *
+     * // Access case information
+     * for (const caseProcess of allCases) {
+     *   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;
+}
+/**
+ * Options for reopening a case instance.
+ */
+interface CaseInstanceReopenOptions extends CaseInstanceOperationOptions {
+    /**
+     * The stage ID from which the case instance should be reopened.
+     */
+    stageId: 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;
+    createdTime: 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;
+    createdTime: string;
+    id: number;
+    action: string | null;
+    externalTag: string | null;
+    lastAssignedTime: string | null;
+    completedTime: string | null;
+    parentOperationId: string | null;
+    deleterUserId: number | null;
+    deletedTime: string | null;
+    lastModifiedTime: string | 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 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;
+    /**
+     * Optional flag to fetch tasks using admin permissions
+     * When true, fetches tasks across folders
+     * where the user has at least Task.View, Task.Edit and TaskAssignment.Create permissions
+     * When false or omitted, fetches tasks across folders
+     * where the user has at least Task.View and Task.Edit permissions
+     */
+    asTaskAdmin?: boolean;
+};
+
+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;
+
+/**
+ * Service model for managing Maestro Case Instances
+ *
+ * Maestro case instances are the running instances of Maestro cases.
+ *
+ * ### Usage
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ```typescript
+ * import { CaseInstances } from '@uipath/uipath-typescript/cases';
+ *
+ * const caseInstances = new CaseInstances(sdk);
+ * const allInstances = await caseInstances.getAll();
+ * ```
+ */
+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 caseInstances.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 filteredInstances = await caseInstances.getAll({
+     *   processKey: 'MyCaseProcess'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await caseInstances.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await caseInstances.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 caseInstances.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 caseInstances.close(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     *
+     * // Or using instance method
+     * const instance = await caseInstances.getById(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     * const result = await instance.close();
+     *
+     * console.log(`Closed: ${result.success}`);
+     *
+     * // Close with a comment
+     * const resultWithComment = await instance.close({
+     *   comment: 'Closing due to invalid input data'
+     * });
+     *
+     * if (resultWithComment.success) {
+     *   console.log(`Instance ${resultWithComment.data.instanceId} status: ${resultWithComment.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>>;
+    /**
+     * Reopen a case instance from a specified element
+     * @param instanceId - The ID of the case instance
+     * @param folderKey - Required folder key
+     * @param options - Reopen options containing stageId (the stage ID to resume from) and an optional comment
+     * @returns Promise resolving to operation result with instance data
+     * {@link CaseInstanceOperationResponse}
+     * @example
+     * ```typescript
+     * import { CaseInstances } from '@uipath/uipath-typescript/cases';
+     *
+     * const caseInstances = new CaseInstances(sdk);
+     *
+     * // First, get the available stages for the case instance
+     * const stages = await caseInstances.getStages('<instanceId>', '<folderKey>');
+     * const stageId = stages[0].id; // Select the stage to reopen from
+     *
+     * // Reopen a case instance from a specific stage
+     * const result = await caseInstances.reopen(
+     *   '<instanceId>',
+     *   '<folderKey>',
+     *   { stageId }
+     * );
+     *
+     * // Reopen with a comment
+     * const result = await caseInstances.reopen(
+     *   '<instanceId>',
+     *   '<folderKey>',
+     *   { stageId, comment: 'Reopening to retry failed stage' }
+     * );
+     *
+     * // Or using instance method
+     * const instance = await caseInstances.getById('<instanceId>', '<folderKey>');
+     * const stages = await instance.getStages();
+     * const result = await instance.reopen({ stageId: stages[0].id });
+     * ```
+     */
+    reopen(instanceId: string, folderKey: string, options: CaseInstanceReopenOptions): 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 caseInstances.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 caseInstances.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 actionTasks = await caseInstances.getActionTasks(
+     *   <caseInstanceId>,
+     * );
+     *
+     * // First page with pagination
+     * const page1 = await caseInstances.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 caseInstances.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>>;
+    /**
+     * Reopens this case instance from a specified element
+     *
+     * @param options - Reopen options containing stageId (the stage ID to resume from) and an optional comment
+     * @returns Promise resolving to operation result
+     */
+    reopen(options: CaseInstanceReopenOptions): 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;
+
+/**
+ * Pagination types supported by the SDK
+ */
+declare enum PaginationType {
+    OFFSET = "offset",
+    TOKEN = "token"
+}
+/**
+ * Interface for service access methods needed by pagination helpers
+ */
+interface PaginationServiceAccess {
+    get<T>(path: string, options?: any): Promise<{
+        data: T;
+    }>;
+    post<T>(path: string, body?: any, options?: any): Promise<{
+        data: T;
+    }>;
+    requestWithPagination<T>(method: string, path: string, paginationOptions: PaginationOptions, options: RequestWithPaginationOptions): Promise<PaginatedResponse<T>>;
+}
+/**
+ * Field names for extracting data from paginated responses.
+ */
+interface PaginationFieldNames {
+    itemsField?: string;
+    totalCountField?: string;
+    continuationTokenField?: string;
+}
+/**
+ * Options for the requestWithPagination method in BaseService.
+ */
+interface RequestWithPaginationOptions extends RequestSpec {
+    pagination: PaginationFieldNames & {
+        paginationType: PaginationType;
+        paginationParams?: {
+            pageSizeParam?: string;
+            offsetParam?: string;
+            tokenParam?: string;
+            countParam?: string;
+        };
+    };
+}
+
+/**
+ * HTTP methods supported by the API client
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+/**
+ * Supported response types for API requests
+ */
+type ResponseType = 'json' | 'text' | 'blob' | 'arraybuffer' | 'stream';
+/**
+ * Query parameters type with support for arrays and nested objects
+ */
+type QueryParams = Record<string, string | number | boolean | Array<string | number | boolean> | null | undefined>;
+/**
+ * Standard HTTP headers type
+ */
+type Headers = Record<string, string>;
+/**
+ * Options for request retries
+ */
+interface RetryOptions {
+    /** Maximum number of retry attempts */
+    maxRetries?: number;
+    /** Base delay between retries in milliseconds */
+    retryDelay?: number;
+    /** Whether to use exponential backoff */
+    useExponentialBackoff?: boolean;
+    /** Status codes that should trigger a retry */
+    retryableStatusCodes?: number[];
+}
+/**
+ * Options for request timeouts
+ */
+interface TimeoutOptions {
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Whether to abort the request on timeout */
+    abortOnTimeout?: boolean;
+}
+/**
+ * Options for request body transformation
+ */
+interface BodyOptions {
+    /** Whether to stringify the body */
+    stringify?: boolean;
+    /** Content type override */
+    contentType?: string;
+}
+/**
+ * Pagination metadata for API requests
+ */
+interface PaginationMetadata {
+    /** Type of pagination used by the API endpoint */
+    paginationType: PaginationType;
+    /** Response field containing items array (defaults to 'value') */
+    itemsField?: string;
+    /** Response field containing total count (defaults to '@odata.count') */
+    totalCountField?: string;
+    /** Response field containing continuation token (defaults to 'continuationToken') */
+    continuationTokenField?: string;
+}
+/**
+ * Base interface for all API requests
+ */
+interface RequestSpec {
+    /** HTTP method for the request */
+    method?: HttpMethod;
+    /** URL endpoint for the request */
+    url?: string;
+    /** Query parameters to be appended to the URL */
+    params?: QueryParams;
+    /** HTTP headers to include with the request */
+    headers?: Headers;
+    /** Raw body content (takes precedence over data) */
+    body?: unknown;
+    /** Expected response type */
+    responseType?: ResponseType;
+    /** Request timeout options */
+    timeoutOptions?: TimeoutOptions;
+    /** Retry behavior options */
+    retryOptions?: RetryOptions;
+    /** Body transformation options */
+    bodyOptions?: BodyOptions;
+    /** AbortSignal for cancelling the request */
+    signal?: AbortSignal;
+    /** Pagination metadata for the request */
+    pagination?: PaginationMetadata;
+}
+
+interface ApiResponse<T> {
+    data: T;
+}
+/**
+ * Base class for all UiPath SDK services.
+ *
+ * Provides common functionality for authentication, configuration, and API communication.
+ * All service classes extend this base to inherit dependency injection and HTTP client access.
+ *
+ * This class implements the dependency injection pattern where services receive a configured
+ * UiPath instance. The ApiClient is created internally and handles all HTTP operations
+ * including authentication token management.
+ *
+ * @remarks
+ * Service classes should extend this base and call `super(uiPath)` in their constructor.
+ * Protected HTTP methods (get, post, put, patch, delete) are available to all subclasses.
+ *
+ */
+declare class BaseService {
+    #private;
+    /**
+     * Creates a base service instance with dependency injection.
+     *
+     * Extracts configuration, execution context, and token manager from the UiPath instance
+     * to initialize an authenticated API client. The ApiClient handles all HTTP operations
+     * and token management internally.
+     *
+     * @param instance - UiPath SDK instance providing authentication and configuration.
+     *                    Services receive this via dependency injection in the modular pattern.
+     *
+     * @example
+     * ```typescript
+     * // Services automatically call this via super()
+     * export class EntityService extends BaseService {
+     *   constructor(instance: IUiPath) {
+     *     super(instance); // Initializes the internal ApiClient
+     *   }
+     * }
+     *
+     * // Usage in modular pattern
+     * import { UiPath } from '@uipath/uipath-typescript/core';
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const sdk = new UiPath(config);
+     * await sdk.initialize();
+     * const entities = new Entities(sdk);
+     * ```
+     */
+    constructor(instance: IUiPath);
+    /**
+     * Gets a valid authentication token, refreshing if necessary.
+     * Use this when you need to manually add Authorization headers (e.g., direct uploads).
+     *
+     * @returns Promise resolving to a valid access token string
+     * @throws AuthenticationError if no token is available or refresh fails
+     */
+    protected getValidAuthToken(): Promise<string>;
+    /**
+     * Creates a service accessor for pagination helpers
+     * This allows pagination helpers to access protected methods without making them public
+     */
+    protected createPaginationServiceAccess(): PaginationServiceAccess;
+    protected request<T>(method: string, path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected requestWithSpec<T>(spec: RequestSpec): Promise<ApiResponse<T>>;
+    protected get<T>(path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected post<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected put<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected patch<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected delete<T>(path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
+    /**
+     * Execute a request with cursor-based pagination
+     */
+    protected requestWithPagination<T>(method: string, path: string, paginationOptions: PaginationOptions, options: RequestWithPaginationOptions): Promise<PaginatedResponse<T>>;
+    /**
+     * Validates and prepares pagination parameters from options
+     */
+    private validateAndPreparePaginationParams;
+    /**
+     * Prepares request parameters for pagination based on pagination type
+     */
+    private preparePaginationRequestParams;
+    /**
+     * Creates a paginated response from API response
+     */
+    private createPaginatedResponseFromResponse;
+    /**
+     * Determines if there are more pages based on pagination type and metadata
+     */
+    private determineHasMorePages;
+}
+
+/**
+ * Service for interacting with UiPath Maestro Cases
+ */
+declare class CasesService extends BaseService implements CasesServiceModel {
+    /**
+     * Get all case management processes with their instance statistics
+     * @returns Promise resolving to array of Case objects
+     *
+     * @example
+     * ```typescript
+     * import { Cases } from '@uipath/uipath-typescript/cases';
+     *
+     * const cases = new Cases(sdk);
+     * const allCases = await cases.getAll();
+     *
+     * // Access case information
+     * for (const caseProcess of allCases) {
+     *   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;
+    /**
+     * Creates an instance of the Case Instances service.
+     *
+     * @param instance - UiPath SDK instance providing authentication and configuration
+     */
+    constructor(instance: IUiPath);
+    /**
+     * 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
+     * import { CaseInstances } from '@uipath/uipath-typescript/cases';
+     *
+     * const caseInstances = new CaseInstances(sdk);
+     *
+     * // Get all case instances (non-paginated)
+     * const instances = await caseInstances.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 filtered = await caseInstances.getAll({
+     *   processKey: 'MyCaseProcess'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await caseInstances.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await caseInstances.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, reopen)
+     * @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>>;
+    /**
+     * Reopen a case instance from a specified element
+     * @param instanceId - The ID of the case instance to reopen
+     * @param folderKey - Required folder key
+     * @param options - Reopen options containing stageId (the stage ID to resume from) and an optional comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    reopen(instanceId: string, folderKey: string, options: CaseInstanceReopenOptions): 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
+     * import { CaseInstances } from '@uipath/uipath-typescript/cases';
+     *
+     * const caseInstances = new CaseInstances(sdk);
+     * const history = await caseInstances.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>>;
+}
+
+export { CaseInstancesService as CaseInstances, CaseInstancesService, CasesService as Cases, CasesService, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, SLADurationUnit, StageTaskType, createCaseInstanceWithMethods };
+export type { CaseAppConfig, CaseAppOverview, CaseGetAllResponse, CaseGetStageResponse, CaseInstanceExecutionHistoryResponse, CaseInstanceGetAllOptions, CaseInstanceGetAllWithPaginationOptions, CaseInstanceGetResponse, CaseInstanceMethods, CaseInstanceOperationOptions, CaseInstanceOperationResponse, CaseInstanceReopenOptions, CaseInstanceRun, CaseInstancesServiceModel, CasesServiceModel, ElementExecutionMetadata, ElementRunMetadata, EscalationAction, EscalationRecipient, EscalationRule, EscalationTriggerMetadata, RawCaseInstanceGetResponse, StageSLA, StageTask };