@uipath/uipath-typescript 1.0.0 → 1.1.0

package/dist/index.umd.js

@@ -3897,6 +3897,303 @@
         return Boolean(config.secret);
     }
 
+    /**
+     * Base error class for all UiPath SDK errors
+     * Extends Error for standard error handling compatibility
+     */
+    class UiPathError extends Error {
+        constructor(type, params) {
+            super(params.message);
+            this.name = type;
+            this.type = type;
+            this.statusCode = params.statusCode;
+            this.requestId = params.requestId;
+            this.timestamp = new Date();
+            // Maintains proper stack trace for where our error was thrown
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, this.constructor);
+            }
+        }
+        /**
+         * Returns a clean JSON representation of the error
+         */
+        toJSON() {
+            return {
+                type: this.type,
+                message: this.message,
+                statusCode: this.statusCode,
+                requestId: this.requestId,
+                timestamp: this.timestamp
+            };
+        }
+        /**
+         * Returns detailed debug information including stack trace
+         */
+        getDebugInfo() {
+            return {
+                ...this.toJSON(),
+                stack: this.stack
+            };
+        }
+    }
+
+    /**
+     * HTTP status code constants for error handling
+     */
+    const HttpStatus = {
+        // Client errors (4xx)
+        BAD_REQUEST: 400,
+        UNAUTHORIZED: 401,
+        FORBIDDEN: 403,
+        NOT_FOUND: 404,
+        TOO_MANY_REQUESTS: 429,
+        // Server errors (5xx)
+        INTERNAL_SERVER_ERROR: 500,
+        NOT_IMPLEMENTED: 501,
+        BAD_GATEWAY: 502,
+        SERVICE_UNAVAILABLE: 503,
+        GATEWAY_TIMEOUT: 504
+    };
+    /**
+     * Error type constants for consistent error identification
+     */
+    const ErrorType = {
+        AUTHENTICATION: 'AuthenticationError',
+        AUTHORIZATION: 'AuthorizationError',
+        VALIDATION: 'ValidationError',
+        NOT_FOUND: 'NotFoundError',
+        RATE_LIMIT: 'RateLimitError',
+        SERVER: 'ServerError',
+        NETWORK: 'NetworkError'
+    };
+    /**
+     * HTTP header constants for error handling
+     */
+    const HttpHeaders = {
+        X_REQUEST_ID: 'x-request-id'
+    };
+    /**
+     * Standard error message constants
+     */
+    const ErrorMessages = {
+        // Authentication errors
+        AUTHENTICATION_FAILED: 'Authentication failed',
+        // Authorization errors  
+        ACCESS_DENIED: 'Access denied',
+        // Validation errors
+        VALIDATION_FAILED: 'Validation failed',
+        // Not found errors
+        RESOURCE_NOT_FOUND: 'Resource not found',
+        // Rate limit errors
+        RATE_LIMIT_EXCEEDED: 'Rate limit exceeded',
+        // Server errors
+        INTERNAL_SERVER_ERROR: 'Internal Server error occurred',
+        // Network errors
+        NETWORK_ERROR: 'Network error occurred',
+        REQUEST_TIMEOUT: 'Request timed out',
+        REQUEST_ABORTED: 'Request was aborted',
+    };
+    /**
+     * Error name constants for network error identification
+     */
+    const ErrorNames = {
+        ABORT_ERROR: 'AbortError'};
+
+    /**
+     * Error thrown when authentication fails (401 errors)
+     * Common scenarios:
+     * - Invalid credentials
+     * - Expired token
+     * - Missing authentication
+     */
+    class AuthenticationError extends UiPathError {
+        constructor(params = {}) {
+            super(ErrorType.AUTHENTICATION, {
+                message: params.message || ErrorMessages.AUTHENTICATION_FAILED,
+                statusCode: params.statusCode ?? HttpStatus.UNAUTHORIZED,
+                requestId: params.requestId
+            });
+        }
+    }
+
+    /**
+     * Error thrown when authorization fails (403 errors)
+     * Common scenarios:
+     * - Insufficient permissions
+     * - Access denied to resource
+     * - Invalid scope
+     */
+    class AuthorizationError extends UiPathError {
+        constructor(params = {}) {
+            super(ErrorType.AUTHORIZATION, {
+                message: params.message || ErrorMessages.ACCESS_DENIED,
+                statusCode: params.statusCode ?? HttpStatus.FORBIDDEN,
+                requestId: params.requestId
+            });
+        }
+    }
+
+    /**
+     * Error thrown when validation fails (400 errors or client-side validation)
+     * Common scenarios:
+     * - Invalid input parameters
+     * - Missing required fields
+     * - Invalid data format
+     */
+    class ValidationError extends UiPathError {
+        constructor(params = {}) {
+            super(ErrorType.VALIDATION, {
+                message: params.message || ErrorMessages.VALIDATION_FAILED,
+                statusCode: params.statusCode ?? HttpStatus.BAD_REQUEST,
+                requestId: params.requestId
+            });
+        }
+    }
+
+    /**
+     * Error thrown when a resource is not found (404 errors)
+     * Common scenarios:
+     * - Resource doesn't exist
+     * - Invalid ID provided
+     * - Resource deleted
+     */
+    class NotFoundError extends UiPathError {
+        constructor(params = {}) {
+            super(ErrorType.NOT_FOUND, {
+                message: params.message || ErrorMessages.RESOURCE_NOT_FOUND,
+                statusCode: params.statusCode ?? HttpStatus.NOT_FOUND,
+                requestId: params.requestId
+            });
+        }
+    }
+
+    /**
+     * Error thrown when rate limit is exceeded (429 errors)
+     * Common scenarios:
+     * - Too many requests in a time window
+     * - API throttling
+     */
+    class RateLimitError extends UiPathError {
+        constructor(params = {}) {
+            super(ErrorType.RATE_LIMIT, {
+                message: params.message || ErrorMessages.RATE_LIMIT_EXCEEDED,
+                statusCode: params.statusCode ?? HttpStatus.TOO_MANY_REQUESTS,
+                requestId: params.requestId
+            });
+        }
+    }
+
+    /**
+     * Error thrown when server encounters an error (5xx errors)
+     * Common scenarios:
+     * - Internal server error
+     * - Service unavailable
+     * - Gateway timeout
+     */
+    class ServerError extends UiPathError {
+        constructor(params = {}) {
+            super(ErrorType.SERVER, {
+                message: params.message || ErrorMessages.INTERNAL_SERVER_ERROR,
+                statusCode: params.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR,
+                requestId: params.requestId
+            });
+        }
+        /**
+         * Checks if this is a temporary error that might succeed on retry
+         */
+        get isRetryable() {
+            return this.statusCode === HttpStatus.BAD_GATEWAY ||
+                this.statusCode === HttpStatus.SERVICE_UNAVAILABLE ||
+                this.statusCode === HttpStatus.GATEWAY_TIMEOUT;
+        }
+    }
+
+    /**
+     * Error thrown when network/connection issues occur
+     * Common scenarios:
+     * - Connection timeout
+     * - DNS resolution failure
+     * - Network unreachable
+     * - Request aborted
+     */
+    class NetworkError extends UiPathError {
+        constructor(params = {}) {
+            super(ErrorType.NETWORK, {
+                message: params.message || ErrorMessages.NETWORK_ERROR,
+                statusCode: params.statusCode, // Network errors typically don't have HTTP status codes
+                requestId: params.requestId
+            });
+        }
+    }
+
+    /**
+     * Type guard to check if an error is a UiPathError
+     */
+    function isUiPathError(error) {
+        return error instanceof UiPathError;
+    }
+    /**
+     * Type guard to check if an error is an AuthenticationError
+     */
+    function isAuthenticationError(error) {
+        return error instanceof AuthenticationError;
+    }
+    /**
+     * Type guard to check if an error is an AuthorizationError
+     */
+    function isAuthorizationError(error) {
+        return error instanceof AuthorizationError;
+    }
+    /**
+     * Type guard to check if an error is a ValidationError
+     */
+    function isValidationError(error) {
+        return error instanceof ValidationError;
+    }
+    /**
+     * Type guard to check if an error is a NotFoundError
+     */
+    function isNotFoundError(error) {
+        return error instanceof NotFoundError;
+    }
+    /**
+     * Type guard to check if an error is a RateLimitError
+     */
+    function isRateLimitError(error) {
+        return error instanceof RateLimitError;
+    }
+    /**
+     * Type guard to check if an error is a ServerError
+     */
+    function isServerError(error) {
+        return error instanceof ServerError;
+    }
+    /**
+     * Type guard to check if an error is a NetworkError
+     */
+    function isNetworkError(error) {
+        return error instanceof NetworkError;
+    }
+    /**
+     * Helper to get error details in a safe way
+     */
+    function getErrorDetails(error) {
+        if (isUiPathError(error)) {
+            return {
+                message: error.message,
+                statusCode: error.statusCode
+            };
+        }
+        if (error instanceof Error) {
+            return {
+                message: error.message
+            };
+        }
+        return {
+            message: String(error)
+        };
+    }
+
     /**
      * TokenManager is responsible for managing authentication tokens.
      * It provides token operations for a specific client ID.
@@ -3929,6 +4226,41 @@
             }
             return new Date() >= tokenInfo.expiresAt;
         }
+        /**
+         * Gets a valid authentication token, refreshing if necessary.
+         * This is the single source of truth for token validation and refresh logic.
+         *
+         * @returns The valid token string
+         * @throws AuthenticationError if no token available or refresh fails
+         */
+        async getValidToken() {
+            const tokenInfo = this.executionContext.get('tokenInfo');
+            if (!tokenInfo) {
+                throw new AuthenticationError({
+                    message: 'No authentication token available. Make sure to initialize the SDK first.'
+                });
+            }
+            // For secret-based tokens, they never expire
+            if (tokenInfo.type === 'secret') {
+                return tokenInfo.token;
+            }
+            // If token is not expired, return it
+            if (!this.isTokenExpired(tokenInfo)) {
+                return tokenInfo.token;
+            }
+            // Token is expired, refresh it
+            try {
+                const newToken = await this.refreshAccessToken();
+                return newToken.access_token;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                throw new AuthenticationError({
+                    message: `Token refresh failed: ${message}. Please re-authenticate.`,
+                    statusCode: HttpStatus.UNAUTHORIZED
+                });
+            }
+        }
         /**
          * Gets the storage key for this TokenManager instance
          */
