@uipath/uipath-typescript 1.3.8 → 1.3.10

package/dist/index.umd.js

@@ -4516,6 +4516,8 @@
         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`,
+        DELETE_FILE: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.DeleteFile`,
+        GET_FILES: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetFiles`,
     };
     /**
      * Orchestrator Process Service Endpoints
@@ -4592,6 +4594,16 @@
         INSIGHTS: {
             /** SLA summary for case instances */
             SLA_SUMMARY: `${INSIGHTS_RTM_BASE}/caseManagement/slaSummary`,
+            /** Stages summary for case instances */
+            STAGES_SUMMARY: `${INSIGHTS_RTM_BASE}/caseManagement/stages`,
+            /** Top processes ranked by run count */
+            TOP_PROCESSES_BY_RUN_COUNT: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopProcessesByRunCount`,
+            /** Top processes ranked by failure count */
+            TOP_PROCESSES_WITH_FAILURE: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopProcesseswithFailure`,
+            /** Instance status aggregated by date for time-series charts */
+            INSTANCE_STATUS_BY_DATE: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/InstanceStatusByDate`,
+            /** Top processes ranked by total duration */
+            TOP_PROCESSES_BY_DURATION: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopProcessesByDuration`,
         },
     };
 
@@ -4631,6 +4643,12 @@
         CHOICESETS: {
             GET_ALL: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
             GET_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/query_expansion`,
