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

package/dist/maestro-processes/index.d.ts

@@ -0,0 +1,1127 @@
+import { IUiPath } from '../core/index';
+
+/**
+ * Maestro Process Types
+ * Types and interfaces for Maestro process management
+ */
+/**
+ * Process information with instance statistics
+ */
+interface RawMaestroProcessGetAllResponse {
+    /** Unique key identifying the process */
+    processKey: string;
+    /** Package identifier */
+    packageId: string;
+    /** Process name */
+    name: string;
+    /** Folder key where process is located */
+    folderKey: string;
+    /** Folder name */
+    folderName: string;
+    /** Available package versions */
+    packageVersions: string[];
+    /** Total number of versions */
+    versionCount: number;
+    /** Process instance count - pending */
+    pendingCount: number;
+    /** Process instance count - running */
+    runningCount: number;
+    /** Process instance count - completed */
+    completedCount: number;
+    /** Process instance count - paused */
+    pausedCount: number;
+    /** Process instance count - cancelled */
+    cancelledCount: number;
+    /** Process instance count - faulted */
+    faultedCount: number;
+    /** Process instance count - retrying */
+    retryingCount: number;
+    /** Process instance count - resuming */
+    resumingCount: number;
+    /** Process instance count - pausing */
+    pausingCount: number;
+    /** Process instance count - canceling */
+    cancelingCount: number;
+}
+
+/**
+ * Process Incident Status
+ */
+declare enum ProcessIncidentStatus {
+    Open = "Open",
+    Closed = "Closed"
+}
+/**
+ * Process Incident Type
+ */
+declare enum ProcessIncidentType {
+    System = "System",
+    User = "User",
+    Deployment = "Deployment"
+}
+/**
+ * Process Incident Severity
+ */
+declare enum ProcessIncidentSeverity {
+    Error = "Error",
+    Warning = "Warning"
+}
+/**
+ * Process Incident Debug Mode
+ */
+declare enum DebugMode {
+    None = "None",
+    Default = "Default",
+    StepByStep = "StepByStep",
+    SingleStep = "SingleStep"
+}
+/**
+ * Process Incident Get Response
+ */
+interface ProcessIncidentGetResponse {
+    instanceId: string;
+    elementId: string;
+    folderKey: string;
+    processKey: string;
+    incidentId: string;
+    incidentStatus: ProcessIncidentStatus;
+    incidentType: ProcessIncidentType | null;
+    errorCode: string;
+    errorMessage: string;
+    errorTime: string;
+    errorDetails: string;
+    debugMode: DebugMode;
+    incidentSeverity: ProcessIncidentSeverity | null;
+    incidentElementActivityType: string;
+    incidentElementActivityName: string;
+}
+/**
+ * Process Incident Summary Get Response
+ */
+interface ProcessIncidentGetAllResponse {
+    count: number;
+    errorMessage: string;
+    errorCode: string;
+    firstOccuranceTime: string;
+    processKey: string;
+}
+
+/**
+ * Maestro Process Models
+ * Model classes for Maestro processes
+ */
+
+/**
+ * Service for managing UiPath Maestro Processes
+ *
+ * UiPath Maestro is a cloud-native orchestration layer that coordinates bots, AI agents, and humans for seamless, intelligent automation of complex workflows. [UiPath Maestro Guide](https://docs.uipath.com/maestro/automation-cloud/latest/user-guide/introduction-to-maestro)
+ *
+ * ### Usage
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ```typescript
+ * import { MaestroProcesses } from '@uipath/uipath-typescript/maestro-processes';
+ *
+ * const maestroProcesses = new MaestroProcesses(sdk);
+ * const allProcesses = await maestroProcesses.getAll();
+ * ```
+ */
+interface MaestroProcessesServiceModel {
+    /**
+     * @returns Promise resolving to array of MaestroProcess objects with methods
+     * {@link MaestroProcessGetAllResponse}
+     * @example
+     * ```typescript
+     * // Get all processes
+     * const allProcesses = await maestroProcesses.getAll();
+     *
+     * // Access process information and incidents
+     * for (const process of allProcesses) {
+     *   console.log(`Process: ${process.processKey}`);
+     *   console.log(`Running instances: ${process.runningCount}`);
+     *   console.log(`Faulted instances: ${process.faultedCount}`);
+     *
+     *   // Get incidents for this process
+     *   const incidents = await process.getIncidents();
+     *   console.log(`Incidents: ${incidents.length}`);
+     * }
+     * ```
+     */
+    getAll(): Promise<MaestroProcessGetAllResponse[]>;
+    /**
+     * Get incidents for a specific process
+     *
+     * @param processKey The key of the process to get incidents for
+     * @param folderKey The folder key for authorization
+     * @returns Promise resolving to array of incidents for the process
+     * {@link ProcessIncidentGetResponse}
+     * @example
+     * ```typescript
+     * // Get incidents for a specific process
+     * const incidents = await maestroProcesses.getIncidents('<processKey>', '<folderKey>');
+     *
+     * // Access incident details
+     * for (const incident of incidents) {
+     *   console.log(`Element: ${incident.incidentElementActivityName} (${incident.incidentElementActivityType})`);
+     *   console.log(`Status: ${incident.incidentStatus}`);
+     *   console.log(`Error: ${incident.errorMessage}`);
+     * }
+     * ```
+     */
+    getIncidents(processKey: string, folderKey: string): Promise<ProcessIncidentGetResponse[]>;
+}
+interface ProcessMethods {
+    /**
+     * Gets incidents for this process
+     *
+     * @returns Promise resolving to array of process incidents
+     */
+    getIncidents(): Promise<ProcessIncidentGetResponse[]>;
+}
+type MaestroProcessGetAllResponse = RawMaestroProcessGetAllResponse & ProcessMethods;
+/**
+ * Creates an actionable process by combining API process data with operational methods.
+ *
+ * @param processData - The process data from API
+ * @param service - The process service instance
+ * @returns A process object with added methods
+ */
+declare function createProcessWithMethods(processData: MaestroProcessGetAllResponse, service: MaestroProcessesServiceModel): MaestroProcessGetAllResponse;
+
+/**
+ * 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;
+});
+
+/**
+ * Process Instance Types
+ * Types and interfaces for Maestro process instance management
+ */
+
+/**
+ * Response for getting a single process instance
+ */
+interface RawProcessInstanceGetResponse {
+    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 | null;
+    instanceRuns: ProcessInstanceRun[];
+}
+/**
+ * Query options for getting process instances
+ */
+interface ProcessInstanceGetAllOptions {
+    packageId?: string;
+    packageVersion?: string;
+    processKey?: string;
+    errorCode?: string;
+}
+/**
+ * Query options for getting process instances with pagination support
+ */
+type ProcessInstanceGetAllWithPaginationOptions = ProcessInstanceGetAllOptions & PaginationOptions;
+/**
+ * Request for process instance operations (cancel, pause, resume)
+ */
+interface ProcessInstanceOperationOptions {
+    comment?: string;
+}
+/**
+ * Response from PIMS operations (cancel, pause, resume)
+ */
+interface ProcessInstanceOperationResponse {
+    instanceId: string;
+    status: string;
+}
+/**
+ * Response for process instance execution history
+ */
+interface ProcessInstanceExecutionHistoryResponse {
+    id: string;
+    traceId: string;
+    parentId: string | null;
+    name: string;
+    startedTime: string;
+    endTime: string | null;
+    attributes: string | null;
+    createdTime: string;
+    updatedTime?: string;
+    expiredTime: string | null;
+}
+/**
+ * Process Instance run
+ */
+interface ProcessInstanceRun {
+    runId: string;
+    status: string;
+    startedTime: string;
+    completedTime: string;
+}
+type BpmnXmlString = string;
+/**
+ * Process Instance element metadata
+ */
+interface ElementMetaData {
+    elementId: string;
+    elementRunId: string;
+    isMarker: boolean;
+    inputs: Record<string, any>;
+    inputDefinitions: Record<string, any>;
+    outputs: Record<string, any>;
+}
+/**
+ * Process Instance global variable metadata
+ */
+interface GlobalVariableMetaData {
+    id: string;
+    name: string;
+    /**
+     * Common values: "integer", "string", "boolean"
+     * May also contain custom types or "any" when type cannot be determined
+     */
+    type: string;
+    elementId: string;
+    /** Name of the BPMN node/element */
+    source: string;
+    value: any;
+}
+/**
+ * Response for getting global variables for process instance
+ */
+interface ProcessInstanceGetVariablesResponse {
+    elements: ElementMetaData[];
+    globalVariables: GlobalVariableMetaData[];
+    instanceId: string;
+    parentElementId: string | null;
+}
+/**
+ * Options for getting global variables
+ */
+interface ProcessInstanceGetVariablesOptions {
+    parentElementId?: string;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Service for managing UiPath Maestro Process instances
+ *
+ * Maestro process instances are the running instances of Maestro processes. [UiPath Maestro Process Instances Guide](https://docs.uipath.com/maestro/automation-cloud/latest/user-guide/all-instances-view)
+ *
+ * ### Usage
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ```typescript
+ * import { ProcessInstances } from '@uipath/uipath-typescript/maestro-processes';
+ *
+ * const processInstances = new ProcessInstances(sdk);
+ * const allInstances = await processInstances.getAll();
+ * ```
+ */
+interface ProcessInstancesServiceModel {
+    /**
+     * Get all process instances with optional filtering and pagination
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options Query parameters for filtering instances and pagination
+     * @returns Promise resolving to either an array of process instances NonPaginatedResponse<ProcessInstanceGetResponse> or a PaginatedResponse<ProcessInstanceGetResponse> when pagination options are used.
+     * {@link ProcessInstanceGetResponse}
+     * @example
+     * ```typescript
+     * // Get all instances (non-paginated)
+     * const instances = await processInstances.getAll();
+     *
+     * // Cancel faulted instances using methods directly on instances
+     * for (const instance of instances.items) {
+     *   if (instance.latestRunStatus === 'Faulted') {
+     *     await instance.cancel({ comment: 'Cancelling faulted instance' });
+     *   }
+     * }
+     *
+     * // With filtering
+     * const filteredInstances = await processInstances.getAll({
+     *   processKey: 'MyProcess'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await processInstances.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await processInstances.getAll({ cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getAll<T extends ProcessInstanceGetAllWithPaginationOptions = ProcessInstanceGetAllWithPaginationOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessInstanceGetResponse> : NonPaginatedResponse<ProcessInstanceGetResponse>>;
+    /**
+     * Get a process instance by ID with operation methods (cancel, pause, resume)
+     * @param id The ID of the instance to retrieve
+     * @param folderKey The folder key for authorization
+     * @returns Promise resolving to a process instance
+     * {@link ProcessInstanceGetResponse}
+     * @example
+     * ```typescript
+     * // Get a specific process instance
+     * const instance = await processInstances.getById(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     *
+     * // Access instance properties
+     * console.log(`Status: ${instance.latestRunStatus}`);
+     * ```
+     */
+    getById(id: string, folderKey: string): Promise<ProcessInstanceGetResponse>;
+    /**
+     * Get execution history (spans) for a process instance
+     * @param instanceId The ID of the instance to get history for
+     * @returns Promise resolving to execution history
+     * {@link ProcessInstanceExecutionHistoryResponse}
+     * @example
+     * ```typescript
+     * // Get execution history for a process instance
+     * const history = await processInstances.getExecutionHistory(
+     *   <instanceId>
+     * );
+     *
+     * // Analyze execution timeline
+     * history.forEach(span => {
+     *   console.log(`Activity: ${span.name}`);
+     *   console.log(`Start: ${span.startTime}`);
+     *   console.log(`Duration: ${span.duration}ms`);
+     * });
+     * ```
+     */
+    getExecutionHistory(instanceId: string): Promise<ProcessInstanceExecutionHistoryResponse[]>;
+    /**
+     * Get BPMN XML file for a process instance
+     * @param instanceId The ID of the instance to get BPMN for
+     * @param folderKey The folder key for authorization
+     * @returns Promise resolving to BPMN XML file
+     * {@link BpmnXmlString}
+     * @example
+     * ```typescript
+     * // Get BPMN XML for a process instance
+     * const bpmnXml = await processInstances.getBpmn(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     *
+     * // Render BPMN diagram in frontend using bpmn-js
+     * import BpmnViewer from 'bpmn-js/lib/Viewer';
+     *
+     * const viewer = new BpmnViewer({
+     *   container: '#bpmn-diagram'
+     * });
+     *
+     * await viewer.importXML(bpmnXml);
+     *
+     * // Zoom to fit the diagram
+     * viewer.get('canvas').zoom('fit-viewport');
+     * ```
+     */
+    getBpmn(instanceId: string, folderKey: string): Promise<BpmnXmlString>;
+    /**
+     * Cancel a process instance
+     * @param instanceId The ID of the instance to cancel
+     * @param folderKey The folder key for authorization
+     * @param options Optional cancellation options with comment
+     * @returns Promise resolving to operation result with instance data
+     * @example
+     * ```typescript
+     * // Cancel a process instance
+     * const result = await processInstances.cancel(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     *
+     * // Or using instance method
+     * const instance = await processInstances.getById(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     * const result = await instance.cancel();
+     *
+     * console.log(`Cancelled: ${result.success}`);
+     *
+     * // Cancel with a comment
+     * const resultWithComment = await instance.cancel({
+     *   comment: 'Cancelling due to invalid input data'
+     * });
+     *
+     * if (resultWithComment.success) {
+     *   console.log(`Instance ${resultWithComment.data.instanceId} status: ${resultWithComment.data.status}`);
+     * }
+     * ```
+     */
+    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 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 instance data
+     */
+    resume(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * 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 resolving to variables response with elements and globals
+     * {@link ProcessInstanceGetVariablesResponse}
+     * @example
+     * ```typescript
+     * // Get all variables for a process instance
+     * const variables = await processInstances.getVariables(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     *
+     * // Access global variables
+     * console.log('Global variables:', variables.globalVariables);
+     *
+     * // Iterate through global variables with metadata
+     * variables.globalVariables?.forEach(variable => {
+     *   console.log(`Variable: ${variable.name} (${variable.id})`);
+     *   console.log(`  Type: ${variable.type}`);
+     *   console.log(`  Element: ${variable.elementId}`);
+     *   console.log(`  Value: ${variable.value}`);
+     * });
+     *
+     * // Get variables for a specific parent element
+     * const elementVariables = await processInstances.getVariables(
+     *   <instanceId>,
+     *   <folderKey>,
+     *   { parentElementId: <parentElementId> }
+     * );
+     * ```
+     */
+    getVariables(instanceId: string, folderKey: string, options?: ProcessInstanceGetVariablesOptions): Promise<ProcessInstanceGetVariablesResponse>;
+    /**
+     * Get incidents for a process instance
+     *
+     * @param instanceId The ID of the instance to get incidents for
+     * @param folderKey The folder key for authorization
+     * @returns Promise resolving to array of incidents for the processinstance
+     * {@link ProcessIncidentGetResponse}
+     * @example
+     * ```typescript
+     * // Get incidents for a specific instance
+     * const incidents = await processInstances.getIncidents('<instanceId>', '<folderKey>');
+     *
+     * // Access process incident details
+     * for (const incident of incidents) {
+     *   console.log(`Element: ${incident.incidentElementActivityName} (${incident.incidentElementActivityType})`);
+     *   console.log(`Severity: ${incident.incidentSeverity}`);
+     *   console.log(`Error: ${incident.errorMessage}`);
+     * }
+     * ```
+     */
+    getIncidents(instanceId: string, folderKey: string): Promise<ProcessIncidentGetResponse[]>;
+}
+interface ProcessInstanceMethods {
+    /**
+     * Cancels this process instance
+     *
+     * @param options - Optional cancellation options with comment
+     * @returns Promise resolving to operation result
+     */
+    cancel(options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Pauses this process instance
+     *
+     * @param options - Optional pause options with comment
+     * @returns Promise resolving to operation result
+     */
+    pause(options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Resumes this process instance
+     *
+     * @param options - Optional resume options with comment
+     * @returns Promise resolving to operation result
+     */
+    resume(options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Gets incidents for this process instance
+     *
+     * @returns Promise resolving to array of incidents for this instance
+     */
+    getIncidents(): Promise<ProcessIncidentGetResponse[]>;
+    /**
+     * Gets execution history (spans) for this process instance
+     *
+     * @returns Promise resolving to execution history
+     */
+    getExecutionHistory(): Promise<ProcessInstanceExecutionHistoryResponse[]>;
+    /**
+     * Gets BPMN XML file for this process instance
+     *
+     * @returns Promise resolving to BPMN XML file
+     */
+    getBpmn(): Promise<BpmnXmlString>;
+    /**
+     * Gets global variables for this process instance
+     *
+     * @param options - Optional options including parentElementId to filter by parent element
+     * @returns Promise resolving to variables response with elements and globals
+     */
+    getVariables(options?: ProcessInstanceGetVariablesOptions): Promise<ProcessInstanceGetVariablesResponse>;
+}
+type ProcessInstanceGetResponse = RawProcessInstanceGetResponse & ProcessInstanceMethods;
+/**
+ * Creates an actionable process instance by combining API process instance data with operational methods.
+ *
+ * @param instanceData - The process instance data from API
+ * @param service - The process instance service instance
+ * @returns A process instance object with added methods
+ */
+declare function createProcessInstanceWithMethods(instanceData: RawProcessInstanceGetResponse, service: ProcessInstancesServiceModel): ProcessInstanceGetResponse;
+
+/**
+ * Service for managing UiPath Maestro Process incidents
+ *
+ * Maestro Process incidents helps you identify, investigate, and resolve errors that occur during process execution. [UiPath Maestro Process Incidents Guide](https://docs.uipath.com/maestro/automation-cloud/latest/user-guide/all-incidents-view)
+ */
+interface ProcessIncidentsServiceModel {
+    /**
+     * Get all process incidents across all folders
+     *
+     * @returns Promise resolving to array of process incident
+     * {@link ProcessIncidentGetAllResponse}
+     * @example
+     * ```typescript
+     * import { ProcessIncidents } from '@uipath/uipath-typescript/maestro-processes';
+     *
+     * const processIncidents = new ProcessIncidents(sdk);
+     *
+     * // Get all process incidents across all folders
+     * const incidents = await processIncidents.getAll();
+     *
+     * // Access process incident information
+     * for (const incident of incidents) {
+     *   console.log(`Process: ${incident.processKey}`);
+     *   console.log(`Error: ${incident.errorMessage}`);
+     *   console.log(`Count: ${incident.count}`);
+     *   console.log(`First occurrence: ${incident.firstOccuranceTime}`);
+     * }
+     * ```
+     */
+    getAll(): Promise<ProcessIncidentGetAllResponse[]>;
+}
+
+/**
+ * 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 Maestro Processes
+ */
+declare class MaestroProcessesService extends BaseService implements MaestroProcessesServiceModel {
+    private processInstancesService;
+    /**
+     * Creates an instance of the Maestro Processes service.
+     *
+     * @param instance - UiPath SDK instance providing authentication and configuration
+     */
+    constructor(instance: IUiPath);
+    /**
+     * Get all processes with their instance statistics
+     * @returns Promise resolving to array of MaestroProcess objects
+     *
+     * @example
+     * ```typescript
+     * import { MaestroProcesses } from '@uipath/uipath-typescript/maestro-processes';
+     *
+     * const maestroProcesses = new MaestroProcesses(sdk);
+     * const processes = await maestroProcesses.getAll();
+     *
+     * // Access process information
+     * for (const process of processes) {
+     *   console.log(`Process: ${process.processKey}`);
+     *   console.log(`Running instances: ${process.runningCount}`);
+     *   console.log(`Faulted instances: ${process.faultedCount}`);
+     * }
+     * ```
+     */
+    getAll(): Promise<MaestroProcessGetAllResponse[]>;
+    /**
+     * Get incidents for a specific process
+     */
+    getIncidents(processKey: string, folderKey: string): Promise<ProcessIncidentGetResponse[]>;
+}
+
+declare class ProcessInstancesService extends BaseService implements ProcessInstancesServiceModel {
+    /**
+     * Get all process instances with optional filtering and pagination
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options Query parameters for filtering instances and pagination
+     * @returns Promise resolving to process instances or paginated result
+     *
+     * @example
+     * ```typescript
+     * import { ProcessInstances } from '@uipath/uipath-typescript/maestro-processes';
+     *
+     * const processInstances = new ProcessInstances(sdk);
+     *
+     * // Get all instances (non-paginated)
+     * const instances = await processInstances.getAll();
+     *
+     * // Cancel faulted instances using methods directly on instances
+     * for (const instance of instances.items) {
+     *   if (instance.latestRunStatus === 'Faulted') {
+     *     await instance.cancel({ comment: 'Cancelling faulted instance' });
+     *   }
+     * }
+     *
+     * // With filtering
+     * const filtered = await processInstances.getAll({
+     *   processKey: 'MyProcess'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await processInstances.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await processInstances.getAll({ cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getAll<T extends ProcessInstanceGetAllWithPaginationOptions = ProcessInstanceGetAllWithPaginationOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessInstanceGetResponse> : NonPaginatedResponse<ProcessInstanceGetResponse>>;
+    /**
+     * Get a process instance by ID with operation methods (cancel, pause, resume)
+     * @param id The ID of the instance to retrieve
+     * @param folderKey The folder key for authorization
+     * @returns Promise<ProcessInstanceGetResponse>
+     */
+    getById(id: string, folderKey: string): Promise<ProcessInstanceGetResponse>;
+    /**
+     * Get execution history (spans) for a process instance
+     * @param instanceId The ID of the instance to get history for
+     * @returns Promise<ProcessInstanceExecutionHistoryResponse[]>
+     */
+    getExecutionHistory(instanceId: string): Promise<ProcessInstanceExecutionHistoryResponse[]>;
+    /**
+     * Get BPMN XML file for a process instance
+     * @param instanceId The ID of the instance to get BPMN for
+     * @param folderKey The folder key for authorization
+     * @returns Promise<BpmnXmlString> The BPMN XML contents as a string
+     */
+    getBpmn(instanceId: string, folderKey: string): Promise<BpmnXmlString>;
+    /**
+     * Cancel a process instance
+     * @param instanceId The ID of the instance to cancel
+     * @param folderKey The folder key for authorization
+     * @param options Optional cancellation options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    cancel(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Pause a process instance
+     * @param instanceId The ID of the instance to pause
+     * @param folderKey The folder key for authorization
+     * @param options Optional pause options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    pause(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Resume a process instance
+     * @param instanceId The ID of the instance to resume
+     * @param folderKey The folder key for authorization
+     * @param options Optional resume options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    resume(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Parses BPMN XML to extract variable metadata from uipath:inputOutput elements
+     * @private
+     * @param bpmnXml The BPMN XML string
+     * @returns Map of variable ID to metadata
+     */
+    private parseBpmnVariables;
+    /**
+     * Extracts element names from BPMN XML and maps them to their element IDs
+     * @private
+     * @param bpmnXml The BPMN XML string
+     * @returns Map of elementId to element name
+     */
+    private getVariableSource;
+    /**
+     * Enriches global variables with metadata from BPMN
+     * @private
+     * @param globals The raw globals object from API response
+     * @param variableMetadata The parsed BPMN variable metadata
+     * @returns Array of global variables
+     */
+    private transformGlobalVariables;
+    /**
+     * Get global variables for a process instance
+     * @param instanceId The ID of the instance to get variables for
+     * @param folderKey The folder key for authorization
+     * @param options Optional options including parentElementId to filter by parent element
+     * @returns Promise<ProcessInstanceGetVariablesResponse>
+     */
+    getVariables(instanceId: string, folderKey: string, options?: ProcessInstanceGetVariablesOptions): Promise<ProcessInstanceGetVariablesResponse>;
+    /**
+     * Get incidents for a process instance
+     * @param instanceId The ID of the instance to get incidents for
+     * @param folderKey The folder key for authorization
+     * @returns Promise<ProcessIncidentGetResponse[]>
+     */
+    getIncidents(instanceId: string, folderKey: string): Promise<ProcessIncidentGetResponse[]>;
+}
+
+/**
+ * Service class for Maestro Process Incidents
+ */
+declare class ProcessIncidentsService extends BaseService implements ProcessIncidentsServiceModel {
+    /**
+     * Get all process incidents across all folders
+     *
+     * @returns Promise resolving to array of process incident
+     * {@link ProcessIncidentGetAllResponse}
+     * @example
+     * ```typescript
+     * import { ProcessIncidents } from '@uipath/uipath-typescript/maestro-processes';
+     *
+     * const processIncidents = new ProcessIncidents(sdk);
+     * const incidents = await processIncidents.getAll();
+     *
+     * // Access process incident information
+     * for (const incident of incidents) {
+     *   console.log(`Process: ${incident.processKey}`);
+     *   console.log(`Error: ${incident.errorMessage}`);
+     *   console.log(`Count: ${incident.count}`);
+     *   console.log(`First occurrence: ${incident.firstOccuranceTime}`);
+     * }
+     * ```
+     */
+    getAll(): Promise<ProcessIncidentGetAllResponse[]>;
+}
+
+export { DebugMode, MaestroProcessesService as MaestroProcesses, MaestroProcessesService, ProcessIncidentSeverity, ProcessIncidentStatus, ProcessIncidentType, ProcessIncidentsService as ProcessIncidents, ProcessIncidentsService, ProcessInstancesService as ProcessInstances, ProcessInstancesService, createProcessInstanceWithMethods, createProcessWithMethods };
+export type { BpmnXmlString, ElementMetaData, GlobalVariableMetaData, MaestroProcessGetAllResponse, MaestroProcessesServiceModel, ProcessIncidentGetAllResponse, ProcessIncidentGetResponse, ProcessIncidentsServiceModel, ProcessInstanceExecutionHistoryResponse, ProcessInstanceGetAllOptions, ProcessInstanceGetAllWithPaginationOptions, ProcessInstanceGetResponse, ProcessInstanceGetVariablesOptions, ProcessInstanceGetVariablesResponse, ProcessInstanceMethods, ProcessInstanceOperationOptions, ProcessInstanceOperationResponse, ProcessInstanceRun, ProcessInstancesServiceModel, ProcessMethods, RawMaestroProcessGetAllResponse, RawProcessInstanceGetResponse };