@@ -4143,10 +4475,6 @@
         }
     }
 
-    /**
-     * API Endpoint Constants
-     * Centralized location for all API endpoints used throughout the SDK
-     */
     /**
      * Base path constants for different services
      */
@@ -4154,6 +4482,66 @@
     const PIMS_BASE = 'pims_';
     const DATAFABRIC_BASE = 'datafabric_';
     const IDENTITY_BASE = 'identity_';
+
+    /**
+     * Orchestrator Service Endpoints
+     */
+    /**
+     * Task Service (Action Center) Endpoints
+     */
+    const TASK_ENDPOINTS = {
+        CREATE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CreateTask`,
+        GET_TASK_USERS: (folderId) => `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTaskUsers(organizationUnitId=${folderId})`,
+        GET_TASKS_ACROSS_FOLDERS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFolders`,
+        GET_TASKS_ACROSS_FOLDERS_ADMIN: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFoldersForAdmin`,
+        GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Tasks(${id})`,
+        ASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks`,
+        REASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.ReassignTasks`,
+        UNASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.UnassignTasks`,
+        COMPLETE_FORM_TASK: `${ORCHESTRATOR_BASE}/forms/TaskForms/CompleteTask`,
+        COMPLETE_APP_TASK: `${ORCHESTRATOR_BASE}/tasks/AppTasks/CompleteAppTask`,
+        COMPLETE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CompleteTask`,
+        GET_TASK_FORM_BY_ID: `${ORCHESTRATOR_BASE}/forms/TaskForms/GetTaskFormById`,
+    };
+    /**
+     * Orchestrator Bucket Endpoints
+     */
+    const BUCKET_ENDPOINTS = {
+        GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Buckets`,
+        GET_ALL: `${ORCHESTRATOR_BASE}/odata/Buckets/UiPath.Server.Configuration.OData.GetBucketsAcrossFolders`,
+        GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})`,
+        GET_FILE_META_DATA: (id) => `${ORCHESTRATOR_BASE}/api/Buckets/${id}/ListFiles`,
+        GET_READ_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetReadUri`,
+        GET_WRITE_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetWriteUri`,
+    };
+    /**
+     * Orchestrator Process Service Endpoints
+     */
+    const PROCESS_ENDPOINTS = {
+        GET_ALL: `${ORCHESTRATOR_BASE}/odata/Releases`,
+        START_PROCESS: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs`,
+        GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Releases(${id})`,
+    };
+    /**
+     * Orchestrator Queue Service Endpoints
+     */
+    const QUEUE_ENDPOINTS = {
+        GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions`,
+        GET_ALL: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions/UiPath.Server.Configuration.OData.GetQueuesAcrossFolders`,
+        GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/QueueDefinitions(${id})`,
+    };
+    /**
+     * Orchestrator Asset Service Endpoints
+     */
+    const ASSET_ENDPOINTS = {
+        GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered`,
+        GET_ALL: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetAssetsAcrossFolders`,
+        GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Assets(${id})`,
+    };
+
+    /**
+     * Maestro Service Endpoints
+     */
     /**
      * Maestro Process Service Endpoints
      */