+            CREATE: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
+            UPDATE: (choiceSetId) => `${DATAFABRIC_BASE}/api/Entity/${choiceSetId}/metadata`,
+            DELETE: (choiceSetId) => `${DATAFABRIC_BASE}/api/Entity/${choiceSetId}/delete`,
+            INSERT_BY_NAME: (choiceSetName) => `${DATAFABRIC_BASE}/api/EntityService/${choiceSetName}/choiceset/insert`,
+            UPDATE_BY_NAME: (choiceSetName, valueId) => `${DATAFABRIC_BASE}/api/EntityService/${choiceSetName}/choiceset/${valueId}/update`,
+            DELETE_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/choiceset/delete`,
         },
     };
 
@@ -9221,54 +9239,56 @@
     }
 
     /**
-     * SDK Telemetry constants
+     * Common telemetry attribute keys + Application Insights connection string.
+     *
+     * Producer-specific identity (SDK version, role name, etc.) is supplied at
+     * runtime via `TelemetryClient.initialize(...)` so the same package can be
+     * reused by multiple packages. The Application Insights connection string is
+     * shared across all consumers and is patched into this file at publish time.
      */
     // 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.3.8";
-    const VERSION = "Version";
-    const SERVICE = "Service";
-    const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
-    const CLOUD_TENANT_NAME = "CloudTenantName";
-    const CLOUD_URL = "CloudUrl";
-    const CLOUD_CLIENT_ID = "CloudClientId";
-    const CLOUD_REDIRECT_URI = "CloudRedirectUri";
-    const APP_NAME = "ApplicationName";
-    const CLOUD_ROLE_NAME = "uipath-ts-sdk";
-    // Service and logger names
-    const SDK_SERVICE_NAME = "UiPath.TypeScript.Sdk";
-    const SDK_LOGGER_NAME = "uipath-ts-sdk-telemetry";
-    // Event names
-    const SDK_RUN_EVENT = "Sdk.Run";
-    // Default value for unknown/empty attributes
-    const UNKNOWN$1 = "";
+    const CONNECTION_STRING = '$CONNECTION_STRING';
+    const VERSION = 'Version';
+    const SERVICE = 'Service';
+    const CLOUD_ORGANIZATION_NAME = 'CloudOrganizationName';
+    const CLOUD_TENANT_NAME = 'CloudTenantName';
+    const CLOUD_URL = 'CloudUrl';
+    const CLOUD_CLIENT_ID = 'CloudClientId';
+    const CLOUD_REDIRECT_URI = 'CloudRedirectUri';
+    const APP_NAME = 'ApplicationName';
+    /** Default value used when an attribute has no resolved value. */
+    const UNKNOWN$1 = '';
 
+    const INSTRUMENTATION_KEY_RE = /InstrumentationKey=([^;]+)/;
+    const INGESTION_ENDPOINT_RE = /IngestionEndpoint=([^;]+)/;
     /**
-     * Log exporter that sends ALL logs as Application Insights custom events
+     * Sends every emitted log record as an Application Insights custom event.
+     * Plugged into OpenTelemetry's `BatchLogRecordProcessor`, which buffers and
+     * flushes log records to this exporter on its own schedule.
      */
     class ApplicationInsightsEventExporter {
-        constructor(connectionString) {
+        constructor(connectionString, tags) {
             this.connectionString = connectionString;
+            this.tags = tags;
         }
         export(logs, resultCallback) {
             try {
-                logs.forEach(logRecord => {
-                    this.sendAsCustomEvent(logRecord);
-                });
+                for (const log of logs) {
+                    this.sendAsCustomEvent(log);
+                }
                 resultCallback({ code: 0 });
             }
             catch (error) {
-                console.debug('Failed to export logs to Application Insights:', error);
-                resultCallback({ code: 2, error });
+                const err = error instanceof Error ? error : new Error(String(error));
+                console.debug('Failed to export logs to Application Insights:', err);
+                resultCallback({ code: 1, error: err });
             }
         }
         shutdown() {
             return Promise.resolve();
         }
         sendAsCustomEvent(logRecord) {
-            // Get event name from body or attributes
-            const eventName = logRecord.body || SDK_RUN_EVENT;
+            const eventName = String(logRecord.body);
             const payload = {
                 name: 'Microsoft.ApplicationInsights.Event',
                 time: new Date().toISOString(),
@@ -9278,25 +9298,25 @@
                     baseData: {
                         ver: 2,
                         name: eventName,
-                        properties: this.convertAttributesToProperties(logRecord.attributes || {})
-                    }
+                        properties: this.convertAttributesToProperties(logRecord.attributes),
+                    },
                 },
                 tags: {
-                    'ai.cloud.role': CLOUD_ROLE_NAME,
-                    'ai.cloud.roleInstance': SDK_VERSION
-                }
+                    'ai.cloud.role': this.tags.cloudRoleName,
+                    'ai.cloud.roleInstance': this.tags.cloudRoleInstance,
+                },
             };
-            this.sendToApplicationInsights(payload);
+            void this.sendToApplicationInsights(payload);
         }
         extractInstrumentationKey() {
-            const match = this.connectionString.match(/InstrumentationKey=([^;]+)/);
+            const match = INSTRUMENTATION_KEY_RE.exec(this.connectionString);
             return match ? match[1] : '';
         }
         convertAttributesToProperties(attributes) {
             const properties = {};
-            Object.entries(attributes || {}).forEach(([key, value]) => {
+            for (const [key, value] of Object.entries(attributes ?? {})) {
                 properties[key] = String(value);
-            });
+            }
             return properties;
         }
         async sendToApplicationInsights(payload) {
@@ -9309,10 +9329,8 @@
                 const url = `${ingestionEndpoint}/v2/track`;
                 const response = await fetch(url, {
                     method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify(payload)
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(payload),
                 });
                 if (!response.ok) {
                     console.debug(`Failed to send event telemetry: ${response.status} ${response.statusText}`);
@@ -9323,101 +9341,102 @@
             }
         }
         extractIngestionEndpoint() {
-            const match = this.connectionString.match(/IngestionEndpoint=([^;]+)/);
+            const match = INGESTION_ENDPOINT_RE.exec(this.connectionString);
             return match ? match[1] : '';
         }
     }
     /**
-     * Singleton telemetry client
+     * Telemetry client owned by a single consumer (e.g. the SDK or the Coded
+     * Action Apps package). Each consumer instantiates its own client so that
+     * its identity (`cloudRoleName`, `serviceName`, `sdkVersion`, …) and tenant
+     * context flow through to its own `Logger` and exporter pipeline. Two
+     * consumers running in the same process emit independent events — they
+     * share the Application Insights connection string but nothing else.
+     *
+     * Records are emitted via `Logger.emit` and batched by
+     * `BatchLogRecordProcessor` before being handed to the Application Insights
+     * exporter.
      */
     class TelemetryClient {
         constructor() {
             this.isInitialized = false;
         }
-        static getInstance() {
-            if (!TelemetryClient.instance) {
-                TelemetryClient.instance = new TelemetryClient();
-            }
-            return TelemetryClient.instance;
-        }
-        /**
-         * Initialize telemetry
-         */
-        initialize(config) {
+        initialize(options) {
             if (this.isInitialized) {
+                console.debug('Telemetry client has already been initialized');
                 return;
             }
             this.isInitialized = true;
-            if (config) {
-                this.telemetryContext = config;
-            }
+            this.options = options;
+            this.telemetryContext = options.context;
             try {
-                const connectionString = this.getConnectionString();
-                if (!connectionString) {
+                if (!this.isValidConnectionString(CONNECTION_STRING)) {
                     return;
                 }
-                this.setupTelemetryProvider(connectionString);
+                this.setupTelemetryProvider(CONNECTION_STRING);
             }
             catch (error) {
-                // Silent failure - telemetry errors shouldn't break functionality
-                console.debug('Failed to initialize OpenTelemetry:', error);
+                console.debug('Failed to initialize telemetry:', error);
             }
         }
-        getConnectionString() {
-            const connectionString = CONNECTION_STRING;
-            return connectionString;
-        }
-        setupTelemetryProvider(connectionString) {
-            const exporter = new ApplicationInsightsEventExporter(connectionString);
-            const processor = new BatchLogRecordProcessor(exporter);
-            this.logProvider = new LoggerProvider({
-                processors: [processor]
-            });
-            this.logger = this.logProvider.getLogger(SDK_LOGGER_NAME);
-        }
-        /**
-         * Track a telemetry event
-         */
         track(eventName, name, extraAttributes = {}) {
             try {
-                // Skip if logger not initialized
                 if (!this.logger) {
                     return;
                 }
-                const finalDisplayName = name || eventName;
+                const finalDisplayName = name ?? eventName;
                 const attributes = this.getEnrichedAttributes(extraAttributes, eventName);
-                // Emit as log 
                 this.logger.emit({
                     body: finalDisplayName,
-                    attributes: attributes,
+                    attributes,
                     timestamp: Date.now(),
                 });
             }
             catch (error) {
-                // Silent failure
                 console.debug('Failed to track telemetry event:', error);
             }
         }
         /**
-         * Get enriched attributes for telemetry events
+         * Default event name (e.g. `Sdk.Run`) used when a tracker fires without
+         * an explicit display name. Returns `undefined` until `initialize` runs.
          */
+        getDefaultEventName() {
+            return this.options?.defaultEventName;
+        }
+        setupTelemetryProvider(connectionString) {
+            // `setupTelemetryProvider` is only called from `initialize` after
+            // `this.options` has been assigned, so the non-null assertion is safe.
+            const opts = this.options;
+            const exporter = new ApplicationInsightsEventExporter(connectionString, {
+                cloudRoleName: opts.cloudRoleName,
+                cloudRoleInstance: opts.sdkVersion,
+            });
+            const processor = new BatchLogRecordProcessor(exporter);
+            this.logProvider = new LoggerProvider({
+                processors: [processor],
+            });
+            this.logger = this.logProvider.getLogger(opts.loggerName);
+        }
+        isValidConnectionString(connectionString) {
+            // Build placeholders are emitted as `$CONNECTION_STRING` literally
+            // until the publish workflow patches them. Treat any unsubstituted
+            // placeholder as "no connection string available".
+            return Boolean(connectionString) && !connectionString.startsWith('$');
+        }
         getEnrichedAttributes(extraAttributes, eventName) {
-            const attributes = {
-                [APP_NAME]: SDK_SERVICE_NAME,
-                [VERSION]: SDK_VERSION,
+            const opts = this.options;
+            return {
+                [APP_NAME]: opts?.serviceName ?? UNKNOWN$1,
+                [VERSION]: opts?.sdkVersion ?? UNKNOWN$1,
                 [SERVICE]: eventName,
                 [CLOUD_URL]: this.createCloudUrl(),
-                [CLOUD_ORGANIZATION_NAME]: this.telemetryContext?.orgName || UNKNOWN$1,
-                [CLOUD_TENANT_NAME]: this.telemetryContext?.tenantName || UNKNOWN$1,
-                [CLOUD_REDIRECT_URI]: this.telemetryContext?.redirectUri || UNKNOWN$1,
-                [CLOUD_CLIENT_ID]: this.telemetryContext?.clientId || UNKNOWN$1,
+                [CLOUD_ORGANIZATION_NAME]: this.telemetryContext?.orgName ?? UNKNOWN$1,
+                [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;
         }
-        /**
-         * Create cloud URL from base URL, organization ID, and tenant ID
-         */
         createCloudUrl() {
             const baseUrl = this.telemetryContext?.baseUrl;
             const orgId = this.telemetryContext?.orgName;
@@ -9428,78 +9447,166 @@
             return `${baseUrl}/${orgId}/${tenantId}`;
         }
     }
-    // Export singleton instance
-    const telemetryClient = TelemetryClient.getInstance();
 
     /**
-     * SDK Track decorator and function for telemetry
+     * Each consumer ships as multiple subpath bundles and Rollup inlines this
+     * shim into every one — `new TelemetryClient()` would hand each bundle its
+     * own (uninitialized) client. `getOrCreateClient(name)` instead parks the
+     * client on `globalThis` so every bundle shares one client per name.
+     */
+    const REGISTRY_KEY$1 = Symbol.for('@uipath/core-telemetry/clients');
+    function getGlobalRegistry() {
+        const holder = globalThis;
+        let registry = holder[REGISTRY_KEY$1];
+        if (!registry) {
+            registry = {};
+            holder[REGISTRY_KEY$1] = registry;
+        }
+        return registry;
+    }
+    /**
+     * Returns the named `TelemetryClient`, creating it on first access.
+     *
+     * @param name Stable identifier for the consumer (e.g. `"uipath-ts-sdk"`,
+     *   `"uipath-ts-coded-action-apps"`). Subpath bundles within the same
+     *   consumer share a client by passing the same name.
      */
+    function getOrCreateClient(name) {
+        const registry = getGlobalRegistry();
+        if (!registry[name]) {
+            registry[name] = new TelemetryClient();
+        }
+        return registry[name];
+    }
+
     /**
-     * Common tracking logic shared between method and function decorators
+     * `@track` decorator and `trackEvent` function factories.
      */
-    function createTrackedFunction(originalFunction, nameOrOptions, fallbackName, opts) {
-        return function (...args) {
-            // Determine if we should track this call
+    function createTrackedFunction(originalFunction, { client, nameOrOptions, fallbackName, opts }) {
+        const wrapped = function (...args) {
             let shouldTrack = true;
             if (opts.condition !== undefined) {
-                if (typeof opts.condition === 'function') {
-                    shouldTrack = opts.condition.apply(this, args);
-                }
-                else {
-                    shouldTrack = opts.condition;
-                }
+                shouldTrack =
+                    typeof opts.condition === 'function'
+                        ? opts.condition.apply(this, args)
+                        : opts.condition;
             }
-            // Track the event if enabled
             if (shouldTrack) {
-                // Use the full name provided in the decorator (e.g., "Queue.GetAll")
-                const serviceMethod = typeof nameOrOptions === 'string'
-                    ? nameOrOptions
-                    : fallbackName;
-                // Use 'Sdk.Run' as the name and serviceMethod as the service
-                telemetryClient.track(serviceMethod, SDK_RUN_EVENT, opts.attributes);
-            }
-            // Execute the original function
+                const serviceMethod = typeof nameOrOptions === 'string' ? nameOrOptions : fallbackName;
+                client.track(serviceMethod, client.getDefaultEventName(), opts.attributes);
+            }
             return originalFunction.apply(this, args);
         };
+        return wrapped;
     }
     /**
-     * Track decorator that can be used to automatically track function calls
+     * Factory: returns a `track` decorator bound to a specific
+     * `TelemetryClient`. Each consumer creates its own decorator from its own
+     * client so events carry that consumer's identity.
      *
-     * Usage:
-     * @track("Service.Method")
-     * function myFunction() { ... }
+     * @example
+     * ```ts
+     * const sdkClient = new TelemetryClient();
+     * sdkClient.initialize({ ... });
+     * export const track = createTrack(sdkClient);
      *
