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

package/dist/index.d.ts

@@ -1,16 +1,3903 @@
+import { z } from 'zod';
+
+declare const ConfigSchema: z.ZodObject<{
+    baseUrl: z.ZodDefault<z.ZodString>;
+    orgName: z.ZodString;
+    tenantName: z.ZodString;
+    secret: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    redirectUri: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    baseUrl: string;
+    orgName: string;
+    tenantName: string;
+    secret?: string | undefined;
+    clientId?: string | undefined;
+    redirectUri?: string | undefined;
+    scope?: string | undefined;
+}, {
+    orgName: string;
+    tenantName: string;
+    baseUrl?: string | undefined;
+    secret?: string | undefined;
+    clientId?: string | undefined;
+    redirectUri?: string | undefined;
+    scope?: string | undefined;
+}>;
+type Config = z.infer<typeof ConfigSchema>;
+
 /**
- * UiPath TypeScript SDK
- *
- * A TypeScript SDK that enables programmatic interaction with UiPath Platform services.
- */
-export { UiPath } from './uipath';
-export type { Config } from './core/config/config';
-export * from './models/common';
-export * from './models/data-fabric';
-export * from './models/maestro';
-export * from './models/orchestrator';
-export * from './models/action-center';
-export * from './core/errors';
-export * from './utils/pagination';
-export * from './core/telemetry';
-//# sourceMappingURL=index.d.ts.map
+ * 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;
+    }>;
+    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;
+}
+
+/**
+ * ExecutionContext manages the state and context of API operations.
+ * It provides a way to share context across service calls and maintain
+ * execution state throughout the lifecycle of operations.
+ */
+declare class ExecutionContext {
+    private context;
+    private headers;
+    /**
+     * Set a context value that will be available throughout the execution
+     */
+    set<T>(key: string, value: T): void;
+    /**
+     * Get a previously set context value
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * Set custom headers that will be included in all API requests
+     */
+    setHeaders(headers: Record<string, string>): void;
+    /**
+     * Get all custom headers
+     */
+    getHeaders(): Record<string, string>;
+    /**
+     * Clear all context and headers
+     */
+    clear(): void;
+    /**
+     * Create a request spec for an API call
+     */
+    createRequestSpec(spec?: Partial<RequestSpec>): RequestSpec;
+}
+
+/**
+ * Authentication token information
+ */
+interface TokenInfo {
+    token: string;
+    type: 'secret' | 'oauth';
+    expiresAt?: Date;
+    refreshToken?: string;
+}
+/**
+ * OAuth token response
+ */
+interface AuthToken {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    scope: string;
+    refresh_token?: string;
+}
+
+/**
+ * TokenManager is responsible for managing authentication tokens.
+ * It provides token operations for a specific client ID.
+ * - For OAuth tokens: Uses session storage with client ID-based keys
+ * - For Secret tokens: Stores only in memory, allowing multiple instances
+ */
+declare class TokenManager {
+    private executionContext;
+    private config;
+    private isOAuth;
+    private currentToken?;
+    private readonly STORAGE_KEY_PREFIX;
+    private refreshPromise;
+    /**
+     * Creates a new TokenManager instance
+     * @param executionContext The execution context
+     * @param config The SDK configuration
+     * @param isOAuth Whether this is an OAuth-based authentication
+     */
+    constructor(executionContext: ExecutionContext, config: Config, isOAuth?: boolean);
+    /**
+     * Checks if a token is expired
+     * @param tokenInfo The token info to check
+     * @returns true if the token is expired, false otherwise
+     */
+    isTokenExpired(tokenInfo?: TokenInfo): boolean;
+    /**
+     * Gets the storage key for this TokenManager instance
+     */
+    private _getStorageKey;
+    /**
+     * Loads token from session storage if available
+     * @returns true if a valid token was loaded, false otherwise
+     */
+    loadFromStorage(): boolean;
+    /**
+     * Parse and validate token info from storage
+     * @param storedToken JSON string from storage
+     * @returns Valid TokenInfo or undefined if invalid
+     */
+    private _parseTokenInfo;
+    /**
+     * Sets a new token and updates all necessary contexts
+     */
+    setToken(tokenInfo: TokenInfo): void;
+    /**
+     * Gets the current token information
+     */
+    getTokenInfo(): TokenInfo | undefined;
+    /**
+     * Gets just the token string
+     */
+    getToken(): string | undefined;
+    /**
+     * Checks if we have a valid token
+     */
+    hasValidToken(): boolean;
+    /**
+     * Clears the current token
+     */
+    clearToken(): void;
+    /**
+     * Updates execution context with token information
+     */
+    private _updateExecutionContext;
+    /**
+     * Refreshes the access token using the stored refresh token.
+     * This method only works for OAuth flow.
+     * Uses a lock mechanism to prevent multiple simultaneous refreshes.
+     * @returns A promise that resolves to the new AuthToken
+     * @throws Error if not in OAuth flow, refresh token is missing, or the request fails
+     */
+    refreshAccessToken(): Promise<AuthToken>;
+    /**
+     * Internal method to perform the actual token refresh
+     */
+    private _doRefreshToken;
+}
+
+interface ApiClientConfig {
+    headers?: Record<string, string>;
+}
+declare class ApiClient {
+    private readonly config;
+    private readonly executionContext;
+    private readonly clientConfig;
+    private defaultHeaders;
+    private tokenManager;
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager, clientConfig?: ApiClientConfig);
+    setDefaultHeaders(headers: Record<string, string>): void;
+    /**
+     * Checks if the current token needs refresh and refreshes it if necessary
+     * @returns The valid token
+     * @throws Error if token refresh fails
+     */
+    private ensureValidToken;
+    private getDefaultHeaders;
+    private request;
+    get<T>(path: string, options?: RequestSpec): Promise<T>;
+    post<T>(path: string, data?: unknown, options?: RequestSpec): Promise<T>;
+    put<T>(path: string, data?: unknown, options?: RequestSpec): Promise<T>;
+    patch<T>(path: string, data?: unknown, options?: RequestSpec): Promise<T>;
+    delete<T>(path: string, options?: RequestSpec): Promise<T>;
+}
+
+interface ApiResponse<T> {
+    data: T;
+}
+declare class BaseService {
+    protected readonly config: Config;
+    protected readonly executionContext: ExecutionContext;
+    protected readonly apiClient: ApiClient;
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * 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;
+}
+
+/**
+ * Entity field type names
+ */
+declare enum EntityFieldDataType {
+    UUID = "UUID",
+    STRING = "STRING",
+    INTEGER = "INTEGER",
+    DATETIME = "DATETIME",
+    DATETIME_WITH_TZ = "DATETIME_WITH_TZ",
+    DECIMAL = "DECIMAL",
+    FLOAT = "FLOAT",
+    DOUBLE = "DOUBLE",
+    DATE = "DATE",
+    BOOLEAN = "BOOLEAN",
+    BIG_INTEGER = "BIG_INTEGER",
+    MULTILINE_TEXT = "MULTILINE_TEXT"
+}
+/**
+ * Represents a single entity record
+ */
+interface EntityRecord {
+    /**
+     * Unique identifier for the record
+     */
+    id: string;
+    /**
+     * Additional dynamic fields for the entity
+     */
+    [key: string]: any;
+}
+/**
+ * Options for getting an entity by Id
+ */
+type EntityGetRecordsByIdOptions = {
+    /** Level of entity expansion (default: 0) */
+    expansionLevel?: number;
+} & PaginationOptions;
+/**
+ * Common options for entity operations that modify multiple records
+ */
+interface EntityOperationOptions {
+    /** Level of entity expansion (default: 0) */
+    expansionLevel?: number;
+    /** Whether to fail on first error (default: false) */
+    failOnFirst?: boolean;
+}
+/**
+ * Options for inserting data into an entity
+ */
+type EntityInsertOptions = EntityOperationOptions;
+/**
+ * Options for updating data in an entity
+ */
+type EntityUpdateOptions = EntityOperationOptions;
+/**
+ * Options for deleting data from an entity
+ */
+interface EntityDeleteOptions {
+    /** Whether to fail on first error (default: false) */
+    failOnFirst?: boolean;
+}
+/**
+ * Represents a failure record in an entity operation
+ */
+interface FailureRecord {
+    /** Error message */
+    error?: string;
+    /** Original record that failed */
+    record?: Record<string, any>;
+}
+/**
+ * Response from an entity operation that modifies multiple records
+ */
+interface EntityOperationResponse {
+    /** Records that were successfully processed */
+    successRecords: Record<string, any>[];
+    /** Records that failed processing */
+    failureRecords: FailureRecord[];
+}
+/**
+ * Response from inserting data into an entity
+ */
+type EntityInsertResponse = EntityOperationResponse;
+/**
+ * Response from updating data in an entity
+ */
+type EntityUpdateResponse = EntityOperationResponse;
+/**
+ * Response from deleting data from an entity
+ */
+type EntityDeleteResponse = EntityOperationResponse;
+/**
+ * Entity type enum
+ */
+declare enum EntityType {
+    Entity = "Entity",
+    ChoiceSet = "ChoiceSet",
+    InternalEntity = "InternalEntity",
+    SystemEntity = "SystemEntity"
+}
+/**
+ * Field type metadata
+ */
+interface FieldDataType {
+    name: EntityFieldDataType;
+    lengthLimit?: number;
+    maxValue?: number;
+    minValue?: number;
+    decimalPrecision?: number;
+}
+/**
+ * Reference types for fields
+ */
+declare enum ReferenceType {
+    ManyToOne = "ManyToOne"
+}
+/**
+ * Field display types
+ */
+declare enum FieldDisplayType {
+    Basic = "Basic",
+    Relationship = "Relationship",
+    File = "File",
+    ChoiceSetSingle = "ChoiceSetSingle",
+    ChoiceSetMultiple = "ChoiceSetMultiple",
+    AutoNumber = "AutoNumber"
+}
+/**
+ * Data direction type for external fields
+ */
+declare enum DataDirectionType {
+    ReadOnly = "ReadOnly",
+    ReadAndWrite = "ReadAndWrite"
+}
+/**
+ * Join type for source join criteria
+ */
+declare enum JoinType {
+    LeftJoin = "LeftJoin"
+}
+/**
+ * Field reference with ID
+ */
+interface Field {
+    id: string;
+    definition?: FieldMetaData;
+}
+/**
+ * Detailed field definition
+ */
+interface FieldMetaData {
+    id: string;
+    name: string;
+    isPrimaryKey: boolean;
+    isForeignKey: boolean;
+    isExternalField: boolean;
+    isHiddenField: boolean;
+    isUnique: boolean;
+    referenceName?: string;
+    referenceEntity?: RawEntityGetResponse;
+    referenceChoiceSet?: RawEntityGetResponse;
+    referenceField?: Field;
+    referenceType: ReferenceType;
+    fieldDataType: FieldDataType;
+    isRequired: boolean;
+    displayName: string;
+    description: string;
+    createdTime: string;
+    createdBy: string;
+    updatedTime: string;
+    updatedBy?: string;
+    isSystemField: boolean;
+    fieldDisplayType?: FieldDisplayType;
+    choiceSetId?: string;
+    defaultValue?: string;
+    isAttachment: boolean;
+    isRbacEnabled: boolean;
+}
+/**
+ * External object details
+ */
+interface ExternalObject {
+    id: string;
+    externalObjectName?: string;
+    externalObjectDisplayName?: string;
+    primaryKey?: string;
+    externalConnectionId: string;
+    entityId?: string;
+    isPrimarySource: boolean;
+}
+/**
+ * External connection details
+ */
+interface ExternalConnection {
+    id: string;
+    connectionId: string;
+    elementInstanceId: number;
+    folderKey: string;
+    connectorKey?: string;
+    connectorName?: string;
+    connectionName?: string;
+}
+/**
+ * External field mapping
+ */
+interface ExternalFieldMapping {
+    id: string;
+    externalFieldName?: string;
+    externalFieldDisplayName?: string;
+    externalObjectId: string;
+    externalFieldType?: string;
+    internalFieldId: string;
+    directionType: DataDirectionType;
+}
+/**
+ * External field
+ */
+interface ExternalField {
+    fieldMetaData: FieldMetaData;
+    externalFieldMappingDetail: ExternalFieldMapping;
+}
+/**
+ * External source fields
+ */
+interface ExternalSourceFields {
+    fields?: ExternalField[];
+    externalObjectDetail?: ExternalObject;
+    externalConnectionDetail?: ExternalConnection;
+}
+/**
+ * Source join criteria
+ */
+interface SourceJoinCriteria {
+    id: string;
+    entityId: string;
+    joinFieldName?: string;
+    joinType: JoinType;
+    relatedSourceObjectId?: string;
+    relatedSourceFieldName?: string;
+}
+/**
+ * Entity metadata returned by getById
+ */
+interface RawEntityGetResponse {
+    name: string;
+    displayName: string;
+    entityType: EntityType;
+    description: string;
+    fields: FieldMetaData[];
+    externalFields?: ExternalSourceFields[];
+    sourceJoinCriterias?: SourceJoinCriteria[];
+    recordCount?: number;
+    storageSizeInMB?: number;
+    usedStorageSizeInMB?: number;
+    attachmentSizeInByte?: number;
+    isRbacEnabled: boolean;
+    id: string;
+    createdBy: string;
+    createdTime: string;
+    updatedTime?: string;
+    updatedBy?: string;
+}
+
+/**
+ * Service for managing UiPath Data Fabric Entities.
+ *
+ * Entities are collections of records that can be used to store and manage data in the Data Fabric. [UiPath Data Fabric Guide](https://docs.uipath.com/data-service/automation-cloud/latest/user-guide/introduction)
+ *
+ */
+interface EntityServiceModel {
+    /**
+     * Gets all entities in the system
+     *
+     * @returns Promise resolving to either an array of entities NonPaginatedResponse<EntityGetResponse> or a PaginatedResponse<EntityGetResponse> when pagination options are used.
+     * {@link EntityGetResponse}
+     * @example
+     * ```typescript
+     * // Get all entities
+     * const entities = await sdk.entities.getAll();
+     *
+     * // Iterate through entities
+     * entities.forEach(entity => {
+     *   console.log(`Entity: ${entity.displayName} (${entity.name})`);
+     *   console.log(`Type: ${entity.entityType}`);
+     * });
+     *
+     * // Find a specific entity by name
+     * const customerEntity = entities.find(e => e.name === 'Customer');
+     *
+     * // Use entity methods directly
+     * if (customerEntity) {
+     *   const records = await customerEntity.getRecords();
+     *   console.log(`Customer records: ${records.items.length}`);
+     *
+     *   const insertResult = await customerEntity.insert([
+     *     { name: "John", age: 30 }
+     *   ]);
+     * }
+     * ```
+     */
+    getAll(): Promise<EntityGetResponse[]>;
+    /**
+     * Gets entity metadata by entity ID with attached operation methods
+     *
+     * @param id - UUID of the entity
+     * @returns Promise resolving to entity metadata with operation methods
+     * {@link EntityGetResponse}
+     * @example
+     * ```typescript
+     * // Get entity metadata with methods
+     * const entity = await sdk.entities.getById(<entityId>);
+     *
+     * // Call operations directly on the entity
+     * const records = await entity.getRecords();
+     *
+     * const insertResult = await entity.insert([
+     *   { name: "John", age: 30 }
+     * ]);
+     * ```
+     */
+    getById(id: string): Promise<EntityGetResponse>;
+    /**
+     * Gets entity records by entity ID
+     *
+     * @param entityId - UUID of the entity
+     * @param options - Query options
+     * @returns Promise resolving to either an array of entity records NonPaginatedResponse<EntityRecord> or a PaginatedResponse<EntityRecord> when pagination options are used.
+     * {@link EntityRecord}
+     * @example
+     * ```typescript
+     * // Basic usage (non-paginated)
+     * const records = await sdk.entities.getRecordsById(<entityId>);
+     *
+     * // With expansion level
+     * const records = await sdk.entities.getRecordsById(<entityId>, {
+     *   expansionLevel: 1
+     * });
+     *
+     * // With pagination
+     * const paginatedResponse = await sdk.entities.getRecordsById(<entityId>, {
+     *   pageSize: 50,
+     *   expansionLevel: 1
+     * });
+     *
+     * // Navigate to next page
+     * const nextPage = await sdk.entities.getRecordsById(<entityId>, {
+     *   cursor: paginatedResponse.nextCursor,
+     *   expansionLevel: 1
+     * });
+     * ```
+     */
+    getRecordsById<T extends EntityGetRecordsByIdOptions = EntityGetRecordsByIdOptions>(entityId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+    /**
+     * Inserts data into an entity by entity ID
+     *
+     * @param id - UUID of the entity
+     * @param data - Array of records to insert
+     * @param options - Insert options
+     * @returns Promise resolving to insert response
+     * {@link EntityInsertResponse}
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = await sdk.entities.insertById(<entityId>, [
+     *   { name: "John", age: 30 },
+     *   { name: "Jane", age: 25 }
+     * ]);
+     *
+     * // With options
+     * const result = await sdk.entities.insertById(<entityId>, [
+     *   { name: "John", age: 30 },
+     *   { name: "Jane", age: 25 }
+     * ], {
+     *   expansionLevel: 1,
+     *   failOnFirst: true
+     * });
+     * ```
+     */
+    insertById(id: string, data: Record<string, any>[], options?: EntityInsertOptions): Promise<EntityInsertResponse>;
+    /**
+     * Updates data in an entity by entity ID
+     *
+     * @param id - UUID of the entity
+     * @param data - Array of records to update. Each record MUST contain the record Id.
+     * @param options - Update options
+     * @returns Promise resolving to update response
+     * {@link EntityUpdateResponse}
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = await sdk.entities.updateById(<entityId>, [
+     *   { Id: "123", name: "John Updated", age: 31 },
+     *   { Id: "456", name: "Jane Updated", age: 26 }
+     * ]);
+     *
+     * // With options
+     * const result = await sdk.entities.updateById(<entityId>, [
+     *   { Id: "123", name: "John Updated", age: 31 },
+     *   { Id: "456", name: "Jane Updated", age: 26 }
+     * ], {
+     *   expansionLevel: 1,
+     *   failOnFirst: true
+     * });
+     * ```
+     */
+    updateById(id: string, data: EntityRecord[], options?: EntityUpdateOptions): Promise<EntityUpdateResponse>;
+    /**
+     * Deletes data from an entity by entity ID
+     *
+     * @param id - UUID of the entity
+     * @param recordIds - Array of record UUIDs to delete
+     * @param options - Delete options
+     * @returns Promise resolving to delete response
+     * {@link EntityDeleteResponse}
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = await sdk.entities.deleteById(<entityId>, [
+     *   <recordId-1>, <recordId-2>
+     * ]);
+     * ```
+     */
+    deleteById(id: string, recordIds: string[], options?: EntityDeleteOptions): Promise<EntityDeleteResponse>;
+}
+/**
+ * Entity methods interface - defines operations that can be performed on an entity
+ */
+interface EntityMethods {
+    /**
+     * Insert data into this entity
+     *
+     * @param data - Array of records to insert
+     * @param options - Insert options
+     * @returns Promise resolving to insert response
+     */
+    insert(data: Record<string, any>[], options?: EntityInsertOptions): Promise<EntityInsertResponse>;
+    /**
+     * Update data in this entity
+     *
+     * @param data - Array of records to update. Each record MUST contain the record Id,
+     *               otherwise the update will fail.
+     * @param options - Update options
+     * @returns Promise resolving to update response
+     */
+    update(data: EntityRecord[], options?: EntityUpdateOptions): Promise<EntityUpdateResponse>;
+    /**
+     * Delete data from this entity
+     *
+     * @param recordIds - Array of record UUIDs to delete
+     * @param options - Delete options
+     * @returns Promise resolving to delete response
+     */
+    delete(recordIds: string[], options?: EntityDeleteOptions): Promise<EntityDeleteResponse>;
+    /**
+     * Get records from this entity
+     *
+     * @param options - Query options
+     * @returns Promise resolving to query response
+     */
+    getRecords<T extends EntityGetRecordsByIdOptions = EntityGetRecordsByIdOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+}
+/**
+ * Entity with methods combining metadata with operation methods
+ */
+type EntityGetResponse = RawEntityGetResponse & EntityMethods;
+/**
+ * Creates an actionable entity metadata by combining entity with operational methods
+ *
+ * @param entityData - Entity metadata
+ * @param service - The entity service instance
+ * @returns Entity metadata with added methods
+ */
+declare function createEntityWithMethods(entityData: RawEntityGetResponse, service: EntityServiceModel): EntityGetResponse;
+
+/**
+ * Service for interacting with the Data Fabric Entity API
+ */
+declare class EntityService extends BaseService implements EntityServiceModel {
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * Gets entity metadata by entity ID with attached operation methods
+     *
+     * @param id - UUID of the entity
+     * @returns Promise resolving to entity metadata with schema information and operation methods
+     *
+     * @example
+     * ```typescript
+     * // Get entity metadata with methods
+     * const entity = await sdk.entities.getById("<entityId>");
+     *
+     * // Call operations directly on the entity
+     * const records = await entity.getRecords();
+     *
+     * const insertResult = await entity.insert([
+     *   { name: "John", age: 30 }
+     * ]);
+     * ```
+     */
+    getById(id: string): Promise<EntityGetResponse>;
+    /**
+     * Orchestrates all field mapping transformations
+     *
+     * @param metadata - Entity metadata to transform
+     * @private
+     */
+    private applyFieldMappings;
+    /**
+     * Maps SQL field types to friendly EntityFieldTypes
+     *
+     * @param metadata - Entity metadata with fields
+     * @private
+     */
+    private mapFieldTypes;
+    /**
+     * Transforms nested reference objects in field metadata
+     */
+    private transformNestedReferences;
+    /**
+     * Maps external field names to consistent naming
+     *
+     * @param metadata - Entity metadata with externalFields
+     * @private
+     */
+    private mapExternalFields;
+    /**
+     * Gets entity records by entity ID
+     *
+     * @param entityId - UUID of the entity
+     * @param options - Query options including expansionLevel and pagination options
+     * @returns Promise resolving to an array of entity records or paginated response
+     *
+     * @example
+     * ```typescript
+     * // Basic usage (non-paginated)
+     * const records = await sdk.entities.getRecordsById(<entityId>);
+     *
+     * // With expansion level
+     * const records = await sdk.entities.getRecordsById(<entityId>, {
+     *   expansionLevel: 1
+     * });
+     *
+     * // With pagination
+     * const paginatedResponse = await sdk.entities.getRecordsById(<entityId>, {
+     *   pageSize: 50,
+     *   expansionLevel: 1
+     * });
+     *
+     * // Navigate to next page
+     * const nextPage = await sdk.entities.getRecordsById(<entityId>, {
+     *   cursor: paginatedResponse.nextCursor,
+     *   expansionLevel: 1
+     * });
+     * ```
+     */
+    getRecordsById<T extends EntityGetRecordsByIdOptions = EntityGetRecordsByIdOptions>(entityId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+    /**
+     * Inserts data into an entity by entity ID
+     *
+     * @param entityId - UUID of the entity
+     * @param data - Array of records to insert
+     * @param options - Insert options
+     * @returns Promise resolving to insert response
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = await sdk.entities.insertById(<entityId>, [
+     *   { name: "John", age: 30 },
+     *   { name: "Jane", age: 25 }
+     * ]);
+     *
+     * // With options
+     * const result = await sdk.entities.insertById(<entityId>, [
+     *   { name: "John", age: 30 },
+     *   { name: "Jane", age: 25 }
+     * ], {
+     *   expansionLevel: 1,
+     *   failOnFirst: true
+     * });
+     * ```
+     */
+    insertById(id: string, data: Record<string, any>[], options?: EntityInsertOptions): Promise<EntityInsertResponse>;
+    /**
+     * Updates data in an entity by entity ID
+     *
+     * @param entityId - UUID of the entity
+     * @param data - Array of records to update. Each record MUST contain the record Id,
+     *               otherwise the update will fail.
+     * @param options - Update options
+     * @returns Promise resolving to update response
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = await sdk.entities.updateById(<entityId>, [
+     *   { Id: "123", name: "John Updated", age: 31 },
+     *   { Id: "456", name: "Jane Updated", age: 26 }
+     * ]);
+     *
+     * // With options
+     * const result = await sdk.entities.updateById(<entityId>, [
+     *   { Id: "123", name: "John Updated", age: 31 },
+     *   { Id: "456", name: "Jane Updated", age: 26 }
+     * ], {
+     *   expansionLevel: 1,
+     *   failOnFirst: true
+     * });
+     * ```
+     */
+    updateById(id: string, data: EntityRecord[], options?: EntityUpdateOptions): Promise<EntityUpdateResponse>;
+    /**
+     * Deletes data from an entity by entity ID
+     *
+     * @param entityId - UUID of the entity
+     * @param recordIds - Array of record UUIDs to delete
+     * @param options - Delete options
+     * @returns Promise resolving to delete response
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = await sdk.entities.deleteById(<entityId>, [
+     *   <recordId-1>, <recordId-2>
+     * ]);
+     * ```
+     */
+    deleteById(id: string, recordIds: string[], options?: EntityDeleteOptions): Promise<EntityDeleteResponse>;
+    /**
+     * Gets all entities in the system
+     *
+     * @returns Promise resolving to an array of entity metadata
+     *
+     * @example
+     * ```typescript
+     * // Get all entities
+     * const entities = await sdk.entities.getAll();
+     *
+     * // Call operations on an entity
+     * const records = await entities[0].getRecords();
+     * ```
+     */
+    getAll(): Promise<EntityGetResponse[]>;
+}
+
+/**
+ * Maestro Process Types
+ * Types and interfaces for Maestro process management
+ */
+/**
+ * Process information with instance statistics
+ */
+interface MaestroProcessGetAllResponse {
+    /** 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;
+}
+
+/**
+ * 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)
+ */
+interface MaestroProcessesServiceModel {
+    /**
+     * @returns Promise resolving to array of MaestroProcess objects
+     * {@link MaestroProcessGetAllResponse}
+     * @example
+     * ```typescript
+     * // Get all processes
+     * const processes = await sdk.maestro.processes.getAll();
+     *
+     * // Access process information
+     * for (const process of processes) {
+     *   console.log(`Process: ${process.processKey}`);
+     *   console.log(`Running instances: ${process.runningCount}`);
+     *   console.log(`Faulted instances: ${process.faultedCount}`);
+     * }
+     *
+     * ```
+     */
+    getAll(): Promise<MaestroProcessGetAllResponse[]>;
+}
+
+/**
+ * Constants used throughout the pagination system
+ */
+/** Maximum number of items that can be requested in a single page */
+declare const MAX_PAGE_SIZE = 1000;
+/** Default page size when jumpToPage is used without specifying pageSize */
+declare const DEFAULT_PAGE_SIZE = 50;
+/** Default field name for items in a paginated response */
+declare const DEFAULT_ITEMS_FIELD = "value";
+/** Default field name for total count in a paginated response */
+declare const DEFAULT_TOTAL_COUNT_FIELD = "@odata.count";
+/**
+ * Limits the page size to the maximum allowed value
+ * @param pageSize - Requested page size
+ * @returns Limited page size value
+ */
+declare function getLimitedPageSize(pageSize?: number): 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;
+}
+
+interface CollectionResponse<T> {
+    value: T[];
+}
+/**
+ * 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;
+}
+
+/**
+ * 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)
+ */
+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 sdk.maestro.processes.instances.getAll();
+     *
+     * // Cancel faulted instances using methods directly on instances
+     * for (const instance of instances.items) {
+     *   if (instance.latestRunStatus === 'Faulted') {
+     *     await instance.cancel({ comment: 'Cancelling faulted instance' });
+     *   }
+     * }
+     *
+     * // With filtering
+     * const instances = await sdk.maestro.processes.instances.getAll({
+     *   processKey: 'MyProcess'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.maestro.processes.instances.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.maestro.processes.instances.getAll({ cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getAll<T extends ProcessInstanceGetAllWithPaginationOptions = ProcessInstanceGetAllWithPaginationOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessInstanceGetResponse> : NonPaginatedResponse<ProcessInstanceGetResponse>>;
+    /**
+     * Get a process instance by ID with operation methods (cancel, pause, resume)
+     * @param id The ID of the instance to retrieve
+     * @param folderKey The folder key for authorization
+     * @returns Promise resolving to a process instance
+     * {@link ProcessInstanceGetResponse}
+     * @example
+     * ```typescript
+     * // Get a specific process instance
+     * const instance = await sdk.maestro.processes.instances.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 sdk.maestro.processes.instances.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 sdk.maestro.processes.instances.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 sdk.maestro.processes.instances.cancel(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     *
+     * if (result.success) {
+     *   console.log(`Instance ${result.data.instanceId} now has status: ${result.data.status}`);
+     * }
+     *
+     * // Cancel with a comment
+     * const result = await sdk.maestro.processes.instances.cancel(
+     *   <instanceId>,
+     *   <folderKey>,
+     *   { comment: <comment> }
+     * );
+     *
+     * // Cancel multiple faulted instances
+     * const instances = await sdk.maestro.processes.instances.getAll({
+     *   latestRunStatus: "Faulted"
+     * });
+     *
+     * for (const instance of instances.items) {
+     *   const result = await sdk.maestro.processes.instances.cancel(
+     *     instance.instanceId,
+     *     instance.folderKey,
+     *     { comment: <comment> }
+     *   );
+     *
+     *   if (result.success) {
+     *     console.log(`Cancelled instance: ${result.data.instanceId}`);
+     *   }
+     * }
+     * ```
+     */
+    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 sdk.maestro.processes.instances.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 variables = await sdk.maestro.processes.instances.getVariables(
+     *   <instanceId>,
+     *   <folderKey>,
+     *   { parentElementId: <parentElementId> }
+     * );
+     * ```
+     */
+    getVariables(instanceId: string, folderKey: string, options?: ProcessInstanceGetVariablesOptions): Promise<ProcessInstanceGetVariablesResponse>;
+}
+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>>;
+}
+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 interacting with Maestro Processes
+ */
+declare class MaestroProcessesService extends BaseService implements MaestroProcessesServiceModel {
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * Get all processes with their instance statistics
+     * @returns Promise resolving to array of MaestroProcess objects
+     *
+     * @example
+     * ```typescript
+     * // Get all processes
+     * const processes = await sdk.maestro.processes.getAll();
+     *
+     * // Access process information
+     * for (const process of processes) {
+     *   console.log(`Process: ${process.processKey}`);
+     *   console.log(`Running instances: ${process.runningCount}`);
+     *   console.log(`Faulted instances: ${process.faultedCount}`);
+     * }
+     *
+     * ```
+     */
+    getAll(): Promise<MaestroProcessGetAllResponse[]>;
+}
+
+declare class ProcessInstancesService extends BaseService implements ProcessInstancesServiceModel {
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * Get all process instances with optional filtering and pagination
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options Query parameters for filtering instances and pagination
+     * @returns Promise resolving to process instances or paginated result
+     *
+     * @example
+     * ```typescript
+     * // Get all instances (non-paginated)
+     * const instances = await sdk.maestro.processes.instances.getAll();
+     *
+     * // Cancel faulted instances using methods directly on instances
+     * for (const instance of instances.items) {
+     *   if (instance.latestRunStatus === 'Faulted') {
+     *     await instance.cancel({ comment: 'Cancelling faulted instance' });
+     *   }
+     * }
+     *
+     * // With filtering
+     * const instances = await sdk.maestro.processes.instances.getAll({
+     *   processKey: 'MyProcess'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.maestro.processes.instances.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.maestro.processes.instances.getAll({ cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getAll<T extends ProcessInstanceGetAllWithPaginationOptions = ProcessInstanceGetAllWithPaginationOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessInstanceGetResponse> : NonPaginatedResponse<ProcessInstanceGetResponse>>;
+    /**
+     * Get a process instance by ID with operation methods (cancel, pause, resume)
+     * @param id The ID of the instance to retrieve
+     * @param folderKey The folder key for authorization
+     * @returns Promise<ProcessInstanceGetResponse>
+     */
+    getById(id: string, folderKey: string): Promise<ProcessInstanceGetResponse>;
+    /**
+     * Get execution history (spans) for a process instance
+     * @param instanceId The ID of the instance to get history for
+     * @returns Promise<ProcessInstanceExecutionHistoryResponse[]>
+     */
+    getExecutionHistory(instanceId: string): Promise<ProcessInstanceExecutionHistoryResponse[]>;
+    /**
+     * Get BPMN XML file for a process instance
+     * @param instanceId The ID of the instance to get BPMN for
+     * @param folderKey The folder key for authorization
+     * @returns Promise<BpmnXmlString> The BPMN XML contents as a string
+     */
+    getBpmn(instanceId: string, folderKey: string): Promise<BpmnXmlString>;
+    /**
+     * Cancel a process instance
+     * @param instanceId The ID of the instance to cancel
+     * @param folderKey The folder key for authorization
+     * @param options Optional cancellation options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    cancel(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Pause a process instance
+     * @param instanceId The ID of the instance to pause
+     * @param folderKey The folder key for authorization
+     * @param options Optional pause options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    pause(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Resume a process instance
+     * @param instanceId The ID of the instance to resume
+     * @param folderKey The folder key for authorization
+     * @param options Optional resume options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    resume(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Parses BPMN XML to extract variable metadata from uipath:inputOutput elements
+     * @private
+     * @param bpmnXml The BPMN XML string
+     * @returns Map of variable ID to metadata
+     */
+    private parseBpmnVariables;
+    /**
+     * Extracts element names from BPMN XML and maps them to their element IDs
+     * @private
+     * @param bpmnXml The BPMN XML string
+     * @returns Map of elementId to element name
+     */
+    private getVariableSource;
+    /**
+     * Enriches global variables with metadata from BPMN
+     * @private
+     * @param globals The raw globals object from API response
+     * @param variableMetadata The parsed BPMN variable metadata
+     * @returns Array of global variables
+     */
+    private transformGlobalVariables;
+    /**
+     * Get global variables for a process instance
+     * @param instanceId The ID of the instance to get variables for
+     * @param folderKey The folder key for authorization
+     * @param options Optional options including parentElementId to filter by parent element
+     * @returns Promise<ProcessInstanceGetVariablesResponse>
+     */
+    getVariables(instanceId: string, folderKey: string, options?: ProcessInstanceGetVariablesOptions): Promise<ProcessInstanceGetVariablesResponse>;
+}
+
+/**
+ * Base service for services that need folder-specific functionality
+ */
+declare class FolderScopedService extends BaseService {
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * Gets resources in a folder with optional query parameters
+     *
+     * @param endpoint - API endpoint to call
+     * @param folderId - required folder ID
+     * @param options - Query options
+     * @param transformFn - Optional function to transform the response data
+     * @returns Promise resolving to an array of resources
+     */
+    protected _getByFolder<T, R = T>(endpoint: string, folderId: number, options?: Record<string, any>, transformFn?: (item: T) => R): Promise<R[]>;
+}
+
+/**
+ * Enum for Asset Value Scope
+ */
+declare enum AssetValueScope {
+    Global = "Global",
+    PerRobot = "PerRobot"
+}
+/**
+ * Enum for Asset Value Type
+ */
+declare enum AssetValueType {
+    DBConnectionString = "DBConnectionString",
+    HttpConnectionString = "HttpConnectionString",
+    Text = "Text",
+    Bool = "Bool",
+    Integer = "Integer",
+    Credential = "Credential",
+    WindowsCredential = "WindowsCredential",
+    KeyValueList = "KeyValueList",
+    Secret = "Secret"
+}
+/**
+ * Interface for key-value pair used in assets
+ */
+interface CustomKeyValuePair {
+    key?: string;
+    value?: string;
+}
+/**
+ * Interface for asset response
+ */
+interface AssetGetResponse {
+    key: string;
+    name: string;
+    id: number;
+    canBeDeleted: boolean;
+    valueScope: AssetValueScope;
+    valueType: AssetValueType;
+    value: string | null;
+    credentialStoreId: number | null;
+    keyValueList: CustomKeyValuePair[];
+    hasDefaultValue: boolean;
+    description: string | null;
+    foldersCount: number;
+    lastModifiedTime: string | null;
+    lastModifierUserId: number | null;
+    createdTime: string;
+    creatorUserId: number;
+}
+/**
+ * Options for getting assets across folders
+ */
+type AssetGetAllOptions = RequestOptions & PaginationOptions & {
+    /**
+     * Optional folder ID to filter assets by folder
+     */
+    folderId?: number;
+};
+/**
+ * Options for getting a single asset by ID
+ */
+type AssetGetByIdOptions = BaseOptions;
+
+/**
+ * Service for managing UiPath Assets.
+ *
+ * Assets are key-value pairs that can be used to store configuration data, credentials, and other settings used by automation processes. [UiPath Assets Guide](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/about-assets)
+ */
+interface AssetServiceModel {
+    /**
+     * Gets all assets across folders with optional filtering
+     *
+     * @param options Query options including optional folderId and pagination options
+     * @returns Promise resolving to either an array of assets NonPaginatedResponse<AssetGetResponse> or a PaginatedResponse<AssetGetResponse> when pagination options are used.
+     * {@link AssetGetResponse}
+     * @example
+     * ```typescript
+     * // Standard array return
+     * const assets = await sdk.assets.getAll();
+     *
+     * // With folder
+     * const folderAssets = await sdk.assets.getAll({ folderId: <folderId> });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.assets.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.assets.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.assets.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends AssetGetAllOptions = AssetGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<AssetGetResponse> : NonPaginatedResponse<AssetGetResponse>>;
+    /**
+     * Gets a single asset by ID
+     *
+     * @param id - Asset ID
+     * @param folderId - Required folder ID
+     * @param options - Optional query parameters (expand, select)
+     * @returns Promise resolving to a single asset
+     * {@link AssetGetResponse}
+     * @example
+     * ```typescript
+     * // Get asset by ID
+     * const asset = await sdk.assets.getById(<assetId>, <folderId>);
+     * ```
+     */
+    getById(id: number, folderId: number, options?: AssetGetByIdOptions): Promise<AssetGetResponse>;
+}
+
+/**
+ * Service for interacting with UiPath Orchestrator Assets API
+ */
+declare class AssetService extends FolderScopedService implements AssetServiceModel {
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * Gets all assets across folders with optional filtering and folder scoping
+     *
+     * @signature getAll(options?) -> Promise<AssetGetResponse[]>
+     * @param options Query options including optional folderId and pagination options
+     * @returns Promise resolving to array of assets or paginated response
+     *
+     * @example
+     * ```typescript
+     * // Standard array return
+     * const assets = await sdk.assets.getAll();
+     *
+     * // With folder
+     * const folderAssets = await sdk.assets.getAll({ folderId: 123 });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.assets.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.assets.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.assets.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends AssetGetAllOptions = AssetGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<AssetGetResponse> : NonPaginatedResponse<AssetGetResponse>>;
+    /**
+     * Gets a single asset by ID
+     *
+     * @param id - Asset ID
+     * @param folderId - Required folder ID
+     * @param options - Optional query parameters (expand, select)
+     * @returns Promise resolving to a single asset
+     *
+     * @example
+     * ```typescript
+     * // Get asset by ID
+     * const asset = await sdk.assets.getById(123, 456);
+     * ```
+     */
+    getById(id: number, folderId: number, options?: AssetGetByIdOptions): Promise<AssetGetResponse>;
+}
+
+declare enum BucketOptions {
+    None = "None",
+    ReadOnly = "ReadOnly",
+    AuditReadAccess = "AuditReadAccess",
+    AccessDataThroughOrchestrator = "AccessDataThroughOrchestrator"
+}
+interface BucketGetResponse {
+    id: number;
+    name: string;
+    description: string | null;
+    identifier: string;
+    storageProvider: string | null;
+    storageParameters: string | null;
+    storageContainer: string | null;
+    options: BucketOptions;
+    credentialStoreId: number | null;
+    externalName: string | null;
+    password: string | null;
+    foldersCount: number;
+}
+type BucketGetAllOptions = RequestOptions & PaginationOptions & {
+    folderId?: number;
+};
+type BucketGetByIdOptions = BaseOptions;
+/**
+ * Maps header names to their values
+ *
+ * @example
+ * ```typescript
+ * {
+ *   "x-ms-blob-type": "BlockBlob"
+ * }
+ * ```
+ */
+type ResponseDictionary = Record<string, string>;
+/**
+ * Response from the GetReadUri API
+ */
+interface BucketGetUriResponse {
+    /**
+     * The URI for accessing the blob file
+     */
+    uri: string;
+    /**
+     * HTTP method to use with the URI
+     */
+    httpMethod: string;
+    /**
+     * Whether authentication is required to access the URI
+     */
+    requiresAuth: boolean;
+    /**
+     * Headers to be included in the request
+     */
+    headers: ResponseDictionary;
+}
+interface BucketGetUriOptions extends BaseOptions {
+    /**
+     * The ID of the bucket
+     */
+    bucketId: number;
+    /**
+     * The ID of the folder
+     */
+    folderId: number;
+    /**
+     * The full path to the BlobFile
+     */
+    path: string;
+    /**
+     * URL expiration time in minutes (0 for default)
+     */
+    expiryInMinutes?: number;
+}
+/**
+ * Request options for getting a read URI for a file in a bucket
+ */
+type BucketGetReadUriOptions = BucketGetUriOptions;
+/**
+ * Request options for getting a write URI for a file in a bucket
+ */
+interface BucketGetWriteUriOptions extends BucketGetUriOptions {
+    /**
+     * ContentType for S3 access policy
+     */
+    contentType?: string;
+}
+/**
+ * Request options for getting files in a bucket
+ */
+interface BucketGetFileMetaDataOptions {
+    /**
+     * The path prefix to filter files by
+     */
+    prefix?: string;
+}
+/**
+ * Request options for getting files in a bucket with pagination support
+ */
+type BucketGetFileMetaDataWithPaginationOptions = BucketGetFileMetaDataOptions & PaginationOptions;
+/**
+ * Response from the GetFiles API
+ */
+interface BucketGetFileMetaDataResponse {
+    /**
+     * Array of blob items in the bucket
+     */
+    blobItems: BlobItem[];
+    /**
+     * Token for retrieving the next set of results
+     */
+    continuationToken: string | null;
+}
+/**
+ * Represents a file or blob in a bucket
+ */
+interface BlobItem {
+    /**
+     * Full path to the blob
+     */
+    path: string;
+    /**
+     * Content type of the blob
+     */
+    contentType: string;
+    /**
+     * Size of the blob in bytes
+     */
+    size: number;
+    /**
+     * Last modified timestamp
+     */
+    lastModified: string | null;
+}
+/**
+ * Options for uploading files to a bucket
+ */
+interface BucketUploadFileOptions {
+    /**
+     * The ID of the bucket to upload to
+     */
+    bucketId: number;
+    /**
+     * The folder/organization unit ID for context
+     */
+    folderId: number;
+    /**
+     * Path where the file should be stored in the bucket
+     */
+    path: string;
+    /**
+     * File content to upload
+     */
+    content: Blob | Buffer | File;
+    /**
+     * Optional MIME type of the file
+     * If not provided, it will be auto-detected
+     */
+    contentType?: string;
+}
+/**
+ * Response from file upload operations
+ */
+interface BucketUploadResponse {
+    /**
+     * Whether the upload was successful
+     */
+    success: boolean;
+    /**
+     * HTTP status code from the upload operation
+     */
+    statusCode: number;
+}
+
+/**
+ * Service for managing UiPath storage Buckets.
+ *
+ * Buckets are cloud storage containers that can be used to store and manage files used by automation processes. [UiPath Buckets Guide](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/about-storage-buckets)
+ */
+interface BucketServiceModel {
+    /**
+     * Gets all buckets across folders with optional filtering
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with data and totalCount (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 and pagination options
+     * @returns Promise resolving to either an array of buckets NonPaginatedResponse<BucketGetResponse> or a PaginatedResponse<BucketGetResponse> when pagination options are used.
+     * {@link BucketGetResponse}
+     * @example
+     * ```typescript
+     * // Get all buckets across folders
+     * const buckets = await sdk.buckets.getAll();
+     *
+     * // Get buckets within a specific folder
+     * const buckets = await sdk.buckets.getAll({
+     *   folderId: <folderId>
+     * });
+     *
+     * // Get buckets with filtering
+     * const buckets = await sdk.buckets.getAll({
+     *   filter: "name eq 'MyBucket'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.buckets.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.buckets.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.buckets.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends BucketGetAllOptions = BucketGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<BucketGetResponse> : NonPaginatedResponse<BucketGetResponse>>;
+    /**
+     * Gets a single bucket by ID
+     *
+     * @param bucketId - Bucket ID
+     * @param folderId - Required folder ID
+     * @param options - Optional query parameters
+     * @returns Promise resolving to a bucket definition
+     * {@link BucketGetResponse}
+     * @example
+     * ```typescript
+     * // Get bucket by ID
+     * const bucket = await sdk.buckets.getById(<bucketId>, <folderId>);
+     * ```
+     */
+    getById(bucketId: number, folderId: number, options?: BucketGetByIdOptions): Promise<BucketGetResponse>;
+    /**
+     * Gets metadata for files in a bucket 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 bucketId - The ID of the bucket to get file metadata from
+     * @param folderId - Required folder ID for organization unit context
+     * @param options - Optional parameters for filtering, pagination and access URL generation
+     * @returns Promise resolving to either an array of files metadata NonPaginatedResponse<BlobItem> or a PaginatedResponse<BlobItem> when pagination options are used.
+     * {@link BlobItem}
+     * @example
+     * ```typescript
+     * // Get metadata for all files in a bucket
+     * const fileMetadata = await sdk.buckets.getFileMetaData(<bucketId>, <folderId>);
+     *
+     * // Get file metadata with a specific prefix
+     * const fileMetadata = await sdk.buckets.getFileMetaData(<bucketId>, <folderId>, {
+     *   prefix: '/folder1'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.buckets.getFileMetaData(<bucketId>, <folderId>, { pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.buckets.getFileMetaData(<bucketId>, <folderId>, { cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getFileMetaData<T extends BucketGetFileMetaDataWithPaginationOptions = BucketGetFileMetaDataWithPaginationOptions>(bucketId: number, folderId: number, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<BlobItem> : NonPaginatedResponse<BlobItem>>;
+    /**
+     * Gets a direct download URL for a file in the bucket
+     *
+     * @param options - Contains bucketId, folderId, file path and optional expiry time
+     * @returns Promise resolving to blob file access information
+     * {@link BucketGetUriResponse}
+     * @example
+     * ```typescript
+     * // Get download URL for a file
+     * const fileAccess = await sdk.buckets.getReadUri({
+     *   bucketId: <bucketId>,
+     *   folderId: <folderId>,
+     *   path: '/folder/file.pdf'
+     * });
+     * ```
+     */
+    getReadUri(options: BucketGetReadUriOptions): Promise<BucketGetUriResponse>;
+    /**
+     * Uploads a file to a bucket
+     *
+     * @param options - Options for file upload including bucket ID, folder ID, path, content, and optional parameters
+     * @returns Promise resolving bucket upload response
+     * {@link BucketUploadResponse}
+     * @example
+     * ```typescript
+     * // Upload a file from browser
+     * const file = new File(['file content'], 'example.txt');
+     * const result = await sdk.buckets.uploadFile({
+     *   bucketId: <bucketId>,
+     *   folderId: <folderId>,
+     *   path: '/folder/example.txt',
+     *   content: file
+     * });
+     *
+     * // In Node env with explicit content type
+     * const buffer = Buffer.from('file content');
+     * const result = await sdk.buckets.uploadFile({
+     *   bucketId: <bucketId>,
+     *   folderId: <folderId>,
+     *   path: '/folder/example.txt',
+     *   content: buffer,
+     *   contentType: 'text/plain'
+     * });
+     * ```
+     */
+    uploadFile(options: BucketUploadFileOptions): Promise<BucketUploadResponse>;
+}
+
+declare class BucketService extends FolderScopedService implements BucketServiceModel {
+    protected readonly tokenManager: TokenManager;
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * Gets a bucket by ID
+     * @param bucketId - The ID of the bucket to retrieve
+     * @param folderId - Folder ID for organization unit context
+     * @param options - Optional query parameters (expand, select)
+     * @returns Promise resolving to the bucket
+     *
+     * @example
+     * ```typescript
+     * // Get bucket by ID
+     * const bucket = await sdk.buckets.getById(123, 456);
+     * ```
+     */
+    getById(id: number, folderId: number, options?: BucketGetByIdOptions): Promise<BucketGetResponse>;
+    /**
+     * Gets all buckets across folders with optional filtering and folder scoping
+     *
+     * The method returns either:
+     * - An array of buckets (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options - Query options including optional folderId
+     * @returns Promise resolving to an array of buckets or paginated result
+     *
+     * @example
+     * ```typescript
+     * // Get all buckets across folders
+     * const buckets = await sdk.buckets.getAll();
+     *
+     * // Get buckets within a specific folder
+     * const buckets = await sdk.buckets.getAll({
+     *   folderId: 123
+     * });
+     *
+     * // Get buckets with filtering
+     * const buckets = await sdk.buckets.getAll({
+     *   filter: "name eq 'MyBucket'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.buckets.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.buckets.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.buckets.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends BucketGetAllOptions = BucketGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<BucketGetResponse> : NonPaginatedResponse<BucketGetResponse>>;
+    /**
+     * Gets metadata for files in a bucket 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 bucketId - The ID of the bucket to get file metadata from
+     * @param folderId - Required folder ID for organization unit context
+     * @param options - Optional parameters for filtering, pagination and access URL generation
+     * @returns Promise resolving to the list of file metadata in the bucket or paginated result
+     *
+     * @example
+     * ```typescript
+     * // Get metadata for all files in a bucket
+     * const fileMetadata = await sdk.buckets.getFileMetaData(123, 456);
+     *
+     * // Get file metadata with a specific prefix
+     * const fileMetadata = await sdk.buckets.getFileMetaData(123, 456, {
+     *   prefix: '/folder1'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.buckets.getFileMetaData(123, 456, { pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.buckets.getFileMetaData(123, 456, { cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getFileMetaData<T extends BucketGetFileMetaDataWithPaginationOptions = BucketGetFileMetaDataWithPaginationOptions>(bucketId: number, folderId: number, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<BlobItem> : NonPaginatedResponse<BlobItem>>;
+    /**
+     * Uploads a file to a bucket
+     *
+     * @param options - Options for file upload including bucket ID, folder ID, path, content, and optional parameters
+     * @returns Promise resolving to a response with success status and HTTP status code
+     *
+     * @example
+     * ```typescript
+     * // Upload a file from browser
+     * const file = new File(['file content'], 'example.txt');
+     * const result = await sdk.buckets.uploadFile({
+     *   bucketId: 123,
+     *   folderId: 456,
+     *   path: '/folder/example.txt',
+     *   content: file
+     * });
+     *
+     * // In Node env with explicit content type
+     * const buffer = Buffer.from('file content');
+     * const result = await sdk.buckets.uploadFile({
+     *   bucketId: 123,
+     *   folderId: 456,
+     *   path: '/folder/example.txt',
+     *   content: buffer,
+     *   contentType: 'text/plain'
+     * });
+     * ```
+     */
+    uploadFile(options: BucketUploadFileOptions): Promise<BucketUploadResponse>;
+    /**
+     * Determines the content type of the file based on the content and path
+     * Uses a hybrid approach:
+     * 1. Checks Blob/File type if available (browser)
+     * 2. Uses content-based detection with file-type (primarily Node.js)
+     * 3. Falls back to extension-based detection with mime-types
+     * 4. Finally defaults to application/octet-stream
+     *
+     * @param content - The file content
+     * @param path - The file path
+     * @returns The determined content type or default
+     */
+    private _determineContentType;
+    /**
+     * Uploads content to the provided URI
+     * @param uriResponse - Response from getWriteUri containing URL and headers
+     * @param content - The content to upload
+     * @param contentType - The content type of the file
+     * @returns The response from the upload request with status info
+     */
+    private _uploadToUri;
+    /**
+     * Private method to handle common URI request logic
+     * @param endpoint - The API endpoint to call
+     * @param bucketId - The bucket ID
+     * @param folderId - The folder ID
+     * @param path - The file path
+     * @param queryOptions - Additional query parameters
+     * @returns Promise resolving to blob file access information
+     */
+    private _getUri;
+    /**
+     * Gets a direct download URL for a file in the bucket
+     *
+     * @param options - Contains bucketId, folderId, file path and optional expiry time
+     * @returns Promise resolving to blob file access information
+     *
+     * @example
+     * ```typescript
+     * // Get download URL for a file
+     * const fileAccess = await sdk.buckets.getReadUri({
+     *   bucketId: 123,
+     *   folderId: 456,
+     *   path: '/folder/file.pdf'
+     * });
+     * ```
+     */
+    getReadUri(options: BucketGetReadUriOptions): Promise<BucketGetUriResponse>;
+    /**
+     * Gets a direct upload URL for a file in the bucket
+     *
+     * @param options - Contains bucketId, folderId, file path, optional expiry time and content type
+     * @returns Promise resolving to blob file access information
+     */
+    private _getWriteUri;
+}
+
+/**
+ * Enum for package types
+ */
+declare enum PackageType {
+    Undefined = "Undefined",
+    Process = "Process",
+    ProcessOrchestration = "ProcessOrchestration",
+    WebApp = "WebApp",
+    Agent = "Agent",
+    TestAutomationProcess = "TestAutomationProcess",
+    Api = "Api",
+    MCPServer = "MCPServer",
+    BusinessRules = "BusinessRules"
+}
+/**
+ * Enum for job priority
+ */
+declare enum JobPriority {
+    Low = "Low",
+    Normal = "Normal",
+    High = "High"
+}
+/**
+ * Enum for target framework
+ */
+declare enum TargetFramework {
+    Legacy = "Legacy",
+    Windows = "Windows",
+    Portable = "Portable"
+}
+/**
+ * Enum for robot size
+ */
+declare enum RobotSize {
+    Small = "Small",
+    Standard = "Standard",
+    Medium = "Medium",
+    Large = "Large"
+}
+/**
+ * Enum for remote control access
+ */
+declare enum RemoteControlAccess {
+    None = "None",
+    ReadOnly = "ReadOnly",
+    Full = "Full"
+}
+/**
+ * Enum for process start strategy
+ */
+declare enum StartStrategy {
+    All = "All",
+    Specific = "Specific",
+    RobotCount = "RobotCount",
+    JobsCount = "JobsCount",
+    ModernJobsCount = "ModernJobsCount"
+}
+/**
+ * Enum for package source type
+ */
+declare enum PackageSourceType {
+    Manual = "Manual",
+    Schedule = "Schedule",
+    Queue = "Queue",
+    StudioWeb = "StudioWeb",
+    IntegrationTrigger = "IntegrationTrigger",
+    StudioDesktop = "StudioDesktop",
+    AutomationOpsPipelines = "AutomationOpsPipelines",
+    Apps = "Apps",
+    SAP = "SAP",
+    HttpTrigger = "HttpTrigger",
+    HttpTriggerWithCallback = "HttpTriggerWithCallback",
+    RobotAPI = "RobotAPI",
+    Assistant = "Assistant",
+    CommandLine = "CommandLine",
+    RobotNetAPI = "RobotNetAPI",
+    Autopilot = "Autopilot",
+    TestManager = "TestManager",
+    AgentService = "AgentService",
+    ProcessOrchestration = "ProcessOrchestration",
+    PluginEcosystem = "PluginEcosystem",
+    PerformanceTesting = "PerformanceTesting",
+    AgentHub = "AgentHub",
+    ApiWorkflow = "ApiWorkflow"
+}
+/**
+ * Enum for stop strategy
+ */
+declare enum StopStrategy {
+    SoftStop = "SoftStop",
+    Kill = "Kill"
+}
+/**
+ * Interface for Job Attachment
+ */
+interface JobAttachment {
+    attachmentId: string;
+    jobKey?: string;
+    category?: string;
+    attachmentName?: string;
+}
+/**
+ * Interface for common process properties shared across multiple interfaces
+ */
+interface ProcessProperties {
+    jobPriority?: JobPriority;
+    specificPriorityValue?: number;
+    inputArguments?: string;
+    environmentVariables?: string;
+    entryPointPath?: string;
+    remoteControlAccess?: RemoteControlAccess;
+    requiresUserInteraction?: boolean;
+}
+/**
+ * Interface for common folder properties
+ */
+interface FolderProperties {
+    folderId?: number;
+    folderName?: string;
+}
+/**
+ * Base interface for process start request
+ */
+interface BaseProcessStartRequest extends ProcessProperties {
+    strategy?: StartStrategy;
+    robotIds?: number[];
+    machineSessionIds?: number[];
+    noOfRobots?: number;
+    jobsCount?: number;
+    source?: PackageSourceType;
+    runtimeType?: string;
+    inputFile?: string;
+    reference?: string;
+    attachments?: JobAttachment[];
+    targetFramework?: TargetFramework;
+    resumeOnSameContext?: boolean;
+    batchExecutionKey?: string;
+    stopProcessExpression?: string;
+    stopStrategy?: StopStrategy;
+    killProcessExpression?: string;
+    alertPendingExpression?: string;
+    alertRunningExpression?: string;
+    runAsMe?: boolean;
+    parentOperationId?: string;
+}
+/**
+ * Interface for start process request with processKey
+ */
+interface ProcessStartRequestWithKey extends BaseProcessStartRequest {
+    processKey: string;
+    processName?: string;
+}
+/**
+ * Interface for start process request with processName
+ */
+interface ProcessStartRequestWithName extends BaseProcessStartRequest {
+    processKey?: string;
+    processName: string;
+}
+/**
+ * Interface for start process request
+ * Either processKey or processName must be provided
+ */
+type ProcessStartRequest = ProcessStartRequestWithKey | ProcessStartRequestWithName;
+/**
+ * Interface for robot metadata
+ */
+interface RobotMetadata {
+    id: number;
+    name?: string;
+    username?: string;
+}
+/**
+ * Interface for machine
+ */
+interface Machine {
+    id: number;
+    name?: string;
+}
+/**
+ * Interface for job error
+ */
+interface JobError {
+    code?: string;
+    title?: string;
+    detail?: string;
+    category?: string;
+    status?: number;
+    timestamp?: string;
+}
+/**
+ * Enum for job type
+ */
+declare enum JobType {
+    Unattended = "Unattended",
+    Attended = "Attended",
+    ServerlessGeneric = "ServerlessGeneric"
+}
+/**
+ * Interface for argument metadata
+ */
+interface ArgumentMetadata {
+    input?: string;
+    output?: string;
+}
+/**
+ * Interface for job response
+ */
+interface ProcessStartResponse extends ProcessProperties, FolderProperties {
+    key: string;
+    startTime: string | null;
+    endTime: string | null;
+    state: JobState;
+    source: string;
+    sourceType: string;
+    batchExecutionKey: string;
+    info: string | null;
+    createdTime: string;
+    startingScheduleId: number | null;
+    processName: string;
+    type: JobType;
+    inputFile: string | null;
+    outputArguments: string | null;
+    outputFile: string | null;
+    hostMachineName: string | null;
+    persistenceId: string | null;
+    resumeVersion: number | null;
+    stopStrategy: StopStrategy | null;
+    runtimeType: string;
+    processVersionId: number | null;
+    reference: string;
+    packageType: PackageType;
+    machine?: Machine;
+    resumeOnSameContext: boolean;
+    localSystemAccount: string;
+    orchestratorUserIdentity: string | null;
+    startingTriggerId: string | null;
+    maxExpectedRunningTimeSeconds: number | null;
+    parentJobKey: string | null;
+    resumeTime: string | null;
+    lastModifiedTime: string | null;
+    jobError: JobError | null;
+    errorCode: string | null;
+    robot?: RobotMetadata;
+    id: number;
+}
+/**
+ * Interface for process response
+ */
+interface ProcessGetResponse extends ProcessProperties, FolderProperties {
+    key: string;
+    packageKey: string;
+    packageVersion: string;
+    isLatestVersion: boolean;
+    isPackageDeleted: boolean;
+    description: string;
+    name: string;
+    entryPointId: number;
+    packageType: PackageType;
+    supportsMultipleEntryPoints: boolean;
+    isConversational: boolean | null;
+    minRequiredRobotVersion: string | null;
+    isCompiled: boolean;
+    arguments: ArgumentMetadata;
+    autoUpdate: boolean;
+    hiddenForAttendedUser: boolean;
+    feedId: string;
+    folderKey: string;
+    targetFramework: TargetFramework;
+    robotSize: RobotSize | null;
+    lastModifiedTime: string | null;
+    lastModifierUserId: number | null;
+    createdTime: string;
+    creatorUserId: number;
+    id: number;
+}
+/**
+ * Options for getting processes across folders
+ */
+type ProcessGetAllOptions = RequestOptions & PaginationOptions & {
+    /**
+     * Optional folder ID to filter processes by folder
+     */
+    folderId?: number;
+};
+/**
+ * Options for getting a single process by ID
+ */
+type ProcessGetByIdOptions = BaseOptions;
+
+/**
+ * Service for managing and executing UiPath Automation Processes.
+ *
+ * Processes (also known as automations or workflows) are the core units of automation in UiPath, representing sequences of activities that perform specific business tasks. [UiPath Processes Guide](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/about-processes)
+ */
+interface ProcessServiceModel {
+    /**
+     * Gets all processes across folders with optional filtering
+     * Returns a NonPaginatedResponse with data and totalCount when no pagination parameters are provided,
+     * or a PaginatedResponse when any pagination parameter is provided
+     *
+     * @param options - Query options including optional folderId and pagination options
+     * @returns Promise resolving to either an array of processes NonPaginatedResponse<ProcessGetResponse> or a PaginatedResponse<ProcessGetResponse> when pagination options are used.
+     * {@link ProcessGetResponse}
+     * @example
+     * ```typescript
+     * // Standard array return
+     * const processes = await sdk.processes.getAll();
+     *
+     * // Get processes within a specific folder
+     * const processes = await sdk.processes.getAll({
+     *   folderId: <folderId>
+     * });
+     *
+     * // Get processes with filtering
+     * const processes = await sdk.processes.getAll({
+     *   filter: "name eq 'MyProcess'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.processes.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.processes.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.processes.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends ProcessGetAllOptions = ProcessGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessGetResponse> : NonPaginatedResponse<ProcessGetResponse>>;
+    /**
+     * Gets a single process by ID
+     *
+     * @param id - Process ID
+     * @param folderId - Required folder ID
+     * @param options - Optional query parameters
+     * @returns Promise resolving to a single process
+     * {@link ProcessGetResponse}
+     * @example
+     * ```typescript
+     * // Get process by ID
+     * const process = await sdk.processes.getById(<processId>, <folderId>);
+     * ```
+     */
+    getById(id: number, folderId: number, options?: ProcessGetByIdOptions): Promise<ProcessGetResponse>;
+    /**
+     * Starts a process with the specified configuration
+     *
+     * @param request - Process start configuration
+     * @param folderId - Required folder ID
+     * @param options - Optional request options
+     * @returns Promise resolving to array of started process instances
+     * {@link ProcessStartResponse}
+     * @example
+     * ```typescript
+     * // Start a process by process key
+     * const process = await sdk.processes.start({
+     *   processKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+     * }, <folderId>); // folderId is required
+     *
+     * // Start a process by name with specific robots
+     * const process = await sdk.processes.start({
+     *   processName: "MyProcess"
+     * }, <folderId>); // folderId is required
+     * ```
+     */
+    start(request: ProcessStartRequest, folderId: number, options?: RequestOptions): Promise<ProcessStartResponse[]>;
+}
+
+/**
+ * Service for interacting with UiPath Orchestrator Processes API
+ */
+declare class ProcessService extends BaseService implements ProcessServiceModel {
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * Gets all processes across folders with optional filtering and folder scoping
+     *
+     * The method returns either:
+     * - An array of processes (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options - Query options including optional folderId
+     * @returns Promise resolving to an array of processes or paginated result
+     *
+     * @example
+     * ```typescript
+     * // Standard array return
+     * const processes = await sdk.processes.getAll();
+     *
+     * // Get processes within a specific folder
+     * const processes = await sdk.processes.getAll({
+     *   folderId: 123
+     * });
+     *
+     * // Get processes with filtering
+     * const processes = await sdk.processes.getAll({
+     *   filter: "name eq 'MyProcess'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.processes.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.processes.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.processes.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends ProcessGetAllOptions = ProcessGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessGetResponse> : NonPaginatedResponse<ProcessGetResponse>>;
+    /**
+     * Starts a process execution (job)
+     *
+     * @param request - Process start request body
+     * @param folderId - Required folder ID
+     * @param options - Optional query parameters
+     * @returns Promise resolving to the created jobs
+     *
+     * @example
+     * ```typescript
+     * // Start a process by process key
+     * const jobs = await sdk.processes.start({
+     *   processKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+     * }, 123); // folderId is required
+     *
+     * // Start a process by name with specific robots
+     * const jobs = await sdk.processes.start({
+     *   processName: "MyProcess"
+     * }, 123); // folderId is required
+     * ```
+     */
+    start(request: ProcessStartRequest, folderId: number, options?: RequestOptions): Promise<ProcessStartResponse[]>;
+    /**
+     * Gets a single process by ID
+     *
+     * @param id - Process ID
+     * @param folderId - Required folder ID
+     * @param options - Optional query parameters
+     * @returns Promise resolving to a single process
+     *
+     * @example
+     * ```typescript
+     * // Get process by ID
+     * const process = await sdk.processes.getById(123, 456);
+     * ```
+     */
+    getById(id: number, folderId: number, options?: ProcessGetByIdOptions): Promise<ProcessGetResponse>;
+}
+
+/**
+ * Interface for queue response
+ */
+interface QueueGetResponse {
+    key: string;
+    name: string;
+    id: number;
+    description: string;
+    maxNumberOfRetries: number;
+    acceptAutomaticallyRetry: boolean;
+    retryAbandonedItems: boolean;
+    enforceUniqueReference: boolean;
+    encrypted: boolean;
+    specificDataJsonSchema: string | null;
+    outputDataJsonSchema: string | null;
+    analyticsDataJsonSchema: string | null;
+    createdTime: string;
+    processScheduleId: number | null;
+    slaInMinutes: number;
+    riskSlaInMinutes: number;
+    releaseId: number | null;
+    isProcessInCurrentFolder: boolean | null;
+    foldersCount: number;
+    folderId: number;
+    folderName: string;
+}
+/**
+ * Options for getting queues across folders
+ */
+type QueueGetAllOptions = RequestOptions & PaginationOptions & {
+    /**
+     * Optional folder ID to filter queues by folder
+     */
+    folderId?: number;
+};
+type QueueGetByIdOptions = BaseOptions;
+
+/**
+ * Service for managing UiPath Queues
+ *
+ * Queues are a fundamental component of UiPath automation that enable distributed and scalable processing of work items. [UiPath Queues Guide](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/about-queues-and-transactions)
+ */
+interface QueueServiceModel {
+    /**
+     * Gets all queues across folders with optional filtering and folder scoping
+     *
+     * @signature getAll(options?) → Promise&lt;QueueGetResponse[]&gt;
+     * @param options Query options including optional folderId and pagination options
+     * @returns Promise resolving to either an array of queues NonPaginatedResponse<QueueGetResponse> or a PaginatedResponse<QueueGetResponse> when pagination options are used.
+     * {@link QueueGetResponse}
+     * @example
+     * ```typescript
+     * // Standard array return
+     * const queues = await sdk.queues.getAll();
+     *
+     * // Get queues within a specific folder
+     * const queues = await sdk.queues.getAll({
+     *   folderId: <folderId>
+     * });
+     *
+     * // Get queues with filtering
+     * const queues = await sdk.queues.getAll({
+     *   filter: "name eq 'MyQueue'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.queues.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.queues.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.queues.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends QueueGetAllOptions = QueueGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<QueueGetResponse> : NonPaginatedResponse<QueueGetResponse>>;
+    /**
+     * Gets a single queue by ID
+     *
+     * @param id - Queue ID
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to a queue definition
+     * @example
+     * ```typescript
+     * // Get queue by ID
+     * const queue = await sdk.queues.getById(<queueId>, <folderId>);
+     * ```
+     */
+    getById(id: number, folderId: number, options?: QueueGetByIdOptions): Promise<QueueGetResponse>;
+}
+
+/**
+ * Service for interacting with UiPath Orchestrator Queues API
+ */
+declare class QueueService extends FolderScopedService implements QueueServiceModel {
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * Gets all queues across folders with optional filtering and folder scoping
+     *
+     * The method returns either:
+     * - An array of queues (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options - Query options including optional folderId
+     * @returns Promise resolving to an array of queues or paginated result
+     *
+     * @example
+     * ```typescript
+     * // Standard array return
+     * const queues = await sdk.queues.getAll();
+     *
+     * // Get queues within a specific folder
+     * const queues = await sdk.queues.getAll({
+     *   folderId: 123
+     * });
+     *
+     * // Get queues with filtering
+     * const queues = await sdk.queues.getAll({
+     *   filter: "name eq 'MyQueue'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.queues.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.queues.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.queues.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends QueueGetAllOptions = QueueGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<QueueGetResponse> : NonPaginatedResponse<QueueGetResponse>>;
+    /**
+     * Gets a single queue by ID
+     *
+     * @param id - Queue ID
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to a queue definition
+     *
+     * @example
+     * ```typescript
+     * // Get queue by ID
+     * const queue = await sdk.queues.getById(123, 456);
+     * ```
+     */
+    getById(id: number, folderId: number, options?: QueueGetByIdOptions): Promise<QueueGetResponse>;
+}
+
+interface UserLoginInfo {
+    name: string;
+    surname: string;
+    userName: string;
+    emailAddress: string;
+    displayName: string;
+    id: number;
+}
+declare enum TaskType {
+    Form = "FormTask",
+    External = "ExternalTask",
+    App = "AppTask"
+}
+declare enum TaskPriority {
+    Low = "Low",
+    Medium = "Medium",
+    High = "High",
+    Critical = "Critical"
+}
+declare enum TaskStatus {
+    Unassigned = "Unassigned",
+    Pending = "Pending",
+    Completed = "Completed"
+}
+declare enum TaskSlaCriteria {
+    TaskCreated = "TaskCreated",
+    TaskAssigned = "TaskAssigned",
+    TaskCompleted = "TaskCompleted"
+}
+declare enum TaskSlaStatus {
+    OverdueLater = "OverdueLater",
+    OverdueSoon = "OverdueSoon",
+    Overdue = "Overdue",
+    CompletedInTime = "CompletedInTime"
+}
+declare enum TaskSourceName {
+    Agent = "Agent",
+    Workflow = "Workflow",
+    Maestro = "Maestro",
+    Default = "Default"
+}
+interface TaskSource {
+    sourceName: TaskSourceName;
+    sourceId: string;
+    taskSourceMetadata: Record<string, unknown>;
+}
+interface TaskSlaDetail {
+    expiryTime?: string;
+    startCriteria?: TaskSlaCriteria;
+    endCriteria?: TaskSlaCriteria;
+    status?: TaskSlaStatus;
+}
+interface TaskAssignment {
+    assignee?: UserLoginInfo;
+    task?: RawTaskGetResponse;
+    id?: number;
+}
+/**
+ * Base interface containing common fields shared across all task response types
+ */
+interface TaskBaseResponse {
+    status: TaskStatus;
+    title: string;
+    type: TaskType;
+    priority: TaskPriority;
+    organizationUnitId: number;
+    key: string;
+    isDeleted: boolean;
+    creationTime: string;
+    creatorUserId: number;
+    id: number;
+    action: string | null;
+    assignedToUserId: number | null;
+    externalTag: string | null;
+    lastAssignedTime: string | null;
+    completionTime: string | null;
+    parentOperationId: string | null;
+    deleterUserId: number | null;
+    deletionTime: string | null;
+    lastModificationTime: string | null;
+}
+interface TaskCreateOptions {
+    title: string;
+    priority?: TaskPriority;
+}
+interface RawTaskCreateResponse extends TaskBaseResponse {
+    waitJobState: JobState | null;
+    assignedToUser: UserLoginInfo | null;
+    taskSlaDetails: TaskSlaDetail[] | null;
+    completedByUser: UserLoginInfo | null;
+    taskAssignees: UserLoginInfo[] | null;
+    processingTime: number | null;
+    data: Record<string, unknown> | null;
+}
+interface RawTaskGetResponse extends TaskBaseResponse {
+    isCompleted: boolean;
+    encrypted: boolean;
+    bulkFormLayoutId: number | null;
+    formLayoutId: number | null;
+    taskSlaDetail: TaskSlaDetail | null;
+    taskAssigneeName: string | null;
+    lastModifierUserId: number | null;
+    assignedToUser?: UserLoginInfo;
+    creatorUser?: UserLoginInfo;
+    lastModifierUser?: UserLoginInfo;
+    taskAssignments?: TaskAssignment[];
+    formLayout?: Record<string, unknown>;
+    actionLabel?: string | null;
+    taskSlaDetails?: TaskSlaDetail[] | null;
+    completedByUser?: UserLoginInfo | null;
+    taskAssignmentCriteria?: string;
+    taskAssignees?: UserLoginInfo[] | null;
+    taskSource?: TaskSource | null;
+    processingTime?: number | null;
+    data?: Record<string, unknown> | null;
+}
+interface TaskAssignmentOptions {
+    taskId: number;
+    userId: number;
+    userNameOrEmail?: string;
+}
+interface TasksUnassignOptions {
+    taskIds: number[];
+}
+interface TaskAssignmentResponse {
+    taskId?: number;
+    userId?: number;
+    errorCode?: number;
+    errorMessage?: string;
+    userNameOrEmail?: string;
+}
+interface TaskCompletionOptions {
+    taskId: number;
+    data?: any;
+    action?: string;
+}
+/**
+ * Options for task assignment operations in the Task class
+ * At least one identification parameter is required
+ */
+type TaskAssignOptions = {
+    userId: number;
+    userNameOrEmail?: string;
+} | {
+    userId?: number;
+    userNameOrEmail: string;
+};
+/**
+ * Options for completing a task
+ */
+type TaskCompleteOptions = {
+    type: TaskType.External;
+    data?: any;
+    action?: string;
+} | {
+    type: Exclude<TaskType, TaskType.External>;
+    data: any;
+    action: string;
+};
+/**
+ * Options for getting tasks across folders
+ */
+type TaskGetAllOptions = RequestOptions & PaginationOptions & {
+    /**
+     * Optional folder ID to filter tasks by folder
+     */
+    folderId?: number;
+};
+/**
+ * Query options for getting a task by ID
+ */
+type TaskGetByIdOptions = BaseOptions;
+/**
+ * Options for getting users with task permissions
+ */
+type TaskGetUsersOptions = RequestOptions & PaginationOptions;
+
+/**
+ * Service for managing UiPath Action Center
+ *
+ * Tasks are task-based automation components that can be integrated into applications and processes. They represent discrete units of work that can be triggered and monitored through the UiPath API. [UiPath Action Center Guide](https://docs.uipath.com/automation-cloud/docs/actions)
+ *
+*/
+interface TaskServiceModel {
+    /**
+     * Gets all tasks across folders with optional filtering
+     *
+     * @param options - Query options including optional folderId and pagination options
+     * @returns Promise resolving to either an array of tasks NonPaginatedResponse<TaskGetResponse> or a PaginatedResponse<TaskGetResponse> when pagination options are used.
+     * {@link TaskGetResponse}
+     */
+    getAll<T extends TaskGetAllOptions = TaskGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
+    getById(id: number, options?: TaskGetByIdOptions, folderId?: number): Promise<TaskGetResponse>;
+    create(options: TaskCreateOptions, folderId: number): Promise<TaskCreateResponse>;
+    assign(options: TaskAssignmentOptions | TaskAssignmentOptions[], folderId?: number): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    reassign(options: TaskAssignmentOptions | TaskAssignmentOptions[], folderId?: number): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    unassign(taskId: number | number[], folderId?: number): Promise<OperationResponse<{
+        taskId: number;
+    }[] | TaskAssignmentResponse[]>>;
+    complete(taskType: TaskType, options: TaskCompletionOptions, folderId: number): Promise<OperationResponse<TaskCompletionOptions>>;
+    /**
+     * Gets users in the given folder who have Tasks.View and Tasks.Edit permissions
+     * Returns a NonPaginatedResponse with data and totalCount when no pagination parameters are provided,
+     * or a PaginatedResponse when any pagination parameter is provided
+     *
+     * @param folderId - The folder ID to get users from
+     * @param options - Optional query and pagination parameters
+     * @returns Promise resolving to NonPaginatedResponse or a paginated result
+     */
+    getUsers<T extends TaskGetUsersOptions = TaskGetUsersOptions>(folderId: number, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<UserLoginInfo> : NonPaginatedResponse<UserLoginInfo>>;
+}
+interface TaskMethods {
+    /**
+     * Assigns this task to a user or users
+     *
+     * @param options - Assignment options (requires at least one of: userId, userNameOrEmail)
+     * @returns Promise resolving to task assignment results
+     */
+    assign(options: TaskAssignOptions): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Reassigns this task to a new user
+     *
+     * @param options - Assignment options (requires at least one of: userId, userNameOrEmail)
+     * @returns Promise resolving to task assignment results
+     */
+    reassign(options: TaskAssignOptions): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Unassigns this task (removes current assignee)
+     *
+     * @returns Promise resolving to task assignment results
+     */
+    unassign(): Promise<OperationResponse<{
+        taskId: number;
+    }[] | TaskAssignmentResponse[]>>;
+    /**
+     * Completes this task with optional data and action
+     *
+     * @param options - Completion options
+     * @returns Promise resolving to completion result
+     */
+    complete(options: TaskCompleteOptions): Promise<OperationResponse<TaskCompletionOptions>>;
+}
+type TaskGetResponse = RawTaskGetResponse & TaskMethods;
+type TaskCreateResponse = RawTaskCreateResponse & TaskMethods;
+/**
+ * Creates an actionable task by combining API task data with operational methods.
+ *
+ * @param taskData - The task data from API
+ * @param service - The task service instance
+ * @returns A task object with added methods
+ */
+declare function createTaskWithMethods(taskData: RawTaskGetResponse | RawTaskCreateResponse, service: TaskServiceModel): TaskGetResponse | TaskCreateResponse;
+
+/**
+ * Service for interacting with UiPath Tasks API
+ */
+declare class TaskService extends BaseService implements TaskServiceModel {
+    /**
+     * @hideconstructor
+     */
+    constructor(config: Config, executionContext: ExecutionContext, tokenManager: TokenManager);
+    /**
+     * 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
+     * const task = await sdk.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
+     * // Standard array return
+     * const users = await sdk.tasks.getUsers(123);
+     *
+     * // Get users with filtering
+     * const users = await sdk.tasks.getUsers(123, {
+     *   filter: "name eq 'abc'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.tasks.getUsers(123, { pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.tasks.getUsers(123, { cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.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 and pagination options
+     * @returns Promise resolving to an array of tasks or paginated result
+     *
+     * @example
+     * ```typescript
+     * // Standard array return
+     * const tasks = await sdk.tasks.getAll();
+     *
+     * // Get tasks within a specific folder
+     * const tasks = await sdk.tasks.getAll({
+     *   folderId: 123
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await sdk.tasks.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await sdk.tasks.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await sdk.tasks.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends TaskGetAllOptions = TaskGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
+    /**
+     * Gets a task by ID
+     *
+     * @param id - The ID of the task to retrieve
+     * @param options - Optional query parameters
+     * @param folderId - Optional folder ID
+     * @returns Promise resolving to the task (form tasks will return form-specific data)
+     *
+     * @example
+     * ```typescript
+     * // Get task by ID
+     * const task = await sdk.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
+     * @param folderId - Optional folder ID
+     * @returns Promise resolving to array of task assignment results
+     *
+     * @example
+     * ```typescript
+     * // Assign a single task to a user by ID
+     * const result = await sdk.tasks.assign({
+     *   taskId: 123,
+     *   userId: 456
+     * });
+     *
+     * // Assign a single task to a user by email
+     * const result = await sdk.tasks.assign({
+     *   taskId: 123,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Assign multiple tasks
+     * const result = await sdk.tasks.assign([
+     *   {
+     *     taskId: 123,
+     *     userId: 456
+     *   },
+     *   {
+     *     taskId: 789,
+     *     userNameOrEmail: "user@example.com"
+     *   }
+     * ]);
+     * ```
+     */
+    assign(taskAssignments: TaskAssignmentOptions | TaskAssignmentOptions[], folderId?: number): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Reassigns tasks to new users
+     *
+     * @param taskAssignments - Single task assignment or array of task assignments
+     * @param folderId - Optional folder ID
+     * @returns Promise resolving to array of task assignment results
+     *
+     * @example
+     * ```typescript
+     * // Reassign a single task to a user by ID
+     * const result = await sdk.tasks.reassign({
+     *   taskId: 123,
+     *   userId: 456
+     * });
+     *
+     * // Reassign a single task to a user by email
+     * const result = await sdk.tasks.reassign({
+     *   taskId: 123,
+     *   userNameOrEmail: "user@example.com"
+     * });
+     *
+     * // Reassign multiple tasks
+     * const result = await sdk.tasks.reassign([
+     *   {
+     *     taskId: 123,
+     *     userId: 456
+     *   },
+     *   {
+     *     taskId: 789,
+     *     userNameOrEmail: "user@example.com"
+     *   }
+     * ]);
+     * ```
+     */
+    reassign(taskAssignments: TaskAssignmentOptions | TaskAssignmentOptions[], folderId?: number): Promise<OperationResponse<TaskAssignmentOptions[] | TaskAssignmentResponse[]>>;
+    /**
+     * Unassigns tasks (removes current assignees)
+     *
+     * @param taskIds - Single task ID or array of task IDs to unassign
+     * @param folderId - Optional folder ID
+     * @returns Promise resolving to array of task assignment results
+     *
+     * @example
+     * ```typescript
+     * // Unassign a single task
+     * const result = await sdk.tasks.unassign(123);
+     *
+     * // Unassign multiple tasks
+     * const result = await sdk.tasks.unassign([123, 456, 789]);
+     * ```
+     */
+    unassign(taskIds: number | number[], folderId?: number): Promise<OperationResponse<{
+        taskId: number;
+    }[] | TaskAssignmentResponse[]>>;
+    /**
+     * Completes a task with the specified type and data
+     *
+     * @param completionType - The type of task (Form, App, or Generic)
+     * @param options - The completion options
+     * @param folderId - Required folder ID
+     * @returns Promise resolving to void
+     *
+     * @example
+     * ```typescript
+     * // Complete an app task
+     * await sdk.tasks.complete(TaskType.App, {
+     *   taskId: 456,
+     *   data: {},
+     *   action: "submit"
+     * }, 123); // folderId is required
+     *
+     * // Complete an external task
+     * await sdk.tasks.complete(TaskType.ExternalTask, {
+     *   taskId: 789
+     * }, 123); // folderId is required
+     * ```
+     */
+    complete(completionType: TaskType, 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;
+}
+
+interface BaseConfig {
+    baseUrl: string;
+    orgName: string;
+    tenantName: string;
+}
+interface OAuthFields {
+    clientId: string;
+    redirectUri: string;
+    scope: string;
+}
+type UiPathSDKConfig = BaseConfig & ({
+    secret: string;
+    clientId?: never;
+    redirectUri?: never;
+    scope?: never;
+} | ({
+    secret?: never;
+} & OAuthFields));
+
+declare class UiPath {
+    private config;
+    private executionContext;
+    private authService;
+    private initialized;
+    private readonly _services;
+    constructor(config: UiPathSDKConfig);
+    /**
+     * Initialize the SDK based on the provided configuration.
+     * This method is only required for OAuth-based authentication.
+     * For secret-based authentication, initialization is automatic.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if the SDK has been initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get the current authentication token
+     */
+    getToken(): string | undefined;
+    private getService;
+    /**
+     * Access to Maestro services
+     */
+    get maestro(): {
+        /**
+         * Access to Maestro Processes service
+         */
+        processes: MaestroProcessesService & {
+            /**
+             * Access to Process Instances service
+             */
+            instances: ProcessInstancesService;
+        };
+    };
+    /**
+     * Access to Entity service
+     */
+    get entities(): EntityService;
+    /**
+     * Access to Tasks service
+     */
+    get tasks(): TaskService;
+    /**
+     * Access to Orchestrator Processes service
+     */
+    get processes(): ProcessService;
+    /**
+     * Access to Orchestrator Buckets service
+     */
+    get buckets(): BucketService;
+    /**
+     * Access to Orchestrator Queues service
+     */
+    get queues(): QueueService;
+    /**
+     * Access to Orchestrator Assets service
+     */
+    get assets(): AssetService;
+}
+
+/**
+ * Error thrown when authorization fails (403 errors)
+ * Common scenarios:
+ * - Insufficient permissions
+ * - Access denied to resource
+ * - Invalid scope
+ */
+declare class AuthorizationError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+}
+
+/**
+ * Error thrown when validation fails (400 errors or client-side validation)
+ * Common scenarios:
+ * - Invalid input parameters
+ * - Missing required fields
+ * - Invalid data format
+ */
+declare class ValidationError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+}
+
+/**
+ * Error thrown when a resource is not found (404 errors)
+ * Common scenarios:
+ * - Resource doesn't exist
+ * - Invalid ID provided
+ * - Resource deleted
+ */
+declare class NotFoundError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+}
+
+/**
+ * Error thrown when rate limit is exceeded (429 errors)
+ * Common scenarios:
+ * - Too many requests in a time window
+ * - API throttling
+ */
+declare class RateLimitError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+}
+
+/**
+ * Error thrown when server encounters an error (5xx errors)
+ * Common scenarios:
+ * - Internal server error
+ * - Service unavailable
+ * - Gateway timeout
+ */
+declare class ServerError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+    /**
+     * Checks if this is a temporary error that might succeed on retry
+     */
+    get isRetryable(): boolean;
+}
+
+/**
+ * Base error creation parameters - only what's needed
+ */
+interface ErrorParams {
+    message: string;
+    statusCode?: number;
+    requestId?: string;
+}
+
+/**
+ * Base error class for all UiPath SDK errors
+ * Pure TypeScript class with clean interface
+ */
+declare abstract class UiPathError {
+    /**
+     * Error type identifier (e.g., "AuthenticationError", "ValidationError")
+     */
+    readonly type: string;
+    /**
+     * Error message describing what went wrong
+     */
+    readonly message: string;
+    /**
+     * HTTP status code (400, 401, 403, 404, 500, etc.)
+     */
+    readonly statusCode?: number;
+    /**
+     * Request ID for tracking with UiPath support
+     */
+    readonly requestId?: string;
+    /**
+     * Timestamp when the error occurred
+     */
+    readonly timestamp: Date;
+    /**
+     * Stack trace for debugging
+     */
+    readonly stack?: string;
+    protected constructor(type: string, params: ErrorParams);
+    /**
+     * Returns a clean JSON representation of the error
+     */
+    private toJSON;
+    /**
+     * Returns detailed debug information including stack trace
+     */
+    getDebugInfo(): Record<string, unknown>;
+}
+
+/**
+ * Error thrown when authentication fails (401 errors)
+ * Common scenarios:
+ * - Invalid credentials
+ * - Expired token
+ * - Missing authentication
+ */
+declare class AuthenticationError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+}
+
+/**
+ * Error thrown when network/connection issues occur
+ * Common scenarios:
+ * - Connection timeout
+ * - DNS resolution failure
+ * - Network unreachable
+ * - Request aborted
+ */
+declare class NetworkError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+}
+
+/**
+ * Type guard to check if an error is a UiPathError
+ */
+declare function isUiPathError(error: unknown): error is UiPathError;
+/**
+ * Type guard to check if an error is an AuthenticationError
+ */
+declare function isAuthenticationError(error: unknown): error is AuthenticationError;
+/**
+ * Type guard to check if an error is an AuthorizationError
+ */
+declare function isAuthorizationError(error: unknown): error is AuthorizationError;
+/**
+ * Type guard to check if an error is a ValidationError
+ */
+declare function isValidationError(error: unknown): error is ValidationError;
+/**
+ * Type guard to check if an error is a NotFoundError
+ */
+declare function isNotFoundError(error: unknown): error is NotFoundError;
+/**
+ * Type guard to check if an error is a RateLimitError
+ */
+declare function isRateLimitError(error: unknown): error is RateLimitError;
+/**
+ * Type guard to check if an error is a ServerError
+ */
+declare function isServerError(error: unknown): error is ServerError;
+/**
+ * Type guard to check if an error is a NetworkError
+ */
+declare function isNetworkError(error: unknown): error is NetworkError;
+/**
+ * Helper to get error details in a safe way
+ */
+declare function getErrorDetails(error: unknown): {
+    message: string;
+    statusCode?: number;
+};
+
+/**
+ * HTTP status code constants for error handling
+ */
+declare const HttpStatus: {
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly TOO_MANY_REQUESTS: 429;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly NOT_IMPLEMENTED: 501;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+    readonly GATEWAY_TIMEOUT: 504;
+};
+/**
+ * Error type constants for consistent error identification
+ */
+declare const ErrorType: {
+    readonly AUTHENTICATION: "AuthenticationError";
+    readonly AUTHORIZATION: "AuthorizationError";
+    readonly VALIDATION: "ValidationError";
+    readonly NOT_FOUND: "NotFoundError";
+    readonly RATE_LIMIT: "RateLimitError";
+    readonly SERVER: "ServerError";
+    readonly NETWORK: "NetworkError";
+};
+
+/**
+ * Telemetry type definitions
+ */
+interface TelemetryAttributes {
+    [key: string]: string | number | boolean;
+}
+interface TelemetryConfig {
+    baseUrl?: string;
+    orgName?: string;
+    tenantName?: string;
+    clientId?: string;
+    redirectUri?: string;
+}
+interface TrackOptions {
+    condition?: boolean | ((...args: any[]) => boolean);
+    attributes?: TelemetryAttributes;
+}
+
+/**
+ * SDK Track decorator and function for telemetry
+ */
+
+/**
+ * Track decorator that can be used to automatically track function calls
+ *
+ * Usage:
+ * @track("Service.Method")
+ * function myFunction() { ... }
+ *
+ * @track("Queue.GetAll")
+ * async getAll() { ... }
+ *
+ * @track("Tasks.Create")
+ * async create() { ... }
+ *
+ * @track("Assets.Update", { condition: false })
+ * function myFunction() { ... }
+ *
+ * @track("Processes.Start", { attributes: { customProp: "value" } })
+ * function myFunction() { ... }
+ */
+declare function track(nameOrOptions?: string | TrackOptions, options?: TrackOptions): MethodDecorator | ((target: any) => any);
+/**
+ * Direct tracking function
+ */
+declare function trackEvent(eventName: string, name?: string, attributes?: TelemetryAttributes): void;
+
+/**
+ * Singleton telemetry client
+ */
+declare class TelemetryClient {
+    private static instance;
+    private isInitialized;
+    private logProvider?;
+    private logger?;
+    private telemetryContext?;
+    private constructor();
+    static getInstance(): TelemetryClient;
+    /**
+     * Initialize telemetry
+     */
+    initialize(config?: TelemetryConfig): void;
+    private getConnectionString;
+    private setupTelemetryProvider;
+    /**
+     * Track a telemetry event
+     */
+    track(eventName: string, name?: string, extraAttributes?: TelemetryAttributes): void;
+    /**
+     * Get enriched attributes for telemetry events
+     */
+    private getEnrichedAttributes;
+    /**
+     * Create cloud URL from base URL, organization ID, and tenant ID
+     */
+    private createCloudUrl;
+}
+declare const telemetryClient: TelemetryClient;
+
+/**
+ * SDK Telemetry constants
+ */
+declare const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
+declare const SDK_VERSION = "1.0.0-beta.13";
+declare const VERSION = "Version";
+declare const SERVICE = "Service";
+declare const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
+declare const CLOUD_TENANT_NAME = "CloudTenantName";
+declare const CLOUD_URL = "CloudUrl";
+declare const CLOUD_CLIENT_ID = "CloudClientId";
+declare const CLOUD_REDIRECT_URI = "CloudRedirectUri";
+declare const APP_NAME = "ApplicationName";
+declare const CLOUD_ROLE_NAME = "uipath-ts-sdk";
+declare const SDK_SERVICE_NAME = "UiPath.TypeScript.Sdk";
+declare const SDK_LOGGER_NAME = "uipath-ts-sdk-telemetry";
+declare const SDK_RUN_EVENT = "Sdk.Run";
+declare const UNKNOWN = "";
+
+export { APP_NAME, AssetValueScope, AssetValueType, AuthenticationError, AuthorizationError, BucketOptions, CLOUD_CLIENT_ID, CLOUD_ORGANIZATION_NAME, CLOUD_REDIRECT_URI, CLOUD_ROLE_NAME, CLOUD_TENANT_NAME, CLOUD_URL, CONNECTION_STRING, DEFAULT_ITEMS_FIELD, DEFAULT_PAGE_SIZE, DEFAULT_TOTAL_COUNT_FIELD, DataDirectionType, EntityFieldDataType, EntityType, ErrorType, FieldDisplayType, HttpStatus, JobPriority, JobState, JobType, JoinType, MAX_PAGE_SIZE, NetworkError, NotFoundError, PackageSourceType, PackageType, RateLimitError, ReferenceType, RemoteControlAccess, RobotSize, SDK_LOGGER_NAME, SDK_RUN_EVENT, SDK_SERVICE_NAME, SDK_VERSION, SERVICE, ServerError, StartStrategy, StopStrategy, TargetFramework, TaskPriority, TaskSlaCriteria, TaskSlaStatus, TaskSourceName, TaskStatus, TaskType, UNKNOWN, UiPath, UiPathError, VERSION, ValidationError, createEntityWithMethods, createProcessInstanceWithMethods, createTaskWithMethods, getErrorDetails, getLimitedPageSize, isAuthenticationError, isAuthorizationError, isNetworkError, isNotFoundError, isRateLimitError, isServerError, isUiPathError, isValidationError, telemetryClient, track, trackEvent };
+export type { ArgumentMetadata, AssetGetAllOptions, AssetGetByIdOptions, AssetGetResponse, AssetServiceModel, BaseOptions, BlobItem, BodyOptions, BpmnXmlString, BucketGetAllOptions, BucketGetByIdOptions, BucketGetFileMetaDataOptions, BucketGetFileMetaDataResponse, BucketGetFileMetaDataWithPaginationOptions, BucketGetReadUriOptions, BucketGetResponse, BucketGetUriOptions, BucketGetUriResponse, BucketGetWriteUriOptions, BucketServiceModel, BucketUploadFileOptions, BucketUploadResponse, CollectionResponse, Config, CustomKeyValuePair, ElementMetaData, EntityDeleteOptions, EntityDeleteResponse, EntityGetRecordsByIdOptions, EntityGetResponse, EntityInsertOptions, EntityInsertResponse, EntityMethods, EntityOperationOptions, EntityOperationResponse, EntityRecord, EntityServiceModel, EntityUpdateOptions, EntityUpdateResponse, ExternalConnection, ExternalField, ExternalFieldMapping, ExternalObject, ExternalSourceFields, FailureRecord, Field, FieldDataType, FieldMetaData, FolderProperties, GlobalVariableMetaData, HasPaginationOptions, Headers, HttpMethod, JobAttachment, JobError, Machine, MaestroProcessGetAllResponse, MaestroProcessesServiceModel, NonPaginatedResponse, OperationResponse, PaginatedResponse, PaginationCursor, PaginationMetadata, PaginationMethodUnion, PaginationOptions, ProcessGetAllOptions, ProcessGetByIdOptions, ProcessGetResponse, ProcessInstanceExecutionHistoryResponse, ProcessInstanceGetAllOptions, ProcessInstanceGetAllWithPaginationOptions, ProcessInstanceGetResponse, ProcessInstanceGetVariablesOptions, ProcessInstanceGetVariablesResponse, ProcessInstanceMethods, ProcessInstanceOperationOptions, ProcessInstanceOperationResponse, ProcessInstanceRun, ProcessInstancesServiceModel, ProcessProperties, ProcessServiceModel, ProcessStartRequest, ProcessStartResponse, QueryParams, QueueGetAllOptions, QueueGetByIdOptions, QueueGetResponse, QueueServiceModel, RawEntityGetResponse, RawProcessInstanceGetResponse, RawTaskCreateResponse, RawTaskGetResponse, RequestOptions, RequestSpec, ResponseDictionary, ResponseType, RetryOptions, RobotMetadata, SourceJoinCriteria, TaskAssignOptions, TaskAssignment, TaskAssignmentOptions, TaskAssignmentResponse, TaskBaseResponse, TaskCompleteOptions, TaskCompletionOptions, TaskCreateOptions, TaskCreateResponse, TaskGetAllOptions, TaskGetByIdOptions, TaskGetResponse, TaskGetUsersOptions, TaskMethods, TaskServiceModel, TaskSlaDetail, TaskSource, TasksUnassignOptions, TimeoutOptions, UserLoginInfo };