@@ -4183,25 +4571,12 @@
             REOPEN: (instanceId) => `${PIMS_BASE}/api/v1/cases/${instanceId}/reopen`,
         },
     };
+
     /**
-     * Task Service (Action Center) Endpoints
+     * Data Fabric Service Endpoints
      */
-    const TASK_ENDPOINTS = {
-        CREATE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CreateTask`,
-        GET_TASK_USERS: (folderId) => `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTaskUsers(organizationUnitId=${folderId})`,
-        GET_TASKS_ACROSS_FOLDERS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFolders`,
-        GET_TASKS_ACROSS_FOLDERS_ADMIN: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFoldersForAdmin`,
-        GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Tasks(${id})`,
-        ASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks`,
-        REASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.ReassignTasks`,
-        UNASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.UnassignTasks`,
-        COMPLETE_FORM_TASK: `${ORCHESTRATOR_BASE}/forms/TaskForms/CompleteTask`,
-        COMPLETE_APP_TASK: `${ORCHESTRATOR_BASE}/tasks/AppTasks/CompleteAppTask`,
-        COMPLETE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CompleteTask`,
-        GET_TASK_FORM_BY_ID: `${ORCHESTRATOR_BASE}/forms/TaskForms/GetTaskFormById`,
-    };
     /**
-     * Data Fabric Service Endpoints
+     * Data Fabric Entity Service Endpoints
      */
     const DATA_FABRIC_ENDPOINTS = {
         ENTITY: {
@@ -4217,51 +4592,20 @@
         },
         CHOICESETS: {
             GET_ALL: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
-            GET_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/query_expansion`,
-        },
-    };
-    /**
-     * Orchestrator Bucket Endpoints
-     */
-    const BUCKET_ENDPOINTS = {
-        GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Buckets`,
-        GET_ALL: `${ORCHESTRATOR_BASE}/odata/Buckets/UiPath.Server.Configuration.OData.GetBucketsAcrossFolders`,
-        GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})`,
-        GET_FILE_META_DATA: (id) => `${ORCHESTRATOR_BASE}/api/Buckets/${id}/ListFiles`,
-        GET_READ_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetReadUri`,
-        GET_WRITE_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetWriteUri`,
+            GET_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/query_expansion`,
+        },
     };
+
     /**
      * Identity/Authentication Endpoints
      */
+    /**
+     * Identity Service Endpoints
+     */
     const IDENTITY_ENDPOINTS = {
         TOKEN: `${IDENTITY_BASE}/connect/token`,
         AUTHORIZE: `${IDENTITY_BASE}/connect/authorize`,
     };