-     * @track("Queue.GetAll")
+     * // Consumer code
+     * @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() { ... }
+     * @track('Assets.Update', { condition: false })
+     * async update() { ... }
+     * ```
      */
-    function track(nameOrOptions, options) {
-        return function decorator(_target, propertyKey, descriptor) {
-            const opts = typeof nameOrOptions === 'object' ? nameOrOptions : options || {};
-            if (descriptor && typeof descriptor.value === 'function') {
-                // Method decorator
-                descriptor.value = createTrackedFunction(descriptor.value, nameOrOptions, propertyKey || 'unknown_method', opts);
-                return descriptor;
+    function createTrack(client) {
+        function trackFactory(nameOrOptions, options) {
+            const opts = typeof nameOrOptions === 'object' ? nameOrOptions : options ?? {};
+            function decoratorImpl(target, propertyKey, descriptor) {
+                if (descriptor && typeof descriptor.value === 'function') {
+                    const original = descriptor.value;
+                    descriptor.value = createTrackedFunction(original, {
+                        client,
+                        nameOrOptions,
+                        fallbackName: typeof propertyKey === 'string'
+                            ? propertyKey
+                            : 'unknown_method',
+                        opts,
+                    });
+                    return descriptor;
+                }
+                const fn = target;
+                return createTrackedFunction(fn, {
+                    client,
+                    nameOrOptions,
+                    fallbackName: fn.name || 'unknown_function',
+                    opts,
+                });
             }
-            // Function decorator
-            return (originalFunction) => createTrackedFunction(originalFunction, nameOrOptions, originalFunction.name || 'unknown_function', opts);
-        };
+            return decoratorImpl;
+        }
+        return trackFactory;
     }
     /**
-     * Direct tracking function
+     * Factory: returns a `trackEvent` function bound to a specific
+     * `TelemetryClient`. Use for ad-hoc tracking outside method boundaries.
+     *
+     * @example
+     * ```ts
+     * const trackEvent = createTrackEvent(sdkClient);
+     * trackEvent('Sdk.Auth');
+     * ```
      */
-    function trackEvent(eventName, name, attributes) {
-        telemetryClient.track(eventName, name, attributes);
+    function createTrackEvent(client) {
+        return function trackEvent(eventName, name, attributes) {
+            client.track(eventName, name, attributes);
+        };
     }
 
+    /**
+     * SDK Telemetry constants.
+     *
+     * Only the SDK's identity (version, service name, role name, …) lives
+     * here. The Application Insights connection string is injected into
+     * `@uipath/core-telemetry` itself at publish time, and the generic attribute
+     * keys (`Version`, `Service`, `CloudOrganizationName`, …) are owned by
+     * `@uipath/core-telemetry` and consumed there — they are not part of the
+     * SDK's public API.
+     */
+    /** SDK version placeholder — patched by the SDK publish workflow. */
+    const SDK_VERSION = '1.3.10';
+    const CLOUD_ROLE_NAME = 'uipath-ts-sdk';
+    const SDK_SERVICE_NAME = 'UiPath.TypeScript.Sdk';
+    const SDK_LOGGER_NAME = 'uipath-ts-sdk-telemetry';
+    const SDK_RUN_EVENT = 'Sdk.Run';
+
+    /**
+     * UiPath TypeScript SDK Telemetry
+     *
+     * Constructs the SDK's own `TelemetryClient` and binds the SDK-local
+     * `track` / `trackEvent` to it. Each consumer of `@uipath/core-telemetry`
+     * does this independently, so events carry their own consumer's identity
+     * and tenant context.
+     */
+    // Keyed by `CLOUD_ROLE_NAME` so every SDK subpath bundle resolves to the
+    // same `TelemetryClient` instance at runtime. A single `initialize(...)`
+    // from the `UiPath` constructor therefore wires up `@track` decorators
+    // across every subpath bundle (`assets`, `feedback`, `tasks`, …).
+    const sdkClient = getOrCreateClient(CLOUD_ROLE_NAME);
+    const track = createTrack(sdkClient);
+    const trackEvent = createTrackEvent(sdkClient);
+    const telemetryClient = {
+        initialize(context) {
+            sdkClient.initialize({
+                sdkVersion: SDK_VERSION,
+                serviceName: SDK_SERVICE_NAME,
+                cloudRoleName: CLOUD_ROLE_NAME,
+                loggerName: SDK_LOGGER_NAME,
+                defaultEventName: SDK_RUN_EVENT,
+                context,
+            });
+        },
+    };
+
     /**
      * SDK Internals Registry - Internal registry for SDK instances
      *
@@ -10192,14 +10299,25 @@
                 if (!text) {
                     return undefined;
                 }
-                return JSON.parse(text);
+                try {
+                    return JSON.parse(text);
+                }
+                catch (error) {
+                    if (error instanceof SyntaxError) {
+                        throw new ServerError({
+                            message: `Server returned non-JSON response (${response.status} ${response.url}): ${error.message}`,
+                            statusCode: response.status,
+                        });
+                    }
+                    throw error;
+                }
             }
             catch (error) {
                 // If it's already one of our errors, re-throw it
                 if (error.type && error.type.includes('Error')) {
                     throw error;
                 }
-                // Otherwise, it's likely a network error
+                // Otherwise, it's a genuine network/fetch failure
                 throw ErrorFactory.createNetworkError(error);
             }
         }
@@ -11095,9 +11213,9 @@
          * @returns Promise resolving to a paginated result
          */
         static async getAllPaginated(params) {
-            const { serviceAccess, getEndpoint, folderId, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+            const { serviceAccess, getEndpoint, folderId, headers: providedHeaders, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
             const endpoint = getEndpoint(folderId);
-            const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+            const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
             const paginatedResponse = await serviceAccess.requestWithPagination(method, endpoint, paginationParams, {
                 headers,
                 params: additionalParams,
@@ -11125,13 +11243,13 @@
          * @returns Promise resolving to an object with data and totalCount
          */
         static async getAllNonPaginated(params) {
-            const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+            const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, headers: providedHeaders, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
             // Set default field names
             const itemsField = options.itemsField || DEFAULT_ITEMS_FIELD;
             const totalCountField = options.totalCountField || DEFAULT_TOTAL_COUNT_FIELD;
             // Determine endpoint and headers based on folderId
             const endpoint = folderId ? getByFolderEndpoint : getAllEndpoint;
-            const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+            const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
             // Make the API call based on method
             let response;
             if (method === HTTP_METHODS.POST) {
@@ -11190,6 +11308,7 @@
                     serviceAccess: config.serviceAccess,
                     getEndpoint: config.getEndpoint,
                     folderId,
+                    headers: config.headers,
                     paginationParams: cursor ? { cursor, pageSize } : jumpToPage ? { jumpToPage, pageSize } : { pageSize },
                     additionalParams: prefixedOptions,
                     transformFn: config.transformFn,
@@ -11207,6 +11326,7 @@
                 getAllEndpoint: config.getEndpoint(),
                 getByFolderEndpoint: byFolderEndpoint,
                 folderId,
+                headers: config.headers,
                 additionalParams: prefixedOptions,
                 transformFn: config.transformFn,
                 method: config.method,
@@ -12994,7 +13114,7 @@
          *
          * @example
          * ```typescript
-         * import { ChoiceSets } from '@uipath/uipath-typescript/choicesets';
+         * import { ChoiceSets } from '@uipath/uipath-typescript/entities';
          *
          * const choiceSets = new ChoiceSets(sdk);
          *
@@ -13043,6 +13163,188 @@
                 }
             }, options);
         }
