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

package/dist/tasks/index.d.ts

@@ -0,0 +1,1122 @@
+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;
+});
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+/**
+ * Common enum for job state used across services
+ */
+declare enum JobState {
+    Pending = "Pending",
+    Running = "Running",
+    Stopping = "Stopping",
+    Terminating = "Terminating",
+    Faulted = "Faulted",
+    Successful = "Successful",
+    Stopped = "Stopped",
+    Suspended = "Suspended",
+    Resumed = "Resumed"
+}
+interface BaseOptions {
+    expand?: string;
+    select?: string;
+}
+/**
+ * Common request options interface used across services for querying data
+ */
+interface RequestOptions extends BaseOptions {
+    filter?: string;
+    orderby?: string;
+}
+
+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 TaskCreateOptions {
+    title: string;
+    data?: Record<string, unknown>;
+    priority?: TaskPriority;
+}
+interface RawTaskCreateResponse extends TaskBaseResponse {
+    waitJobState: JobState | null;
+    assignedToUser: UserLoginInfo | null;
+    taskSlaDetails: TaskSlaDetail[] | null;
+    completedByUser: UserLoginInfo | null;
+    taskAssignees: UserLoginInfo[] | null;
+    processingTime: number | null;
+    data: Record<string, unknown> | null;
+}
+interface RawTaskGetResponse extends TaskBaseResponse {
+    isCompleted: boolean;
+    encrypted: boolean;
+    bulkFormLayoutId: number | null;
+    formLayoutId: number | null;
+    taskSlaDetail: TaskSlaDetail | null;
+    taskAssigneeName: string | null;
+    lastModifierUserId: number | null;
+    assignedToUser: UserLoginInfo | null;
+    creatorUser?: UserLoginInfo;
+    lastModifierUser?: UserLoginInfo;
+    taskAssignments?: TaskAssignment[];
+    activities?: TaskActivity[];
+    tags?: Tag[];
+    formLayout?: Record<string, unknown>;
+    actionLabel?: string | null;
+    taskSlaDetails?: TaskSlaDetail[] | null;
+    completedByUser?: UserLoginInfo | null;
+    taskAssignmentCriteria?: string;
+    taskAssignees?: UserLoginInfo[] | null;
+    taskSource?: TaskSource | null;
+    processingTime?: number | null;
+    data?: Record<string, unknown> | null;
+}
+/**
+ * Options for task assignment operations when called from a task instance
+ * Requires either userId or userNameOrEmail, but not both
+ */
+type TaskAssignOptions = {
+    userId: number;
+    userNameOrEmail?: never;
+} | {
+    userId?: never;
+    userNameOrEmail: string;
+};
+/**
+ * Options for task assignment operations when called from the service
+ * Extends TaskAssignOptions with the required taskId field
+ */
+type TaskAssignmentOptions = {
+    taskId: number;
+} & TaskAssignOptions;
+interface TasksUnassignOptions {
+    taskIds: number[];
+}
+interface TaskAssignmentResponse {
+    taskId?: number;
+    userId?: number;
+    errorCode?: number;
+    errorMessage?: string;
+    userNameOrEmail?: string;
+}
+/**
+ * Options for completing a task
+ */
+type TaskCompleteOptions = {
+    type: TaskType.External;
+    data?: any;
+    action?: string;
+} | {
+    type: Exclude<TaskType, TaskType.External>;
+    data: any;
+    action: string;
+};
+/**
+ * Options for completing a task when called from the service
+ * Extends TaskCompleteOptions with the required taskId field
+ */
+type TaskCompletionOptions = TaskCompleteOptions & {
+    taskId: number;
+};
+/**
+ * Options for getting tasks across folders
+ */
+type TaskGetAllOptions = RequestOptions & PaginationOptions & {
+    /**
+     * Optional folder ID to filter tasks by folder
+     */
+    folderId?: number;
+    /**
+     * 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;
+};
+/**
+ * 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)
+ *
+ * ### Usage
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ```typescript
+ * import { Tasks } from '@uipath/uipath-typescript/tasks';
+ *
+ * const tasks = new Tasks(sdk);
+ * const allTasks = await tasks.getAll();
+ * ```
+ */
+interface TaskServiceModel {
+    /**
+     * Gets all tasks across folders with optional filtering
+     *
+     * @param options - Query options including optional folderId, asTaskAdmin flag and pagination options
+     * @returns Promise resolving to either an array of tasks NonPaginatedResponse<TaskGetResponse> or a PaginatedResponse<TaskGetResponse> when pagination options are used.
+     * {@link TaskGetResponse}
+     *  @example
+     * ```typescript
+     * // Standard array return
+     * const allTasks = await tasks.getAll();
+     *
+     * // Get tasks within a specific folder
+     * const folderTasks = await tasks.getAll({
+     *   folderId: 123
+     * });
+     *
+     * // Get tasks with admin permissions
+     * // This fetches tasks across folders where the user has Task.View, Task.Edit and TaskAssignment.Create permissions
+     * const adminTasks = await tasks.getAll({
+     *   asTaskAdmin: true
+     * });
+     *
+     * // Get tasks without admin permissions (default)
+     * // This fetches tasks across folders where the user has Task.View and Task.Edit permissions
+     * const userTasks = await tasks.getAll({
+     *   asTaskAdmin: false
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await tasks.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await tasks.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await tasks.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends TaskGetAllOptions = TaskGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
+    /**
+     * Gets a task by ID
+     * IMPORTANT: For form tasks, folderId must be provided.
+     * @param id - The ID of the task to retrieve
+     * @param options - Optional query parameters
+     * @param folderId - Optional folder ID (REQUIRED for form tasks)
+     * @returns Promise resolving to the task
+     * {@link TaskGetResponse}
+     * @example
+     * ```typescript
+     * // Get a task by ID
+     * const task = await tasks.getById(<taskId>);
+     *
+     * // Get a form task by ID
+     * const formTask = await tasks.getById(<taskId>, <folderId>);
+     *
+     * // Access form task properties
+     * console.log(formTask.formLayout);
+     * ```
+     */
+    getById(id: number, options?: TaskGetByIdOptions, folderId?: number): Promise<TaskGetResponse>;
+    /**
+     * Creates a new task
+     *
+     * @param options - The task to be created
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to the created task
+     * {@link TaskCreateResponse}
+     * @example
+     * ```typescript
+     * import { TaskPriority } from '@uipath/uipath-typescript';
+     * const task = await tasks.create({
+     *   title: "My Task",
+     *   priority: TaskPriority.Medium
+     * }, <folderId>); // folderId is required
+     * ```
+     */
+    create(options: TaskCreateOptions, folderId: number): Promise<TaskCreateResponse>;
+    /**
+     * Assigns tasks to users
+     *
+     * @param options - Single task assignment or array of task assignments
+     * @returns Promise resolving to array of task assignment results
+     * {@link TaskAssignmentResponse}
+     * @example
+     * ```typescript
+     * // Assign a single task to a user by ID
+     * const result = await tasks.assign({
+     *   taskId: <taskId>,
+     *   userId: <userId>
+     * });
+     *
+     * // Or using instance method
+     * const task = await tasks.getById(<taskId>);
+     * const result = await task.assign({
+     *   userId: <userId>
+     * });
+     *
+     * // Assign a single task to a user by email
+     * const result = await tasks.assign({
+     *   taskId: <taskId>,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Assign multiple tasks
+     * const result = await tasks.assign([
+     *   { taskId: <taskId1>, userId: <userId> },
+     *   { taskId: <taskId2>, userNameOrEmail: "user@example.com" }
+     * ]);
+     * ```
+     */
+    assign(options: TaskAssignmentOptions | TaskAssignmentOptions[]): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Reassigns tasks to new users
+     *
+     * @param options - Single task assignment or array of task assignments
+     * @returns Promise resolving to array of task assignment results
+     * {@link TaskAssignmentResponse}
+     * @example
+     * ```typescript
+     * // Reassign a single task to a user by ID
+     * const result = await tasks.reassign({
+     *   taskId: <taskId>,
+     *   userId: <userId>
+     * });
+     *
+     * // Or using instance method
+     * const task = await tasks.getById(<taskId>);
+     * const result = await task.reassign({
+     *   userId: <userId>
+     * });
+     *
+     * // Reassign a single task to a user by email
+     * const result = await tasks.reassign({
+     *   taskId: <taskId>,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Reassign multiple tasks
+     * const result = await tasks.reassign([
+     *   { taskId: <taskId1>, userId: <userId> },
+     *   { taskId: <taskId2>, userNameOrEmail: "user@example.com" }
+     * ]);
+     * ```
+     */
+    reassign(options: TaskAssignmentOptions | TaskAssignmentOptions[]): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Unassigns tasks (removes current assignees)
+     *
+     * @param taskId - Single task ID or array of task IDs to unassign
+     * @returns Promise resolving to array of task assignment results
+     * {@link TaskAssignmentResponse}
+     * @example
+     * ```typescript
+     * // Unassign a single task
+     * const result = await tasks.unassign(<taskId>);
+     *
+     * // Or using instance method
+     * const task = await tasks.getById(<taskId>);
+     * const result = await task.unassign();
+     *
+     * // Unassign multiple tasks
+     * const result = await tasks.unassign([<taskId1>, <taskId2>, <taskId3>]);
+     * ```
+     */
+    unassign(taskId: number | number[]): Promise<OperationResponse<{
+        taskId: number;
+    }[] | TaskAssignmentResponse[]>>;
+    /**
+     * Completes a task with the specified type and data
+     *
+     * @param options - The completion options including task type, taskId, data, and action
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to completion result
+     * {@link TaskCompleteOptions}
+     * @example
+     * ```typescript
+     * // Complete an app task
+     * await tasks.complete({
+     *   type: TaskType.App,
+     *   taskId: <taskId>,
+     *   data: {},
+     *   action: "submit"
+     * }, <folderId>); // folderId is required
+     *
+     * // Complete an external task
+     * await tasks.complete({
+     *   type: TaskType.External,
+     *   taskId: <taskId>
+     * }, <folderId>); // folderId is required
+     * ```
+     */
+    complete(options: TaskCompletionOptions, folderId: number): Promise<OperationResponse<TaskCompletionOptions>>;
+    /**
+     * Gets users in the given folder who have Tasks.View and Tasks.Edit permissions
+     * Returns a NonPaginatedResponse with data and totalCount when no pagination parameters are provided,
+     * or a PaginatedResponse when any pagination parameter is provided
+     *
+     * @param folderId - The folder ID to get users from
+     * @param options - Optional query and pagination parameters
+     * @returns Promise resolving to either an array of users NonPaginatedResponse<UserLoginInfo> or a PaginatedResponse<UserLoginInfo> when pagination options are used.
+     * {@link UserLoginInfo}
+     * @example
+     * ```typescript
+     * // Get users from a folder
+     * const users = await tasks.getUsers(<folderId>);
+     *
+     * // Access user properties
+     * console.log(users.items[0].name);
+     * console.log(users.items[0].emailAddress);
+     * ```
+     */
+    getUsers<T extends TaskGetUsersOptions = TaskGetUsersOptions>(folderId: number, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<UserLoginInfo> : NonPaginatedResponse<UserLoginInfo>>;
+}
+interface TaskMethods {
+    /**
+     * Assigns this task to a user or users
+     *
+     * @param options - Assignment options (requires at least one of: userId, userNameOrEmail)
+     * @returns Promise resolving to task assignment results
+     */
+    assign(options: TaskAssignOptions): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Reassigns this task to a new user
+     *
+     * @param options - Assignment options (requires at least one of: userId, userNameOrEmail)
+     * @returns Promise resolving to task assignment results
+     */
+    reassign(options: TaskAssignOptions): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Unassigns this task (removes current assignee)
+     *
+     * @returns Promise resolving to task assignment results
+     */
+    unassign(): Promise<OperationResponse<{
+        taskId: number;
+    }[] | TaskAssignmentResponse[]>>;
+    /**
+     * Completes this task with optional data and action
+     *
+     * @param options - Completion options
+     * @returns Promise resolving to completion result
+     */
+    complete(options: TaskCompleteOptions): Promise<OperationResponse<TaskCompletionOptions>>;
+}
+type TaskGetResponse = RawTaskGetResponse & TaskMethods;
+type TaskCreateResponse = RawTaskCreateResponse & TaskMethods;
+/**
+ * Creates an actionable task by combining API task data with operational methods.
+ *
+ * @param taskData - The task data from API
+ * @param service - The task service instance
+ * @returns A task object with added methods
+ */
+declare function createTaskWithMethods(taskData: RawTaskGetResponse | RawTaskCreateResponse, service: TaskServiceModel): TaskGetResponse | TaskCreateResponse;
+
+/**
+ * Service for interacting with UiPath Tasks API
+ */
+declare class TaskService extends BaseService implements TaskServiceModel {
+    /**
+     * Creates a new task
+     * @param task - The task to be created
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to the created task
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     * const task = await tasks.create({
+     *   title: "My Task",
+     *   priority: TaskPriority.Medium,
+     *   data: { key: "value" }
+     * }, 123); // folderId is required
+     * ```
+     */
+    create(task: TaskCreateOptions, folderId: number): Promise<TaskCreateResponse>;
+    /**
+     * Gets users in the given folder who have Tasks.View and Tasks.Edit permissions
+     *
+     * The method returns either:
+     * - An array of users (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (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 an array of users or paginated result
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Standard array return
+     * const users = await tasks.getUsers(123);
+     *
+     * // Get users with filtering
+     * const users = await tasks.getUsers(123, {
+     *   filter: "name eq 'abc'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await tasks.getUsers(123, { pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await tasks.getUsers(123, { cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await tasks.getUsers(123, {
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getUsers<T extends TaskGetUsersOptions = TaskGetUsersOptions>(folderId: number, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<UserLoginInfo> : NonPaginatedResponse<UserLoginInfo>>;
+    /**
+     * Gets tasks across folders with optional filtering and folder scoping
+     *
+     * 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 options - Query options including optional folderId, asTaskAdmin flag and pagination options
+     * @returns Promise resolving to an array of tasks or paginated result
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Standard array return
+     * const allTasks = await tasks.getAll();
+     *
+     * // Get tasks within a specific folder
+     * const folderTasks = await tasks.getAll({
+     *   folderId: 123
+     * });
+     *
+     * // Get tasks with admin permissions
+     * const adminTasks = await tasks.getAll({
+     *   asTaskAdmin: true
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await tasks.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await tasks.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await tasks.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends TaskGetAllOptions = TaskGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
+    /**
+     * Gets a task by ID
+     * IMPORTANT: For form tasks, folderId must be provided.
+     *
+     * @param id - The ID of the task to retrieve
+     * @param options - Optional query parameters
+     * @param folderId - Optional folder ID (REQUIRED for form tasks)
+     * @returns Promise resolving to the task (form tasks will return form-specific data)
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Get task by ID
+     * const task = await tasks.getById(123);
+     *
+     * // If the task is a form task, it will automatically return form-specific data
+     * ```
+     */
+    getById(id: number, options?: TaskGetByIdOptions, folderId?: number): Promise<TaskGetResponse>;
+    /**
+     * Assigns tasks to users
+     *
+     * @param taskAssignments - Single task assignment or array of task assignments
+     * @returns Promise resolving to array of task assignment results
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Assign a single task to a user by ID
+     * const result = await tasks.assign({
+     *   taskId: 123,
+     *   userId: 456
+     * });
+     *
+     * // Assign a single task to a user by email
+     * const result = await tasks.assign({
+     *   taskId: 123,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Assign multiple tasks
+     * const result = await tasks.assign([
+     *   {
+     *     taskId: 123,
+     *     userId: 456
+     *   },
+     *   {
+     *     taskId: 789,
+     *     userNameOrEmail: "user@example.com"
+     *   }
+     * ]);
+     * ```
+     */
+    assign(taskAssignments: TaskAssignmentOptions | TaskAssignmentOptions[]): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Reassigns tasks to new users
+     *
+     * @param taskAssignments - Single task assignment or array of task assignments
+     * @returns Promise resolving to array of task assignment results
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Reassign a single task to a user by ID
+     * const result = await tasks.reassign({
+     *   taskId: 123,
+     *   userId: 456
+     * });
+     *
+     * // Reassign a single task to a user by email
+     * const result = await tasks.reassign({
+     *   taskId: 123,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Reassign multiple tasks
+     * const result = await tasks.reassign([
+     *   {
+     *     taskId: 123,
+     *     userId: 456
+     *   },
+     *   {
+     *     taskId: 789,
+     *     userNameOrEmail: "user@example.com"
+     *   }
+     * ]);
+     * ```
+     */
+    reassign(taskAssignments: TaskAssignmentOptions | TaskAssignmentOptions[]): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Unassigns tasks (removes current assignees)
+     *
+     * @param taskIds - Single task ID or array of task IDs to unassign
+     * @returns Promise resolving to array of task assignment results
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Unassign a single task
+     * const result = await tasks.unassign(123);
+     *
+     * // Unassign multiple tasks
+     * const result = await tasks.unassign([123, 456, 789]);
+     * ```
+     */
+    unassign(taskIds: number | number[]): Promise<OperationResponse<{
+        taskId: number;
+    }[] | TaskAssignmentResponse[]>>;
+    /**
+     * Completes a task with the specified type and data
+     *
+     * @param options - The completion options including task type, taskId, data, and action
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to completion result
+     *
+     * @example
+     * ```typescript
+     * import { Tasks } from '@uipath/uipath-typescript/tasks';
+     *
+     * const tasks = new Tasks(sdk);
+     *
+     * // Complete an app task
+     * await tasks.complete({
+     *   type: TaskType.App,
+     *   taskId: 456,
+     *   data: {},
+     *   action: "submit"
+     * }, 123); // folderId is required
+     *
+     * // Complete an external task
+     * await tasks.complete({
+     *   type: TaskType.External,
+     *   taskId: 789
+     * }, 123); // folderId is required
+     * ```
+     */
+    complete(options: TaskCompletionOptions, folderId: number): Promise<OperationResponse<TaskCompletionOptions>>;
+    /**
+     * Gets a form task by ID (private method)
+     *
+     * @param id - The ID of the form task to retrieve
+     * @param folderId - Required folder ID
+     * @param options - Optional query parameters
+     * @returns Promise resolving to the form task
+     */
+    private getFormTaskById;
+    /**
+     * Process parameters for task queries with folder filtering
+     * @param options - The REST API options to process
+     * @param folderId - Optional folder ID to filter by
+     * @returns Processed options with folder filtering applied if needed
+     * @private
+     */
+    private processTaskParameters;
+    /**
+     * Adds default expand parameters to options
+     * @param options - The options object to add default expand to
+     * @returns Options with default expand parameters added
+     * @private
+     */
+    private addDefaultExpand;
+}
+
+export { TaskActivityType, TaskPriority, TaskService, TaskSlaCriteria, TaskSlaStatus, TaskSourceName, TaskStatus, TaskType, TaskService as Tasks, createTaskWithMethods };
+export type { RawTaskCreateResponse, RawTaskGetResponse, Tag, TaskActivity, TaskAssignOptions, TaskAssignment, TaskAssignmentOptions, TaskAssignmentResponse, TaskBaseResponse, TaskCompleteOptions, TaskCompletionOptions, TaskCreateOptions, TaskCreateResponse, TaskGetAllOptions, TaskGetByIdOptions, TaskGetResponse, TaskGetUsersOptions, TaskMethods, TaskServiceModel, TaskSlaDetail, TaskSource, TasksUnassignOptions, UserLoginInfo };