-    /**
-     * Orchestrator Process Service Endpoints
-     */
-    const PROCESS_ENDPOINTS = {
-        GET_ALL: `${ORCHESTRATOR_BASE}/odata/Releases`,
-        START_PROCESS: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs`,
-        GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Releases(${id})`,
-    };
-    /**
-     * Orchestrator Queue Service Endpoints
-     */
-    const QUEUE_ENDPOINTS = {
-        GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions`,
-        GET_ALL: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions/UiPath.Server.Configuration.OData.GetQueuesAcrossFolders`,
-        GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/QueueDefinitions(${id})`,
-    };
-    /**
-     * Orchestrator Asset Service Endpoints
-     */
-    const ASSET_ENDPOINTS = {
-        GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered`,
-        GET_ALL: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetAssetsAcrossFolders`,
-        GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Assets(${id})`,
-    };
 
     class AuthService {
         constructor(config, executionContext) {
@@ -8376,7 +8720,7 @@
     // Connection string placeholder that will be replaced during build
     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";
     // SDK Version placeholder 
-    const SDK_VERSION = "1.0.0";
+    const SDK_VERSION = "1.1.0";
     const VERSION = "Version";
     const SERVICE = "Service";
     const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -8553,7 +8897,6 @@
          */
         getEnrichedAttributes(extraAttributes, eventName) {
             const attributes = {
-                ...extraAttributes,
                 [APP_NAME]: SDK_SERVICE_NAME,
                 [VERSION]: SDK_VERSION,
                 [SERVICE]: eventName,
@@ -8562,6 +8905,7 @@
                 [CLOUD_TENANT_NAME]: this.telemetryContext?.tenantName || UNKNOWN$1,
                 [CLOUD_REDIRECT_URI]: this.telemetryContext?.redirectUri || UNKNOWN$1,
                 [CLOUD_CLIENT_ID]: this.telemetryContext?.clientId || UNKNOWN$1,
+                ...extraAttributes,
             };
             return attributes;
         }
@@ -8831,332 +9175,38 @@
         }
         /**
          * Complete OAuth authentication flow (only call if isInOAuthCallback() is true)
-         */
-        async completeOAuth() {
-            if (!AuthService.isInOAuthCallback()) {
-                throw new Error('Not in OAuth callback state. Call initialize() first to start OAuth flow.');
-            }
-            try {
-                const success = await __classPrivateFieldGet(this, _UiPath_authService, "f").authenticate(__classPrivateFieldGet(this, _UiPath_config, "f"));
-                if (success && this.isAuthenticated()) {
-                    __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
-                    return true;
-                }
-                return false;
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
-                throw new Error(`Failed to complete OAuth: ${errorMessage}`);
-            }
-        }
-        /**
-         * Check if the user is authenticated (has valid token)
-         */
-        isAuthenticated() {
-            return __classPrivateFieldGet(this, _UiPath_authService, "f").hasValidToken();
-        }
-        /**
-         * Get the current authentication token
-         */
-        getToken() {
-            return __classPrivateFieldGet(this, _UiPath_authService, "f").getToken();
-        }
-    };
-    _UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_initialized = new WeakMap();
-
-    /**
-     * Base error class for all UiPath SDK errors
-     * Pure TypeScript class with clean interface
-     */
-    class UiPathError {
-        constructor(type, params) {
-            this.type = type;
-            this.message = params.message;
-            this.statusCode = params.statusCode;
-            this.requestId = params.requestId;
-            this.timestamp = new Date();
-            // Capture stack trace for debugging
-            this.stack = (new Error()).stack;
-        }
-        /**
-         * Returns a clean JSON representation of the error
-         */
-        toJSON() {
-            return {
-                type: this.type,
-                message: this.message,
-                statusCode: this.statusCode,
-                requestId: this.requestId,
-                timestamp: this.timestamp
-            };
-        }
-        /**
-         * Returns detailed debug information including stack trace
-         */
-        getDebugInfo() {
-            return {
-                ...this.toJSON(),
-                stack: this.stack
-            };
-        }
-    }
-
-    /**
-     * HTTP status code constants for error handling
-     */
-    const HttpStatus = {
-        // Client errors (4xx)
-        BAD_REQUEST: 400,
-        UNAUTHORIZED: 401,
-        FORBIDDEN: 403,
-        NOT_FOUND: 404,
-        TOO_MANY_REQUESTS: 429,
-        // Server errors (5xx)
-        INTERNAL_SERVER_ERROR: 500,
-        NOT_IMPLEMENTED: 501,
-        BAD_GATEWAY: 502,
-        SERVICE_UNAVAILABLE: 503,
-        GATEWAY_TIMEOUT: 504
-    };
-    /**
-     * Error type constants for consistent error identification
-     */
-    const ErrorType = {
-        AUTHENTICATION: 'AuthenticationError',
-        AUTHORIZATION: 'AuthorizationError',
-        VALIDATION: 'ValidationError',
-        NOT_FOUND: 'NotFoundError',
-        RATE_LIMIT: 'RateLimitError',
-        SERVER: 'ServerError',
-        NETWORK: 'NetworkError'
-    };
-    /**
-     * HTTP header constants for error handling
-     */
-    const HttpHeaders = {
-        X_REQUEST_ID: 'x-request-id'
-    };
-    /**
-     * Standard error message constants
-     */
-    const ErrorMessages = {
-        // Authentication errors
-        AUTHENTICATION_FAILED: 'Authentication failed',
-        // Authorization errors  
-        ACCESS_DENIED: 'Access denied',
-        // Validation errors
-        VALIDATION_FAILED: 'Validation failed',
-        // Not found errors
-        RESOURCE_NOT_FOUND: 'Resource not found',
-        // Rate limit errors
-        RATE_LIMIT_EXCEEDED: 'Rate limit exceeded',
-        // Server errors
-        INTERNAL_SERVER_ERROR: 'Internal Server error occurred',
-        // Network errors
-        NETWORK_ERROR: 'Network error occurred',
-        REQUEST_TIMEOUT: 'Request timed out',
-        REQUEST_ABORTED: 'Request was aborted',
-    };
-    /**
-     * Error name constants for network error identification
-     */
-    const ErrorNames = {
-        ABORT_ERROR: 'AbortError'};
-
-    /**
-     * Error thrown when authentication fails (401 errors)
-     * Common scenarios:
-     * - Invalid credentials
-     * - Expired token
-     * - Missing authentication
-     */
-    class AuthenticationError extends UiPathError {
-        constructor(params = {}) {
-            super(ErrorType.AUTHENTICATION, {
-                message: params.message || ErrorMessages.AUTHENTICATION_FAILED,
-                statusCode: params.statusCode ?? HttpStatus.UNAUTHORIZED,
-                requestId: params.requestId
-            });
-        }
-    }
-
-    /**
-     * Error thrown when authorization fails (403 errors)
-     * Common scenarios:
-     * - Insufficient permissions
-     * - Access denied to resource
-     * - Invalid scope
-     */
-    class AuthorizationError extends UiPathError {
-        constructor(params = {}) {
-            super(ErrorType.AUTHORIZATION, {
-                message: params.message || ErrorMessages.ACCESS_DENIED,
-                statusCode: params.statusCode ?? HttpStatus.FORBIDDEN,
-                requestId: params.requestId
-            });
-        }
-    }
-
-    /**
-     * Error thrown when validation fails (400 errors or client-side validation)
-     * Common scenarios:
-     * - Invalid input parameters
-     * - Missing required fields
-     * - Invalid data format
-     */
-    class ValidationError extends UiPathError {
-        constructor(params = {}) {
-            super(ErrorType.VALIDATION, {
-                message: params.message || ErrorMessages.VALIDATION_FAILED,
-                statusCode: params.statusCode ?? HttpStatus.BAD_REQUEST,
-                requestId: params.requestId
-            });
-        }
-    }
-
-    /**
-     * Error thrown when a resource is not found (404 errors)
-     * Common scenarios:
-     * - Resource doesn't exist
-     * - Invalid ID provided
-     * - Resource deleted
-     */
-    class NotFoundError extends UiPathError {
-        constructor(params = {}) {
-            super(ErrorType.NOT_FOUND, {
-                message: params.message || ErrorMessages.RESOURCE_NOT_FOUND,
-                statusCode: params.statusCode ?? HttpStatus.NOT_FOUND,
-                requestId: params.requestId
-            });
-        }
-    }
-
-    /**
-     * Error thrown when rate limit is exceeded (429 errors)
-     * Common scenarios:
-     * - Too many requests in a time window
-     * - API throttling
-     */
-    class RateLimitError extends UiPathError {
-        constructor(params = {}) {
-            super(ErrorType.RATE_LIMIT, {
-                message: params.message || ErrorMessages.RATE_LIMIT_EXCEEDED,
-                statusCode: params.statusCode ?? HttpStatus.TOO_MANY_REQUESTS,
-                requestId: params.requestId
-            });
-        }
-    }
-
-    /**
-     * Error thrown when server encounters an error (5xx errors)
-     * Common scenarios:
-     * - Internal server error
-     * - Service unavailable
-     * - Gateway timeout
-     */
-    class ServerError extends UiPathError {
-        constructor(params = {}) {
-            super(ErrorType.SERVER, {
-                message: params.message || ErrorMessages.INTERNAL_SERVER_ERROR,
-                statusCode: params.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR,
-                requestId: params.requestId
-            });
+         */
+        async completeOAuth() {
+            if (!AuthService.isInOAuthCallback()) {
+                throw new Error('Not in OAuth callback state. Call initialize() first to start OAuth flow.');
+            }
+            try {
+                const success = await __classPrivateFieldGet(this, _UiPath_authService, "f").authenticate(__classPrivateFieldGet(this, _UiPath_config, "f"));
+                if (success && this.isAuthenticated()) {
+                    __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
+                    return true;
+                }
+                return false;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                throw new Error(`Failed to complete OAuth: ${errorMessage}`);
+            }
         }
         /**
-         * Checks if this is a temporary error that might succeed on retry
+         * Check if the user is authenticated (has valid token)
          */
-        get isRetryable() {
-            return this.statusCode === HttpStatus.BAD_GATEWAY ||
-                this.statusCode === HttpStatus.SERVICE_UNAVAILABLE ||
-                this.statusCode === HttpStatus.GATEWAY_TIMEOUT;
-        }
-    }
-
-    /**
-     * Error thrown when network/connection issues occur
-     * Common scenarios:
-     * - Connection timeout
-     * - DNS resolution failure
-     * - Network unreachable
-     * - Request aborted
-     */
-    class NetworkError extends UiPathError {
-        constructor(params = {}) {
-            super(ErrorType.NETWORK, {
-                message: params.message || ErrorMessages.NETWORK_ERROR,
-                statusCode: params.statusCode, // Network errors typically don't have HTTP status codes
-                requestId: params.requestId
-            });
-        }
-    }
-
-    /**
-     * Type guard to check if an error is a UiPathError
-     */
-    function isUiPathError(error) {
-        return error instanceof UiPathError;
-    }
-    /**
-     * Type guard to check if an error is an AuthenticationError
-     */
-    function isAuthenticationError(error) {
-        return error instanceof AuthenticationError;
-    }
-    /**
-     * Type guard to check if an error is an AuthorizationError
-     */
-    function isAuthorizationError(error) {
-        return error instanceof AuthorizationError;
-    }
-    /**
-     * Type guard to check if an error is a ValidationError
-     */
-    function isValidationError(error) {
-        return error instanceof ValidationError;
-    }
-    /**
-     * Type guard to check if an error is a NotFoundError
-     */
-    function isNotFoundError(error) {
-        return error instanceof NotFoundError;
-    }
-    /**
-     * Type guard to check if an error is a RateLimitError
-     */
-    function isRateLimitError(error) {
-        return error instanceof RateLimitError;
-    }
-    /**
-     * Type guard to check if an error is a ServerError
-     */
-    function isServerError(error) {
-        return error instanceof ServerError;
-    }
-    /**
-     * Type guard to check if an error is a NetworkError
-     */
-    function isNetworkError(error) {
-        return error instanceof NetworkError;
-    }
-    /**
-     * Helper to get error details in a safe way
-     */
-    function getErrorDetails(error) {
-        if (isUiPathError(error)) {
-            return {
-                message: error.message,
-                statusCode: error.statusCode
-            };
+        isAuthenticated() {
+            return __classPrivateFieldGet(this, _UiPath_authService, "f").hasValidToken();
         }
-        if (error instanceof Error) {
-            return {
-                message: error.message
-            };
+        /**
+         * Get the current authentication token
+         */
+        getToken() {
+            return __classPrivateFieldGet(this, _UiPath_authService, "f").getToken();
         }
-        return {
-            message: String(error)
-        };
-    }
+    };
+    _UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_initialized = new WeakMap();
 
     /**
      * Type guards for error response types
@@ -9430,29 +9480,7 @@
          * @throws AuthenticationError if no token available or refresh fails
          */
         async getValidToken() {
-            // Try to get token info from context
-            const tokenInfo = this.executionContext.get('tokenInfo');
-            if (!tokenInfo) {
-                throw new AuthenticationError({ message: 'No authentication token available. Make sure to initialize the SDK first.' });
-            }
-            // For secret-based tokens, they never expire
-            if (tokenInfo.type === 'secret') {
-                return tokenInfo.token;
-            }
-            // If token is not expired, return it
-            if (!this.tokenManager.isTokenExpired(tokenInfo)) {
-                return tokenInfo.token;
-            }
-            try {
-                const newToken = await this.tokenManager.refreshAccessToken();
-                return newToken.access_token;
-            }
-            catch (error) {
-                throw new AuthenticationError({
-                    message: `Token refresh failed: ${error.message}. Please re-authenticate.`,
-                    statusCode: HttpStatus.UNAUTHORIZED
-                });
-            }
+            return this.tokenManager.getValidToken();
         }
         async getDefaultHeaders() {
             // Get headers from execution context first
@@ -10137,6 +10165,51 @@
             return acc;
         }, {});
     }