+        /**
+         * Creates a new Data Fabric choice set
+         *
+         * @param name - Choice set name. Must start with a
+         *   letter, may contain only letters, numbers, and underscores, length
+         *   3–100 characters (e.g., `"expenseTypes"`).
+         * @param options - Optional choice-set-level settings ({@link ChoiceSetCreateOptions})
+         * @returns Promise resolving to the UUID of the created choice set
+         *
+         * @example
+         * ```typescript
+         * import { ChoiceSets } from '@uipath/uipath-typescript/entities';
+         *
+         * const choicesets = new ChoiceSets(sdk);
+         *
+         * // Minimal create
+         * const expenseTypesId = await choicesets.create("expense_types");
+         *
+         * // With display name and description
+         * const priorityLevelsId = await choicesets.create("priority_levels", {
+         *   displayName: "Priority Levels",
+         *   description: "Ticket priority categories",
+         * });
+         * ```
+         * @internal
+         */
+        async create(name, options) {
+            const opts = options ?? {};
+            const payload = {
+                ...(opts.description !== undefined && { description: opts.description }),
+                ...(opts.displayName !== undefined && { displayName: opts.displayName }),
+                entityDefinition: {
+                    name,
+                    fields: [],
+                    folderId: opts.folderKey ?? DATA_FABRIC_TENANT_FOLDER_ID,
+                },
+            };
+            const response = await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.CREATE, payload);
+            return response.data;
+        }
+        /**
+         * Updates an existing choice set's metadata (display name and/or description).
+         *
+         * **At least one of `displayName` or `description` must be provided** —
+         * the call throws `ValidationError` if both are omitted.
+         *
+         * @param choiceSetId - UUID of the choice set to update
+         * @param options - Metadata fields to change ({@link ChoiceSetUpdateOptions})
+         * @returns Promise resolving when the update is complete
+         *
+         * @example
+         * ```typescript
+         * // First, get the choice set ID using getAll()
+         * const allChoiceSets = await choicesets.getAll();
+         * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+         *
+         * await choicesets.updateById(expenseTypes.id, {
+         *   displayName: "Expense Categories",
+         *   description: "Updated description",
+         * });
+         * ```
+         * @internal
+         */
+        async updateById(choiceSetId, options) {
+            if (options.displayName === undefined && options.description === undefined) {
+                throw new ValidationError({
+                    message: 'updateById requires at least one of displayName or description.',
+                });
+            }
+            await this.patch(DATA_FABRIC_ENDPOINTS.CHOICESETS.UPDATE(choiceSetId), {
+                ...(options.displayName !== undefined && { displayName: options.displayName }),
+                ...(options.description !== undefined && { description: options.description }),
+            });
+        }
+        /**
+         * Deletes a Data Fabric choice set and all its values.
+         *
+         * @param choiceSetId - UUID of the choice set to delete
+         * @returns Promise resolving when the choice set is deleted
+         *
+         * @example
+         * ```typescript
+         * // First, get the choice set ID using getAll()
+         * const allChoiceSets = await choicesets.getAll();
+         * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+         *
+         * await choicesets.deleteById(expenseTypes.id);
+         * ```
+         * @internal
+         */
+        async deleteById(choiceSetId) {
+            await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.DELETE(choiceSetId), {});
+        }
+        /**
+         * Inserts a single value into a choice set.
+         *
+         * @param choiceSetId - UUID of the parent choice set
+         * @param name - Identifier name of the new value (e.g., `"TRAVEL"`)
+         * @param options - Optional fields ({@link ChoiceSetValueInsertOptions})
+         * @returns Promise resolving to the inserted value ({@link ChoiceSetValueInsertResponse})
+         *
+         * @example
+         * ```typescript
+         * // First, get the choice set ID using getAll()
+         * const allChoiceSets = await choicesets.getAll();
+         * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+         *
+         * const inserted = await choicesets.insertValueById(expenseTypes.id, 'TRAVEL', {
+         *   displayName: 'Travel',
+         * });
+         * console.log(inserted.id);
+         * ```
+         * @internal
+         */
+        async insertValueById(choiceSetId, name, options) {
+            const choiceSetName = await this.resolveChoiceSetName(choiceSetId);
+            const payload = {
+                Name: name,
+                ...(options?.displayName !== undefined && { DisplayName: options.displayName }),
+            };
+            const response = await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.INSERT_BY_NAME(choiceSetName), payload);
+            const camelCased = pascalToCamelCaseKeys(response.data);
+            return transformData(camelCased, EntityMap);
+        }
+        /**
+         * Updates an existing choice-set value's display name.
+         *
+         * Only `displayName` is mutable; the value's `name` (identifier) is fixed at
+         * insert time and cannot be changed.
+         *
+         * @param choiceSetId - UUID of the parent choice set
+         * @param valueId - UUID of the value to update
+         * @param displayName - New human-readable display name for the value
+         * @returns Promise resolving to the updated value ({@link ChoiceSetValueUpdateResponse})
+         *
+         * @example
+         * ```typescript
+         * // Get the choice set ID from getAll() and the value ID from getById()
+         * const allChoiceSets = await choicesets.getAll();
+         * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+         * const values = await choicesets.getById(expenseTypes.id);
+         * const travel = values.items.find(v => v.name === 'TRAVEL');
+         *
+         * await choicesets.updateValueById(expenseTypes.id, travel.id, 'Business Travel');
+         * ```
+         * @internal
+         */
+        async updateValueById(choiceSetId, valueId, displayName) {
+            const choiceSetName = await this.resolveChoiceSetName(choiceSetId);
+            const payload = { DisplayName: displayName };
+            const response = await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.UPDATE_BY_NAME(choiceSetName, valueId), payload);
+            const camelCased = pascalToCamelCaseKeys(response.data);
+            return transformData(camelCased, EntityMap);
+        }
+        /**
+         * Deletes one or more values from a choice set.
+         *
+         * @param choiceSetId - UUID of the parent choice set
+         * @param valueIds - Array of value UUIDs to delete
+         * @returns Promise resolving when the values are deleted
+         *
+         * @example
+         * ```typescript
+         * // Get the value IDs from getById()
+         * const values = await choicesets.getById('<choiceSetId>');
+         * const idsToDelete = values.items.slice(0, 2).map(v => v.id);
+         *
+         * await choicesets.deleteValuesById('<choiceSetId>', idsToDelete);
+         * ```
+         * @internal
+         */
+        async deleteValuesById(choiceSetId, valueIds) {
+            await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.DELETE_BY_ID(choiceSetId), valueIds);
+        }
+        async resolveChoiceSetName(choiceSetId) {
+            const all = await this.getAll();
+            const match = all.find(cs => cs.id === choiceSetId);
+            if (!match) {
+                throw new NotFoundError({ message: `Choice set with id '${choiceSetId}' not found.` });
+            }
+            return match.name;
+        }
     }
     __decorate([
         track('Choicesets.GetAll')
@@ -13050,6 +13352,24 @@
     __decorate([
         track('Choicesets.GetById')
     ], ChoiceSetService.prototype, "getById", null);
+    __decorate([
+        track('Choicesets.Create')
+    ], ChoiceSetService.prototype, "create", null);
+    __decorate([
+        track('Choicesets.UpdateById')
+    ], ChoiceSetService.prototype, "updateById", null);
+    __decorate([
+        track('Choicesets.DeleteById')
+    ], ChoiceSetService.prototype, "deleteById", null);
+    __decorate([
+        track('Choicesets.InsertValueById')
+    ], ChoiceSetService.prototype, "insertValueById", null);
+    __decorate([
+        track('Choicesets.UpdateValueById')
+    ], ChoiceSetService.prototype, "updateValueById", null);
+    __decorate([
+        track('Choicesets.DeleteValuesById')
+    ], ChoiceSetService.prototype, "deleteValuesById", null);
 
     /**
      * Maestro Process Models
@@ -13085,6 +13405,53 @@
         return Object.assign({}, processData, methods);
     }
 
+    /**
+     * Builds the request body for Insights RTM "top" endpoints.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param isCaseManagement - Whether to filter for case management processes
+     * @param options - Optional filters (packageId, processKey, version)
+     * @returns Request body for the Insights RTM endpoint
+     * @internal
+     */
+    function buildInsightsTopBody(startTime, endTime, isCaseManagement, options) {
+        return {
+            commonParams: {
+                startTime: startTime.getTime(),
+                endTime: endTime.getTime(),
+                isCaseManagement,
+                ...(options?.packageId ? { packageId: options.packageId } : {}),
+                ...(options?.processKey ? { processKey: options.processKey } : {}),
+                ...(options?.version ? { version: options.version } : {}),
+            }
+        };
+    }
+    /**
+     * Fetches instance status timeline from the Insights API.
+     * Shared implementation used by both MaestroProcessesService and CasesService.
+     *
+     * @param postFn - Bound post method from a BaseService subclass
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param isCaseManagement - Whether to filter for case management processes
+     * @param options - Optional settings for time bucketing granularity
+     * @returns Promise resolving to an array of instance status timeline entries
+     * @internal
+     */
+    async function fetchInstanceStatusTimeline(postFn, startTime, endTime, isCaseManagement, options) {
+        const response = await postFn(MAESTRO_ENDPOINTS.INSIGHTS.INSTANCE_STATUS_BY_DATE, {
+            commonParams: {
+                startTime: startTime.getTime(),
+                endTime: endTime.getTime(),
+                isCaseManagement,
+            },
+            timeSliceUnit: options?.groupBy,
+            timezoneOffset: new Date().getTimezoneOffset() * -1,
+        });
+        return response.data ?? [];
+    }
+
     /**
      * Maps fields for Incident entities
      */
@@ -13461,6 +13828,11 @@
                 if (!instanceData.instanceId)
                     throw new Error('Case instance ID is undefined');
                 return service.getSlaSummary({ ...options, caseInstanceId: instanceData.instanceId });
+            },
+            async getStagesSlaSummary() {
+                if (!instanceData.instanceId)
+                    throw new Error('Case instance ID is undefined');
+                return service.getStagesSlaSummary({ caseInstanceId: instanceData.instanceId });
             }
         };
     }
@@ -13476,6 +13848,40 @@
         return Object.assign({}, instanceData, methods);
     }
 
