@uipath/uipath-typescript 1.3.8 → 1.3.9

package/dist/index.umd.js

@@ -4592,6 +4592,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`,
         },
     };
 
@@ -9221,54 +9231,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 +9290,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 +9321,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 +9333,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 +9439,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.9';
+    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
      *
@@ -13085,6 +13184,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 +13607,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 +13627,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,6 +14036,177 @@
             // Fetch BPMN XML and add element name/type to each incident
             return BpmnHelpers.enrichIncidentsWithBpmnData(rawResponse.data || [], folderKey, this.processInstancesService);
         }
+        /**
+         * Get the top 5 processes ranked by run count within a time range.
+         *
+         * 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 { MaestroProcesses } from '@uipath/uipath-typescript/maestro-processes';
+         *
+         * const maestroProcesses = new MaestroProcesses(sdk);
+         *
+         * // 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 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 }));
+        }
+        /**
+         * 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')
@@ -13858,6 +14214,18 @@
     __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
@@ -13942,6 +14310,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 +14503,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 +15630,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 +15695,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 +16105,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
          *
@@ -15806,6 +16420,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);
@@ -16983,6 +17600,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 +17970,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 +17980,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 +18012,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 +18105,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 +18202,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 +18219,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;