+    /**
+     * Transforms request data from SDK field names to API field names.
+     *
+     * This is the inverse of `transformData` - while `transformData` converts
+     * API responses to SDK format (API → SDK), this function converts SDK
+     * requests to API format (SDK → API).
+     *
+     * @param data The request data with SDK field names
+     * @param responseMap The response mapping (API → SDK) - will be automatically reversed
+     * @returns A new object with API field names
+     *
+     * @example
+     * ```typescript
+     * // Response map: API field → SDK field
+     * const ProcessMap = { releaseKey: 'processKey', releaseName: 'processName' };
+     *
+     * // SDK request with SDK field names
+     * const sdkRequest = { processKey: 'abc-123', processName: 'MyProcess' };
+     *
+     * // Transform to API format
+     * const apiRequest = transformRequest(sdkRequest, ProcessMap);
+     * // Result: { releaseKey: 'abc-123', releaseName: 'MyProcess' }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Conversation example
+     * const ConversationMap = { agentReleaseId: 'agentId' };
+     *
+     * const sdkOptions = { agentId: 123, folderId: 456, label: 'My Chat' };
+     * const apiPayload = transformRequest(sdkOptions, ConversationMap);
+     * // Result: { agentReleaseId: 123, folderId: 456, label: 'My Chat' }
+     * ```
+     */
+    function transformRequest(data, responseMap) {
+        const result = { ...data };
+        const requestMap = reverseMap(responseMap);
+        for (const [sdkField, apiField] of Object.entries(requestMap)) {
+            if (sdkField in result) {
+                result[apiField] = result[sdkField];
+                delete result[sdkField];
+            }
+        }
+        return result;
+    }
     /**
      * Transforms an array-based dictionary with separate keys and values arrays
      * into a standard JavaScript object/record
@@ -10394,10 +10467,7 @@
          */
         static async getAll(config, options) {
             const optionsWithDefaults = options || {};
-            const { folderId, ...restOptions } = optionsWithDefaults;
-            const cursor = options?.cursor;
-            const pageSize = options?.pageSize;
-            const jumpToPage = options?.jumpToPage;
+            const { folderId, pageSize, cursor, jumpToPage, ...restOptions } = optionsWithDefaults;
             // Determine if pagination is requested
             const isPaginationRequested = PaginationHelpers.hasPaginationParameters(options || {});
             // Process parameters (custom processing if provided, otherwise default)
@@ -14100,17 +14170,8 @@
          */
         async start(request, folderId, options = {}) {
             const headers = createHeaders({ [FOLDER_ID]: folderId });
-            // Transform processKey/processName to releaseKey/releaseName for API compatibility
-            const apiRequest = { ...request };
-            // Create a reverse mapping using ProcessMap
-            const reversedPropertiesMap = reverseMap(ProcessMap);
-            // Apply transformations for any client properties found in the request
-            Object.entries(reversedPropertiesMap).forEach(([clientKey, apiKey]) => {
-                if (clientKey in apiRequest) {
-                    apiRequest[apiKey] = apiRequest[clientKey];
-                    delete apiRequest[clientKey];
-                }
-            });
+            // Transform SDK field names to API field names (e.g., processKey → releaseKey)
+            const apiRequest = transformRequest(request, ProcessMap);
             // Create the request object according to API spec
             const requestBody = {
                 startInfo: apiRequest
@@ -14518,7 +14579,266 @@
         JobState["Resumed"] = "Resumed";
     })(exports.JobState || (exports.JobState = {}));
 
+    /**
+     * Common Constants for Conversational Agent
+     */
+    /**
+     * Common field mappings shared across all conversational agent entities.
+     * Maps API response fields to SDK-consistent naming conventions.
+     */
+    const CommonFieldMap = {
+        createdAt: 'createdTime',
+        updatedAt: 'updatedTime'
+    };
+
+    /**
+     * Constants for Conversational Agent
+     */
+    /**
+     * Maps API response fields to SDK field names (API → SDK)
+     * Used when transforming API responses for SDK consumers.
+     * For request transformation (SDK → API), use `transformRequest(data, ConversationMap)`.
+     */
+    const ConversationMap = {
+        ...CommonFieldMap,
+        conversationId: 'id',
+        lastActivityAt: 'lastActivityTime',
+        agentReleaseId: 'agentId'
+    };
+    /**
+     * Maps fields for Exchange entity to ensure consistent SDK naming
+     */
+    const ExchangeMap = {
+        ...CommonFieldMap
+    };
+    /**
+     * Maps fields for Message entity to ensure consistent SDK naming
+     */
+    const MessageMap = {
+        ...CommonFieldMap
+    };
+
+    /**
+     * Common types for Conversational Agent
+     * Contains IDs, primitives, and utility types used across conversation types.
+     */
+    /**
+     * Identifies the origin of a message in the conversation.
+     */
+    exports.MessageRole = void 0;
+    (function (MessageRole) {
+        MessageRole["System"] = "system";
+        MessageRole["User"] = "user";
+        MessageRole["Assistant"] = "assistant";
+    })(exports.MessageRole || (exports.MessageRole = {}));
+    /**
+     * Identifies the type of an interrupt.
+     */
+    exports.InterruptType = void 0;
+    (function (InterruptType) {
+        InterruptType["ToolCallConfirmation"] = "uipath_cas_tool_call_confirmation";
+    })(exports.InterruptType || (exports.InterruptType = {}));
+
+    /**
+     * Core data model types for Conversational Agent REST endpoints
+     * Contains: Conversation, Exchange, Message, ContentPart, ToolCall, etc.
+     */
+    /**
+     * Represents the order in which items should be sorted.
+     */
+    exports.SortOrder = void 0;
+    (function (SortOrder) {
+        SortOrder["Ascending"] = "ascending";
+        SortOrder["Descending"] = "descending";
+    })(exports.SortOrder || (exports.SortOrder = {}));
+    /**
+     * Feedback rating type.
+     */
+    exports.FeedbackRating = void 0;
+    (function (FeedbackRating) {
+        FeedbackRating["Positive"] = "positive";
+        FeedbackRating["Negative"] = "negative";
+    })(exports.FeedbackRating || (exports.FeedbackRating = {}));
+
+    /**
+     * Event types for Conversational Agent WebSocket protocol
+     */
+    /**
+     * Identifies how sensitive the LLM should be when detecting the start or end of speech.
+     *
+     *     * UNSPECIFIED - the default is HIGH
+     *     * HIGH - Will detect the start/end of speech more often.
+     *     * LOW - Will detect the start/end of speech less often.
+     */
+    exports.InputStreamSpeechSensitivity = void 0;
+    (function (InputStreamSpeechSensitivity) {
+        InputStreamSpeechSensitivity["Unspecified"] = "UNSPECIFIED";
+        InputStreamSpeechSensitivity["High"] = "HIGH";
+        InputStreamSpeechSensitivity["Low"] = "LOW";
+    })(exports.InputStreamSpeechSensitivity || (exports.InputStreamSpeechSensitivity = {}));
+
+    /**
+     * Content Part Stream Types
+     *
+     * Defines the public API for interacting with streaming content parts
+     * within a message. Content parts represent text, audio, images, etc.
+     */
+    /**
+     * Types of citation processing errors
+     */
+    exports.CitationErrorType = void 0;
+    (function (CitationErrorType) {
+        CitationErrorType["CitationNotEnded"] = "CitationNotEnded";
+        CitationErrorType["CitationNotStarted"] = "CitationNotStarted";
+    })(exports.CitationErrorType || (exports.CitationErrorType = {}));
+
+    /**
+     * Conversation Service Model
+     *
+     * This interface defines the HTTP CRUD operations for conversations
+     * and real-time WebSocket session management.
+     */
+    /**
+     * Creates methods for a conversation
+     *
+     * @param conversationData - The conversation data (response from API)
+     * @param service - The conversation service instance
+     * @param sessionMethods - Optional session methods for WebSocket session operations
+     * @param exchangeService - Optional exchange service for scoped exchange methods
+     * @returns Object containing conversation methods
+     */
+    function createConversationMethods(conversationData, service, sessionMethods, exchangeService) {
+        return {
+            exchanges: {
+                getAll(options) {
+                    if (!conversationData.id)
+                        throw new Error('Conversation ID is undefined');
+                    if (!exchangeService)
+                        throw new Error('Exchange methods are not available.');
+                    return exchangeService.getAll(conversationData.id, options);
+                },
+                getById(exchangeId, options) {
+                    if (!conversationData.id)
+                        throw new Error('Conversation ID is undefined');
+                    if (!exchangeService)
+                        throw new Error('Exchange methods are not available.');
+                    return exchangeService.getById(conversationData.id, exchangeId, options);
+                },
+                createFeedback(exchangeId, options) {
+                    if (!conversationData.id)
+                        throw new Error('Conversation ID is undefined');
+                    if (!exchangeService)
+                        throw new Error('Exchange methods are not available.');
+                    return exchangeService.createFeedback(conversationData.id, exchangeId, options);
+                }
+            },
+            async update(options) {
+                if (!conversationData.id)
+                    throw new Error('Conversation ID is undefined');
+                return service.updateById(conversationData.id, options);
+            },
+            async delete() {
+                if (!conversationData.id)
+                    throw new Error('Conversation ID is undefined');
+                return service.deleteById(conversationData.id);
+            },
+            startSession(options) {
+                if (!conversationData.id)
+                    throw new Error('Conversation ID is undefined');
+                if (!sessionMethods) {
+                    throw new Error('Session methods are not available. Use ConversationService to create conversations with session support.');
+                }
+                return sessionMethods.startSession(conversationData.id, options);
+            },
+            getSession() {
+                if (!conversationData.id)
+                    throw new Error('Conversation ID is undefined');
+                if (!sessionMethods) {
+                    throw new Error('Session methods are not available. Use ConversationService to create conversations with session support.');
+                }
+                return sessionMethods.getSession(conversationData.id);
+            },
+            endSession() {
+                if (!conversationData.id)
+                    throw new Error('Conversation ID is undefined');
+                if (!sessionMethods) {
+                    throw new Error('Session methods are not available. Use ConversationService to create conversations with session support.');
+                }
+                sessionMethods.endSession(conversationData.id);
+            },
+            async uploadAttachment(file) {
+                if (!conversationData.id)
+                    throw new Error('Conversation ID is undefined');
+                return service.uploadAttachment(conversationData.id, file);
+            }
+        };
+    }
+    /**
+     * Creates an actionable conversation by combining API conversation data with operational methods.
+     *
+     * @param conversationData - The conversation data from API
+     * @param service - The conversation service instance
+     * @param sessionMethods - Optional session methods for WebSocket session operations
+     * @param exchangeService - Optional exchange service for scoped exchange methods
+     * @returns A conversation object with added methods
+     */
+    function createConversationWithMethods(conversationData, service, sessionMethods, exchangeService) {
+        const methods = createConversationMethods(conversationData, service, sessionMethods, exchangeService);
+        return Object.assign({}, conversationData, methods);
+    }
+
+    /**
+     * Agent Service Models
+     *
+     * Provides fluent API for agent objects returned from getAll() and getById().
+     */
+    /**
+     * Creates methods for an agent
+     *
+     * @param agentData - The agent data from API
+     * @param conversationService - The conversation service instance for delegation
+     * @returns Object containing agent methods
+     */
+    function createAgentMethods(agentData, conversationService) {
+        const agentConversations = {
+            async create(options = {}) {
+                return conversationService.create(agentData.id, agentData.folderId, options);
+            }
+        };
+        return {
+            conversations: agentConversations,
+            get connectionStatus() { return conversationService.connectionStatus; },
+            get isConnected() { return conversationService.isConnected; },
+            get connectionError() { return conversationService.connectionError; }
+        };
+    }
+    function createAgentWithMethods(agentData, conversationService) {
+        const methods = createAgentMethods(agentData, conversationService);
+        return Object.defineProperties(Object.assign({}, agentData), Object.getOwnPropertyDescriptors(methods));
+    }
+
+    /**
+     * Constants for Agent Service
+     */
+    /**
+     * Maps fields for Agent entities to ensure consistent SDK naming
+     */
+    const AgentMap = {
+        ...CommonFieldMap
+    };
+
+    /**
+     * Constants for User Service
+     */
+    /**
+     * Maps fields for User Settings entities to ensure consistent SDK naming
+     */
+    const UserSettingsMap = {
+        ...CommonFieldMap
+    };
+
     exports.APP_NAME = APP_NAME;
+    exports.AgentMap = AgentMap;
     exports.AuthenticationError = AuthenticationError;
     exports.AuthorizationError = AuthorizationError;
     exports.CLOUD_CLIENT_ID = CLOUD_CLIENT_ID;
@@ -14528,12 +14848,15 @@
     exports.CLOUD_TENANT_NAME = CLOUD_TENANT_NAME;
     exports.CLOUD_URL = CLOUD_URL;
     exports.CONNECTION_STRING = CONNECTION_STRING;
+    exports.ConversationMap = ConversationMap;
     exports.DEFAULT_ITEMS_FIELD = DEFAULT_ITEMS_FIELD;
     exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
     exports.DEFAULT_TOTAL_COUNT_FIELD = DEFAULT_TOTAL_COUNT_FIELD;
     exports.ErrorType = ErrorType;
+    exports.ExchangeMap = ExchangeMap;
     exports.HttpStatus = HttpStatus;
     exports.MAX_PAGE_SIZE = MAX_PAGE_SIZE;
+    exports.MessageMap = MessageMap;
     exports.NetworkError = NetworkError;
     exports.NotFoundError = NotFoundError;
     exports.RateLimitError = RateLimitError;
@@ -14546,9 +14869,12 @@
     exports.UNKNOWN = UNKNOWN$1;
     exports.UiPath = UiPath;
     exports.UiPathError = UiPathError;
+    exports.UserSettingsMap = UserSettingsMap;
     exports.VERSION = VERSION;
     exports.ValidationError = ValidationError;
+    exports.createAgentWithMethods = createAgentWithMethods;
     exports.createCaseInstanceWithMethods = createCaseInstanceWithMethods;
+    exports.createConversationWithMethods = createConversationWithMethods;
     exports.createEntityWithMethods = createEntityWithMethods;
     exports.createProcessInstanceWithMethods = createProcessInstanceWithMethods;
     exports.createProcessWithMethods = createProcessWithMethods;