+    /**
+     * Insights Types
+     * Shared types for Maestro insights analytics endpoints
+     */
+    /**
+     * Time bucketing granularity for insights time-series queries.
+     *
+     * Controls how data points are grouped on the time axis.
+     */
+    exports.TimeInterval = void 0;
+    (function (TimeInterval) {
+        /** Group data points by hour */
+        TimeInterval["Hour"] = "HOUR";
+        /** Group data points by day */
+        TimeInterval["Day"] = "DAY";
+        /** Group data points by week */
+        TimeInterval["Week"] = "WEEK";
+    })(exports.TimeInterval || (exports.TimeInterval = {}));
+    /**
+     * Final instance statuses returned by the instance status timeline endpoint.
+     *
+     * Only includes statuses where the instance has finished execution — Completed, Faulted, or Cancelled.
+     * Active statuses like Running or Paused are not included.
+     */
+    exports.InstanceFinalStatus = void 0;
+    (function (InstanceFinalStatus) {
+        /** Instance completed successfully */
+        InstanceFinalStatus["Completed"] = "Completed";
+        /** Instance encountered an error */
+        InstanceFinalStatus["Faulted"] = "Faulted";
+        /** Instance was cancelled */
+        InstanceFinalStatus["Cancelled"] = "Cancelled";
+    })(exports.InstanceFinalStatus || (exports.InstanceFinalStatus = {}));
+
     /**
      * Maps fields for Process Instance entities to ensure consistent naming
      */
@@ -13851,59 +14257,242 @@
             // Fetch BPMN XML and add element name/type to each incident
             return BpmnHelpers.enrichIncidentsWithBpmnData(rawResponse.data || [], folderKey, this.processInstancesService);
         }
-    }
-    __decorate([
-        track('MaestroProcesses.GetAll')
-    ], MaestroProcessesService.prototype, "getAll", null);
-    __decorate([
-        track('MaestroProcesses.GetIncidents')
-    ], MaestroProcessesService.prototype, "getIncidents", null);
-
-    /**
-     * Service class for Maestro Process Incidents
-     */
-    class ProcessIncidentsService extends BaseService {
         /**
-         * Get all process incidents across all folders
+         * Get the top 5 processes ranked by run count within a time range.
          *
-         * @returns Promise resolving to array of process incident
-         * {@link ProcessIncidentGetAllResponse}
+         * Returns an array of up to 5 processes sorted by how many times they were executed,
+         * useful for identifying the most active processes in a given period.
+         *
+         * @param startTime - Start of the time range to query
+         * @param endTime - End of the time range to query
+         * @param options - Optional filters (packageId, processKey, version)
+         * @returns Promise resolving to an array of {@link ProcessGetTopRunCountResponse}
          * @example
          * ```typescript
-         * import { ProcessIncidents } from '@uipath/uipath-typescript/maestro-processes';
+         * import { MaestroProcesses } from '@uipath/uipath-typescript/maestro-processes';
          *
-         * const processIncidents = new ProcessIncidents(sdk);
-         * const incidents = await processIncidents.getAll();
+         * const maestroProcesses = new MaestroProcesses(sdk);
          *
-         * // Access process incident information
-         * for (const incident of incidents) {
-         *   console.log(`Process: ${incident.processKey}`);
-         *   console.log(`Error: ${incident.errorMessage}`);
-         *   console.log(`Count: ${incident.count}`);
-         *   console.log(`First occurrence: ${incident.firstOccuranceTime}`);
+         * // Get top processes by run count for the last 7 days
+         * const topProcesses = await maestroProcesses.getTopRunCount(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date()
+         * );
+         *
+         * for (const process of topProcesses) {
+         *   console.log(`${process.packageId}: ${process.runCount} runs`);
          * }
          * ```
+         *
+         * @example
+         * ```typescript
+         * // Get top processes by run count for a specific package
+         * const filtered = await maestroProcesses.getTopRunCount(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date(),
+         *   { packageId: '<packageId>' }
+         * );
+         * ```
          */
-        async getAll() {
-            const rawResponse = await this.get(MAESTRO_ENDPOINTS.INCIDENTS.GET_ALL);
-            // Transform field names  
-            const data = rawResponse.data || [];
-            return data.map(incident => transformData(incident, ProcessIncidentSummaryMap));
+        async getTopRunCount(startTime, endTime, options) {
+            const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.TOP_PROCESSES_BY_RUN_COUNT, buildInsightsTopBody(startTime, endTime, false, options));
+            return (data ?? []).map(process => ({ ...process, name: process.packageId }));
         }
-    }
-    __decorate([
-        track('ProcessIncidents.getAll')
-    ], ProcessIncidentsService.prototype, "getAll", null);
-
-    /**
-     * Internal types for Maestro Cases
-     * These types are used internally by the cases service
-     */
-    /**
-     * Process type enum for filtering
-     */
-    var ProcessType;
-    (function (ProcessType) {
+        /**
+         * Get all instances status counts aggregated by date for maestro processes.
+         *
+         * Returns time-grouped counts of instances grouped by status (Completed, Faulted, Cancelled),
+         * useful for rendering time-series charts. Use `groupBy` to control the time bucket size
+         * (hour, day, or week) — defaults to day if not provided.
+         *
+         * @param startTime - Start of the time range to query
+         * @param endTime - End of the time range to query
+         * @param options - Optional settings for time bucketing granularity
+         * @returns Promise resolving to an array of {@link InstanceStatusTimelineResponse}
+         *
+         * @example
+         * ```typescript
+         * // Get daily instance status for the last 7 days
+         * const now = new Date();
+         * const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+         * const statuses = await maestroProcesses.getInstanceStatusTimeline(sevenDaysAgo, now);
+         *
+         * for (const entry of statuses) {
+         *   console.log(`${entry.startTime} — ${entry.status}: ${entry.count}`);
+         * }
+         * ```
+         *
+         * @example
+         * ```typescript
+         * import { TimeInterval } from '@uipath/uipath-typescript/maestro-processes';
+         *
+         * // Get hourly breakdown
+         * const statuses = await maestroProcesses.getInstanceStatusTimeline(startTime, endTime, {
+         *   groupBy: TimeInterval.Hour,
+         * });
+         * ```
+         *
+         * @example
+         * ```typescript
+         * // Get all-time data (from Unix epoch to now)
+         * const allTime = await maestroProcesses.getInstanceStatusTimeline(new Date(0), new Date());
+         * ```
+         */
+        async getInstanceStatusTimeline(startTime, endTime, options) {
+            return fetchInstanceStatusTimeline(this.post.bind(this), startTime, endTime, false, options);
+        }
+        /**
+         * Get the top 10 processes ranked by failure count within a time range.
+         *
+         * Returns an array of up to 10 processes sorted by how many instances faulted,
+         * useful for identifying the most error-prone processes in a given period.
+         *
+         * @param startTime - Start of the time range to query
+         * @param endTime - End of the time range to query
+         * @param options - Optional filters (packageId, processKey, version)
+         * @returns Promise resolving to an array of {@link ProcessGetTopFaultedCountResponse}
+         * @example
+         * ```typescript
+         * import { MaestroProcesses } from '@uipath/uipath-typescript/maestro-processes';
+         *
+         * const maestroProcesses = new MaestroProcesses(sdk);
+         *
+         * // Get top processes by faulted count for the last 7 days
+         * const topFailing = await maestroProcesses.getTopFaultedCount(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date()
+         * );
+         *
+         * for (const process of topFailing) {
+         *   console.log(`${process.packageId}: ${process.faultedCount} failures`);
+         * }
+         * ```
+         *
+         * @example
+         * ```typescript
+         * // Get top processes by faulted count for a specific package
+         * const filtered = await maestroProcesses.getTopFaultedCount(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date(),
+         *   { packageId: '<packageId>' }
+         * );
+         * ```
+         */
+        async getTopFaultedCount(startTime, endTime, options) {
+            const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.TOP_PROCESSES_WITH_FAILURE, buildInsightsTopBody(startTime, endTime, false, options));
+            return (data ?? []).map(item => ({
+                packageId: item.packageId,
+                processKey: item.processKey,
+                faultedCount: item.runCount,
+                name: item.packageId,
+            }));
+        }
+        /**
+         * Get the top 5 processes ranked by total duration within a time range.
+         *
+         * Returns an array of up to 5 processes sorted by their total execution time,
+         * useful for identifying the longest-running processes in a given period.
+         *
+         * @param startTime - Start of the time range to query
+         * @param endTime - End of the time range to query
+         * @param options - Optional filters (packageId, processKey, version)
+         * @returns Promise resolving to an array of {@link ProcessGetTopDurationResponse}
+         * @example
+         * ```typescript
+         * import { MaestroProcesses } from '@uipath/uipath-typescript/maestro-processes';
+         *
+         * const maestroProcesses = new MaestroProcesses(sdk);
+         *
+         * // Get top processes by duration for the last 7 days
+         * const topProcesses = await maestroProcesses.getTopExecutionDuration(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date()
+         * );
+         *
+         * for (const process of topProcesses) {
+         *   console.log(`${process.packageId}: ${process.duration}ms total`);
+         * }
+         * ```
+         *
+         * @example
+         * ```typescript
+         * // Get top processes by duration for a specific package
+         * const filtered = await maestroProcesses.getTopExecutionDuration(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date(),
+         *   { packageId: '<packageId>' }
+         * );
+         * ```
+         */
+        async getTopExecutionDuration(startTime, endTime, options) {
+            const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.TOP_PROCESSES_BY_DURATION, buildInsightsTopBody(startTime, endTime, false, options));
+            return (data ?? []).map(process => ({ ...process, name: process.packageId }));
+        }
+    }
+    __decorate([
+        track('MaestroProcesses.GetAll')
+    ], MaestroProcessesService.prototype, "getAll", null);
+    __decorate([
+        track('MaestroProcesses.GetIncidents')
+    ], MaestroProcessesService.prototype, "getIncidents", null);
+    __decorate([
+        track('MaestroProcesses.GetTopRunCount')
+    ], MaestroProcessesService.prototype, "getTopRunCount", null);
+    __decorate([
+        track('MaestroProcesses.GetInstanceStatusTimeline')
+    ], MaestroProcessesService.prototype, "getInstanceStatusTimeline", null);
+    __decorate([
+        track('MaestroProcesses.GetTopFaultedCount')
+    ], MaestroProcessesService.prototype, "getTopFaultedCount", null);
+    __decorate([
+        track('MaestroProcesses.GetTopExecutionDuration')
+    ], MaestroProcessesService.prototype, "getTopExecutionDuration", null);
+
+    /**
+     * Service class for Maestro Process Incidents
+     */
+    class ProcessIncidentsService extends BaseService {
+        /**
+         * Get all process incidents across all folders
+         *
+         * @returns Promise resolving to array of process incident
+         * {@link ProcessIncidentGetAllResponse}
+         * @example
+         * ```typescript
+         * import { ProcessIncidents } from '@uipath/uipath-typescript/maestro-processes';
+         *
+         * const processIncidents = new ProcessIncidents(sdk);
+         * const incidents = await processIncidents.getAll();
+         *
+         * // Access process incident information
+         * for (const incident of incidents) {
+         *   console.log(`Process: ${incident.processKey}`);
+         *   console.log(`Error: ${incident.errorMessage}`);
+         *   console.log(`Count: ${incident.count}`);
+         *   console.log(`First occurrence: ${incident.firstOccuranceTime}`);
+         * }
+         * ```
+         */
+        async getAll() {
+            const rawResponse = await this.get(MAESTRO_ENDPOINTS.INCIDENTS.GET_ALL);
+            // Transform field names  
+            const data = rawResponse.data || [];
+            return data.map(incident => transformData(incident, ProcessIncidentSummaryMap));
+        }
+    }
+    __decorate([
+        track('ProcessIncidents.getAll')
+    ], ProcessIncidentsService.prototype, "getAll", null);
+
+    /**
+     * Internal types for Maestro Cases
+     * These types are used internally by the cases service
+     */
+    /**
+     * Process type enum for filtering
+     */
+    var ProcessType;
+    (function (ProcessType) {
         ProcessType["CaseManagement"] = "CaseManagement";
     })(ProcessType || (ProcessType = {}));
 
@@ -13942,6 +14531,177 @@
                 name: this.extractCaseName(caseItem.packageId)
             }));
         }
+        /**
+         * Get the top 5 case processes ranked by run count within a time range.
+         *
+         * Returns an array of up to 5 case processes sorted by how many times they were executed,
+         * useful for identifying the most active case processes in a given period.
+         *
+         * @param startTime - Start of the time range to query
+         * @param endTime - End of the time range to query
+         * @param options - Optional filters (packageId, processKey, version)
+         * @returns Promise resolving to an array of {@link CaseGetTopRunCountResponse}
+         * @example
+         * ```typescript
+         * import { Cases } from '@uipath/uipath-typescript/cases';
+         *
+         * const cases = new Cases(sdk);
+         *
+         * // Get top case processes by run count for the last 7 days
+         * const topProcesses = await cases.getTopRunCount(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date()
+         * );
+         *
+         * for (const process of topProcesses) {
+         *   console.log(`${process.packageId}: ${process.runCount} runs`);
+         * }
+         * ```
+         *
+         * @example
+         * ```typescript
+         * // Get top case processes by run count for a specific package
+         * const filtered = await cases.getTopRunCount(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date(),
+         *   { packageId: '<packageId>' }
+         * );
+         * ```
+         */
+        async getTopRunCount(startTime, endTime, options) {
+            const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.TOP_PROCESSES_BY_RUN_COUNT, buildInsightsTopBody(startTime, endTime, true, options));
+            return (data ?? []).map(process => ({ ...process, name: this.extractCaseName(process.packageId) }));
+        }
+        /**
+         * Get all instances status counts aggregated by date for case management processes.
+         *
+         * Returns time-grouped counts of case instances grouped by status (Completed, Faulted, Cancelled),
+         * useful for rendering time-series charts. Use `groupBy` to control the time bucket size
+         * (hour, day, or week) — defaults to day if not provided.
+         *
+         * @param startTime - Start of the time range to query
+         * @param endTime - End of the time range to query
+         * @param options - Optional settings for time bucketing granularity
+         * @returns Promise resolving to an array of {@link InstanceStatusTimelineResponse}
+         *
+         * @example
+         * ```typescript
+         * // Get daily instance status for the last 7 days
+         * const now = new Date();
+         * const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+         * const statuses = await cases.getInstanceStatusTimeline(sevenDaysAgo, now);
+         *
+         * for (const entry of statuses) {
+         *   console.log(`${entry.startTime} — ${entry.status}: ${entry.count}`);
+         * }
+         * ```
+         *
+         * @example
+         * ```typescript
+         * import { TimeInterval } from '@uipath/uipath-typescript/cases';
+         *
+         * // Get weekly breakdown
+         * const statuses = await cases.getInstanceStatusTimeline(startTime, endTime, {
+         *   groupBy: TimeInterval.Week,
+         * });
+         * ```
+         *
+         * @example
+         * ```typescript
+         * // Get all-time data (from Unix epoch to now)
+         * const allTime = await cases.getInstanceStatusTimeline(new Date(0), new Date());
+         * ```
+         */
+        async getInstanceStatusTimeline(startTime, endTime, options) {
+            return fetchInstanceStatusTimeline(this.post.bind(this), startTime, endTime, true, options);
+        }
+        /**
+         * Get the top 10 case processes ranked by failure count within a time range.
+         *
+         * Returns an array of up to 10 case processes sorted by how many instances faulted,
+         * useful for identifying the most error-prone case processes in a given period.
+         *
+         * @param startTime - Start of the time range to query
+         * @param endTime - End of the time range to query
+         * @param options - Optional filters (packageId, processKey, version)
+         * @returns Promise resolving to an array of {@link CaseGetTopFaultedCountResponse}
+         * @example
+         * ```typescript
+         * import { Cases } from '@uipath/uipath-typescript/cases';
+         *
+         * const cases = new Cases(sdk);
+         *
+         * // Get top case processes by faulted count for the last 7 days
+         * const topFailing = await cases.getTopFaultedCount(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date()
+         * );
+         *
+         * for (const process of topFailing) {
+         *   console.log(`${process.packageId}: ${process.faultedCount} failures`);
+         * }
+         * ```
+         *
+         * @example
+         * ```typescript
+         * // Get top case processes by faulted count for a specific package
+         * const filtered = await cases.getTopFaultedCount(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date(),
+         *   { packageId: '<packageId>' }
+         * );
+         * ```
+         */
+        async getTopFaultedCount(startTime, endTime, options) {
+            const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.TOP_PROCESSES_WITH_FAILURE, buildInsightsTopBody(startTime, endTime, true, options));
+            return (data ?? []).map(item => ({
+                packageId: item.packageId,
+                processKey: item.processKey,
+                faultedCount: item.runCount,
+                name: this.extractCaseName(item.packageId),
+            }));
+        }
+        /**
+         * Get the top 5 case processes ranked by total duration within a time range.
+         *
+         * Returns an array of up to 5 case processes sorted by their total execution time,
+         * useful for identifying the longest-running case processes in a given period.
+         *
+         * @param startTime - Start of the time range to query
+         * @param endTime - End of the time range to query
+         * @param options - Optional filters (packageId, processKey, version)
+         * @returns Promise resolving to an array of {@link CaseGetTopDurationResponse}
+         * @example
+         * ```typescript
+         * import { Cases } from '@uipath/uipath-typescript/cases';
+         *
+         * const cases = new Cases(sdk);
+         *
+         * // Get top case processes by duration for the last 7 days
+         * const topProcesses = await cases.getTopExecutionDuration(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date()
+         * );
+         *
+         * for (const process of topProcesses) {
+         *   console.log(`${process.packageId}: ${process.duration}ms total`);
+         * }
+         * ```
+         *
+         * @example
+         * ```typescript
+         * // Get top case processes by duration for a specific package
+         * const filtered = await cases.getTopExecutionDuration(
+         *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+         *   new Date(),
+         *   { packageId: '<packageId>' }
+         * );
+         * ```
+         */
+        async getTopExecutionDuration(startTime, endTime, options) {
+            const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.TOP_PROCESSES_BY_DURATION, buildInsightsTopBody(startTime, endTime, true, options));
+            return (data ?? []).map(process => ({ ...process, name: this.extractCaseName(process.packageId) }));
+        }
         /**
          * Extract a readable case name from the packageId
          * @param packageId - The full package identifier
@@ -13964,6 +14724,18 @@
     __decorate([
         track('Cases.GetAll')
     ], CasesService.prototype, "getAll", null);
+    __decorate([
+        track('Cases.GetTopRunCount')
+    ], CasesService.prototype, "getTopRunCount", null);
+    __decorate([
+        track('Cases.GetInstanceStatusTimeline')
+    ], CasesService.prototype, "getInstanceStatusTimeline", null);
+    __decorate([
+        track('Cases.GetTopFaultedCount')
+    ], CasesService.prototype, "getTopFaultedCount", null);
+    __decorate([
+        track('Cases.GetTopExecutionDuration')
+    ], CasesService.prototype, "getTopExecutionDuration", null);
 
     /**
      * Maps fields for Case Instance entities to ensure consistent naming
@@ -15079,6 +15851,40 @@
                 }
             }, apiOptions);
         }
+        /**
+         * Get stages SLA summary for case instances across folders.
+         *
+         * Returns stage-level SLA status and escalation information for each case instance, aggregated from Insights Real-Time Monitoring.
+         *
+         * @param options - Optional filtering options
+         * @returns Promise resolving to an array of {@link CaseInstanceStageSLAResponse}
+         * @example
+         * ```typescript
+         * // Get stages SLA summary for all case instances
+         * const stagesSla = await caseInstances.getStagesSlaSummary();
+         * for (const item of stagesSla) {
+         *   console.log(`Instance: ${item.caseInstanceId}`);
+         *   for (const stage of item.stages) {
+         *     console.log(`  Stage: ${stage.name} - SLA Status: ${stage.slaStatus}, Due: ${stage.slaDueTime}`);
+         *   }
+         * }
+         *
+         * // Filter by case instance ID
+         * const filtered = await caseInstances.getStagesSlaSummary({
+         *   caseInstanceId: '<caseInstanceId>'
+         * });
+         *
+         * // Using bound method on a case instance
+         * const instance = await caseInstances.getById('<instanceId>', '<folderKey>');
+         * const stagesSla = await instance.getStagesSlaSummary();
+         * ```
+         */
+        async getStagesSlaSummary(options) {
+            const response = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.STAGES_SUMMARY, {
+                caseInstanceId: options?.caseInstanceId,
+            });
+            return response.data ?? [];
+        }
     }
     __decorate([
         track('CaseInstances.GetAll')
@@ -15110,6 +15916,9 @@
     __decorate([
         track('CaseInstances.GetSlaSummary')
     ], CaseInstancesService.prototype, "getSlaSummary", null);
+    __decorate([
+        track('CaseInstances.GetStagesSlaSummary')
+    ], CaseInstancesService.prototype, "getStagesSlaSummary", null);
 
     /**
      * Validates the `name` argument passed to a `getByName(name, ...)` method.
@@ -15517,6 +16326,32 @@
             // Transform response from PascalCase to camelCase
             return pascalToCamelCaseKeys(response.data);
         }
+        /**
+         * Retrieves a single orchestrator storage bucket by name.
+         *
+         * @param name - Bucket name to search for
+         * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional query parameters (`expand`, `select`)
+         * @returns Promise resolving to a single bucket
+         * {@link BucketGetResponse}
+         * @example
+         * ```typescript
+         * import { Buckets } from '@uipath/uipath-typescript/buckets';
+         *
+         * const buckets = new Buckets(sdk);
+         *
+         * // By folder ID
+         * await buckets.getByName('MyBucket', { folderId: <folderId> });
+         *
+         * // By folder key (GUID)
+         * await buckets.getByName('MyBucket', { folderKey: '<folderKey>' });
+         *
+         * // By folder path
+         * await buckets.getByName('MyBucket', { folderPath: '<folderPath>' });
+         * ```
+         */
+        async getByName(name, options = {}) {
+            return this.getByNameLookup('Bucket', BUCKET_ENDPOINTS.GET_BY_FOLDER, name, options, (raw) => pascalToCamelCaseKeys(raw));
+        }
         /**
          * Gets all buckets across folders with optional filtering and folder scoping
          *
@@ -15788,6 +16623,120 @@
             }
             return transformedData;
         }
+        /**
+         * Lists all files in a bucket.
+         *
+         * Returns a flat, recursive listing of all files in the bucket. Supports regex filtering
+         * and filter / orderby / select / expand. {@link BucketFile} entries include
+         * `isDirectory` so callers can distinguish folders from files.
+         *
+         * 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
+         * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional parameters for regex filtering, query options, and pagination
+         * @returns Promise resolving to either an array of files NonPaginatedResponse<BucketFile> or a PaginatedResponse<BucketFile> when pagination options are used.
+         *
+         * @example
+         * ```typescript
+         * import { Buckets } from '@uipath/uipath-typescript/buckets';
+         *
+         * const buckets = new Buckets(sdk);
+         *
+         * // List all files in the bucket
+         * const files = await buckets.getFiles(<bucketId>, { folderId: <folderId> });
+         *
+         * // Filter by regex pattern
+         * const pdfs = await buckets.getFiles(<bucketId>, {
+         *   folderId: <folderId>,
+         *   fileNameRegex: '.*\\.pdf$'
+         * });
+         *
+         * // First page with pagination
+         * const page1 = await buckets.getFiles(<bucketId>, { folderId: <folderId>, pageSize: 10 });
+         *
+         * // Navigate using cursor
+         * if (page1.hasNextPage) {
+         *   const page2 = await buckets.getFiles(<bucketId>, { folderId: <folderId>, cursor: page1.nextCursor });
+         * }
+         *
+         * // Jump to specific page
+         * const page5 = await buckets.getFiles(<bucketId>, {
+         *   folderId: <folderId>,
+         *   jumpToPage: 5,
+         *   pageSize: 10
+         * });
+         * ```
+         */
+        async getFiles(bucketId, options) {
+            if (!bucketId) {
+                throw new ValidationError({ message: 'bucketId is required for getFiles' });
+            }
+            const { folderId, folderKey, folderPath, ...restOptions } = options ?? {};
+            const headers = resolveFolderHeaders({
+                folderId,
+                folderKey,
+                folderPath,
+                resourceType: 'Buckets.getFiles',
+                fallbackFolderKey: this.config.folderKey,
+            });
+            const transformBucketFile = (file) => transformData(pascalToCamelCaseKeys(file), BucketMap);
+            return PaginationHelpers.getAll({
+                serviceAccess: this.createPaginationServiceAccess(),
+                getEndpoint: () => BUCKET_ENDPOINTS.GET_FILES(bucketId),
+                transformFn: transformBucketFile,
+                pagination: {
+                    paginationType: PaginationType.OFFSET,
+                    itemsField: ODATA_PAGINATION.ITEMS_FIELD,
+                    totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
+                    paginationParams: {
+                        pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+                        offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
+                        countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM,
+                    },
+                },
+                excludeFromPrefix: ['directory', 'recursive', 'fileNameRegex'],
+                headers,
+            }, { ...restOptions, directory: '/', recursive: true });
+        }
+        /**
+         * Deletes a file from a bucket
+         *
+         * @param bucketId - The ID of the bucket
+         * @param path - The full path to the file to delete
+         * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`)
+         * @returns Promise resolving when the file is deleted
+         *
+         * @example
+         * ```typescript
+         * import { Buckets } from '@uipath/uipath-typescript/buckets';
+         *
+         * const buckets = new Buckets(sdk);
+         *
+         * // Delete a file from a bucket
+         * await buckets.deleteFile(<bucketId>, '/folder/file.pdf', { folderId: <folderId> });
+         * ```
+         */
+        async deleteFile(bucketId, path, options) {
+            if (!bucketId) {
+                throw new ValidationError({ message: 'bucketId is required for deleteFile' });
+            }
+            if (!path) {
+                throw new ValidationError({ message: 'path is required for deleteFile' });
+            }
+            const headers = resolveFolderHeaders({
+                folderId: options?.folderId,
+                folderKey: options?.folderKey,
+                folderPath: options?.folderPath,
+                resourceType: 'Buckets.deleteFile',
+                fallbackFolderKey: this.config.folderKey,
+            });
+            await this.delete(BUCKET_ENDPOINTS.DELETE_FILE(bucketId), {
+                params: { path },
+                headers,
+            });
+        }
         /**
          * Gets a direct upload URL for a file in the bucket
          *
@@ -15806,6 +16755,9 @@
     __decorate([
         track('Buckets.GetById')
     ], BucketService.prototype, "getById", null);
+    __decorate([
+        track('Buckets.GetByName')
+    ], BucketService.prototype, "getByName", null);
     __decorate([
         track('Buckets.GetAll')
     ], BucketService.prototype, "getAll", null);
@@ -15818,6 +16770,12 @@
     __decorate([
         track('Buckets.GetReadUri')
     ], BucketService.prototype, "getReadUri", null);
+    __decorate([
+        track('Buckets.GetFiles')
+    ], BucketService.prototype, "getFiles", null);
+    __decorate([
+        track('Buckets.DeleteFile')
+    ], BucketService.prototype, "deleteFile", null);
 
     exports.BucketOptions = void 0;
     (function (BucketOptions) {
@@ -16615,33 +17573,32 @@
                 }
             }, options);
         }
-        /**
-         * 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
-         * import { Processes } from '@uipath/uipath-typescript/processes';
-         *
-         * const processes = new Processes(sdk);
-         *
-         * // Start a process by process key
-         * const jobs = await processes.start({
-         *   processKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
-         * }, 123); // folderId is required
-         *
-         * // Start a process by name with specific robots
-         * const jobs = await processes.start({
-         *   processName: "MyProcess"
-         * }, 123); // folderId is required
-         * ```
-         */
-        async start(request, folderId, options = {}) {
-            const headers = createHeaders({ [FOLDER_ID]: folderId });
+        async start(request, optionsOrFolderId, legacyOptions) {
+            // Normalize the two overload forms into a single internal shape.
+            let folderId;
+            let folderKey;
+            let folderPath;
+            let queryOptions;
+            if (typeof optionsOrFolderId === 'number') {
+                // Deprecated positional form: start(request, folderId, options?)
+                folderId = optionsOrFolderId;
+                queryOptions = legacyOptions ?? {};
+            }
+            else {
+                // Preferred form: start(request, options?)
+                const { folderId: fid, folderKey: fkey, folderPath: fpath, ...rest } = optionsOrFolderId ?? {};
+                folderId = fid;
+                folderKey = fkey;
+                folderPath = fpath;
+                queryOptions = rest;
+            }
+            const headers = resolveFolderHeaders({
+                folderId,
+                folderKey,
+                folderPath,
+                resourceType: 'processes.start',
+                fallbackFolderKey: this.config.folderKey,
+            });
             // 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
@@ -16649,8 +17606,8 @@
                 startInfo: apiRequest
             };
             // Prefix all query parameter keys with '$' for OData
-            const keysToPrefix = Object.keys(options);
-            const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+            const keysToPrefix = Object.keys(queryOptions);
+            const apiOptions = addPrefixToKeys(queryOptions, ODATA_PREFIX, keysToPrefix);
             const response = await this.post(PROCESS_ENDPOINTS.START_PROCESS, requestBody, {
                 params: apiOptions,
                 headers
@@ -16983,6 +17940,17 @@
         lastActivityAt: 'lastActivityTime',
         agentReleaseId: 'agentId'
     };
+    /**
+     * Maps API filter param names (left) to SDK-facing names (right) for the conversation list endpoint.
+     * Used by `getAll` to translate SDK filters to the field names the backend expects. Kept separate
+     * from `ConversationMap` because `label`/`search` would otherwise collide with the `label` field
+     * on create/update payloads.
+     */
+    const ConversationGetAllFilterMap = {
+        agentReleaseKey: 'agentKey',
+        agentReleaseId: 'agentId',
+        search: 'label'
+    };
     /**
      * Maps fields for Exchange entity to ensure consistent SDK naming
      */
@@ -17342,8 +18310,8 @@
     // Auto-generated from the OpenAPI spec — do not edit manually.
     var ModelKind;
     (function (ModelKind) {
-        ModelKind["Classifier"] = "Classifier";
         ModelKind["Extractor"] = "Extractor";
+        ModelKind["Classifier"] = "Classifier";
     })(ModelKind || (ModelKind = {}));
     var ModelType;
     (function (ModelType) {
@@ -17352,6 +18320,14 @@
         ModelType["Predefined"] = "Predefined";
     })(ModelType || (ModelType = {}));
 
+    // Auto-generated from the OpenAPI spec — do not edit manually.
+    var ErrorSeverity;
+    (function (ErrorSeverity) {
+        ErrorSeverity["Info"] = "Info";
+        ErrorSeverity["Warning"] = "Warning";
+        ErrorSeverity["Error"] = "Error";
+    })(ErrorSeverity || (ErrorSeverity = {}));
+
     // Auto-generated from the OpenAPI spec — do not edit manually.
     var ClassifierDocumentTypeType;
     (function (ClassifierDocumentTypeType) {
@@ -17376,6 +18352,13 @@
         GptFieldType["Number"] = "Number";
         GptFieldType["Text"] = "Text";
     })(GptFieldType || (GptFieldType = {}));
+    var JobStatus;
+    (function (JobStatus) {
+        JobStatus["Succeeded"] = "Succeeded";
+        JobStatus["Failed"] = "Failed";
+        JobStatus["Running"] = "Running";
+        JobStatus["NotStarted"] = "NotStarted";
+    })(JobStatus || (JobStatus = {}));
     var ValidationDisplayMode;
     (function (ValidationDisplayMode) {
         ValidationDisplayMode["Classic"] = "Classic";
@@ -17462,8 +18445,10 @@
         get DocumentActionPriority () { return DocumentActionPriority; },
         get DocumentActionStatus () { return DocumentActionStatus; },
         get DocumentActionType () { return DocumentActionType; },
+        get ErrorSeverity () { return ErrorSeverity; },
         get FieldType () { return FieldType; },
         get GptFieldType () { return GptFieldType; },
+        get JobStatus () { return JobStatus; },
         get LogicalOperator () { return LogicalOperator; },
         get MarkupType () { return MarkupType; },
         get ModelKind () { return ModelKind; },
@@ -17557,17 +18542,10 @@
         return getMetaTagContent(exports.UiPathMetaTags.APP_BASE) || '/';
     }
 
-    exports.APP_NAME = APP_NAME;
     exports.AgentMap = AgentMap;
     exports.AuthenticationError = AuthenticationError;
     exports.AuthorizationError = AuthorizationError;
-    exports.CLOUD_CLIENT_ID = CLOUD_CLIENT_ID;
-    exports.CLOUD_ORGANIZATION_NAME = CLOUD_ORGANIZATION_NAME;
-    exports.CLOUD_REDIRECT_URI = CLOUD_REDIRECT_URI;
-    exports.CLOUD_ROLE_NAME = CLOUD_ROLE_NAME;
-    exports.CLOUD_TENANT_NAME = CLOUD_TENANT_NAME;
-    exports.CLOUD_URL = CLOUD_URL;
-    exports.CONNECTION_STRING = CONNECTION_STRING;
+    exports.ConversationGetAllFilterMap = ConversationGetAllFilterMap;
     exports.ConversationMap = ConversationMap;
     exports.DEFAULT_ITEMS_FIELD = DEFAULT_ITEMS_FIELD;
     exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
@@ -17581,17 +18559,10 @@
     exports.NetworkError = NetworkError;
     exports.NotFoundError = NotFoundError;
     exports.RateLimitError = RateLimitError;
-    exports.SDK_LOGGER_NAME = SDK_LOGGER_NAME;
-    exports.SDK_RUN_EVENT = SDK_RUN_EVENT;
-    exports.SDK_SERVICE_NAME = SDK_SERVICE_NAME;
-    exports.SDK_VERSION = SDK_VERSION;
-    exports.SERVICE = SERVICE;
     exports.ServerError = ServerError;
-    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;