@uipath/uipath-typescript 1.3.7 → 1.3.9

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var sdkLogs = require('@opentelemetry/sdk-logs');
+var coreTelemetry = require('@uipath/core-telemetry');
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -4480,6 +4480,7 @@ const ORCHESTRATOR_BASE = 'orchestrator_';
 const PIMS_BASE = 'pims_';
 const DATAFABRIC_BASE = 'datafabric_';
 const IDENTITY_BASE = 'identity_';
+const INSIGHTS_RTM_BASE = 'insightsrtm_';
 
 /**
  * Orchestrator Service Endpoints
@@ -4586,6 +4587,20 @@ const MAESTRO_ENDPOINTS = {
         GET_ELEMENT_EXECUTIONS: (instanceId) => `${PIMS_BASE}/api/v1/element-executions/case-instances/${instanceId}`,
         REOPEN: (instanceId) => `${PIMS_BASE}/api/v1/cases/${instanceId}/reopen`,
     },
+    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`,
+    },
 };
 
 /**
@@ -5459,284 +5474,49 @@ function normalizeBaseUrl(url) {
 }
 
 /**
- * SDK Telemetry constants
- */
-// 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.7";
-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 = "";
-
-/**
- * Log exporter that sends ALL logs as Application Insights custom events
- */
-class ApplicationInsightsEventExporter {
-    constructor(connectionString) {
-        this.connectionString = connectionString;
-    }
-    export(logs, resultCallback) {
-        try {
-            logs.forEach(logRecord => {
-                this.sendAsCustomEvent(logRecord);
-            });
-            resultCallback({ code: 0 });
-        }
-        catch (error) {
-            console.debug('Failed to export logs to Application Insights:', error);
-            resultCallback({ code: 2, error });
-        }
-    }
-    shutdown() {
-        return Promise.resolve();
-    }
-    sendAsCustomEvent(logRecord) {
-        // Get event name from body or attributes
-        const eventName = logRecord.body || SDK_RUN_EVENT;
-        const payload = {
-            name: 'Microsoft.ApplicationInsights.Event',
-            time: new Date().toISOString(),
-            iKey: this.extractInstrumentationKey(),
-            data: {
-                baseType: 'EventData',
-                baseData: {
-                    ver: 2,
-                    name: eventName,
-                    properties: this.convertAttributesToProperties(logRecord.attributes || {})
-                }
-            },
-            tags: {
-                'ai.cloud.role': CLOUD_ROLE_NAME,
-                'ai.cloud.roleInstance': SDK_VERSION
-            }
-        };
-        this.sendToApplicationInsights(payload);
-    }
-    extractInstrumentationKey() {
-        const match = this.connectionString.match(/InstrumentationKey=([^;]+)/);
-        return match ? match[1] : '';
-    }
-    convertAttributesToProperties(attributes) {
-        const properties = {};
-        Object.entries(attributes || {}).forEach(([key, value]) => {
-            properties[key] = String(value);
-        });
-        return properties;
-    }
-    async sendToApplicationInsights(payload) {
-        try {
-            const ingestionEndpoint = this.extractIngestionEndpoint();
-            if (!ingestionEndpoint) {
-                console.debug('No ingestion endpoint found in connection string');
-                return;
-            }
-            const url = `${ingestionEndpoint}/v2/track`;
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(payload)
-            });
-            if (!response.ok) {
-                console.debug(`Failed to send event telemetry: ${response.status} ${response.statusText}`);
-            }
-        }
-        catch (error) {
-            console.debug('Error sending event telemetry to Application Insights:', error);
-        }
-    }
-    extractIngestionEndpoint() {
-        const match = this.connectionString.match(/IngestionEndpoint=([^;]+)/);
-        return match ? match[1] : '';
-    }
-}
-/**
- * Singleton telemetry client
- */
-class TelemetryClient {
-    constructor() {
-        this.isInitialized = false;
-    }
-    static getInstance() {
-        if (!TelemetryClient.instance) {
-            TelemetryClient.instance = new TelemetryClient();
-        }
-        return TelemetryClient.instance;
-    }
-    /**
-     * Initialize telemetry
-     */
-    initialize(config) {
-        if (this.isInitialized) {
-            return;
-        }
-        this.isInitialized = true;
-        if (config) {
-            this.telemetryContext = config;
-        }
-        try {
-            const connectionString = this.getConnectionString();
-            if (!connectionString) {
-                return;
-            }
-            this.setupTelemetryProvider(connectionString);
-        }
-        catch (error) {
-            // Silent failure - telemetry errors shouldn't break functionality
-            console.debug('Failed to initialize OpenTelemetry:', error);
-        }
-    }
-    getConnectionString() {
-        const connectionString = CONNECTION_STRING;
-        return connectionString;
-    }
-    setupTelemetryProvider(connectionString) {
-        const exporter = new ApplicationInsightsEventExporter(connectionString);
-        const processor = new sdkLogs.BatchLogRecordProcessor(exporter);
-        this.logProvider = new sdkLogs.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 attributes = this.getEnrichedAttributes(extraAttributes, eventName);
-            // Emit as log 
-            this.logger.emit({
-                body: finalDisplayName,
-                attributes: attributes,
-                timestamp: Date.now(),
-            });
-        }
-        catch (error) {
-            // Silent failure
-            console.debug('Failed to track telemetry event:', error);
-        }
-    }
-    /**
-     * Get enriched attributes for telemetry events
-     */
-    getEnrichedAttributes(extraAttributes, eventName) {
-        const attributes = {
-            [APP_NAME]: SDK_SERVICE_NAME,
-            [VERSION]: SDK_VERSION,
-            [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,
-            ...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;
-        const tenantId = this.telemetryContext?.tenantName;
-        if (!baseUrl || !orgId || !tenantId) {
-            return UNKNOWN$1;
-        }
-        return `${baseUrl}/${orgId}/${tenantId}`;
-    }
-}
-// Export singleton instance
-const telemetryClient = TelemetryClient.getInstance();
-
-/**
- * SDK Track decorator and function for telemetry
- */
-/**
- * Common tracking logic shared between method and function decorators
- */
-function createTrackedFunction(originalFunction, nameOrOptions, fallbackName, opts) {
-    return function (...args) {
-        // Determine if we should track this call
-        let shouldTrack = true;
-        if (opts.condition !== undefined) {
-            if (typeof opts.condition === 'function') {
-                shouldTrack = opts.condition.apply(this, args);
-            }
-            else {
-                shouldTrack = 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
-        return originalFunction.apply(this, args);
-    };
-}
-/**
- * Track decorator that can be used to automatically track function calls
- *
- * Usage:
- * @track("Service.Method")
- * function myFunction() { ... }
+ * SDK Telemetry constants.
  *
- * @track("Queue.GetAll")
- * async getAll() { ... }
+ * 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
  *
- * @track("Tasks.Create")
- * async create() { ... }
- *
- * @track("Assets.Update", { condition: false })
- * function myFunction() { ... }
- *
- * @track("Processes.Start", { attributes: { customProp: "value" } })
- * function myFunction() { ... }
- */
-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 decorator
-        return (originalFunction) => createTrackedFunction(originalFunction, nameOrOptions, originalFunction.name || 'unknown_function', opts);
-    };
-}
-/**
- * Direct tracking function
- */
-function trackEvent(eventName, name, attributes) {
-    telemetryClient.track(eventName, name, attributes);
-}
+ * 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 = coreTelemetry.getOrCreateClient(CLOUD_ROLE_NAME);
+const track = coreTelemetry.createTrack(sdkClient);
+const trackEvent = coreTelemetry.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
@@ -6470,6 +6250,27 @@ var PaginationType;
 /**
  * Collection of utility functions for working with objects
  */
+/**
+ * Resolves a field value from an object, supporting both direct keys (e.g., '@odata.count')
+ * and dot-separated nested paths (e.g., 'pagination.totalCount').
+ * Direct key match takes priority over nested traversal.
+ */
+function resolveNestedField(data, fieldPath) {
+    if (!data) {
+        return undefined;
+    }
+    if (fieldPath in data) {
+        return data[fieldPath];
+    }
+    if (!fieldPath.includes('.')) {
+        return undefined;
+    }
+    let value = data;
+    for (const part of fieldPath.split('.')) {
+        value = value?.[part];
+    }
+    return value;
+}
 /**
  * Filters out undefined values from an object
  * @param obj The source object
@@ -6729,6 +6530,26 @@ const BUCKET_PAGINATION = {
     /** Field name for continuation token in bucket file metadata response */
     CONTINUATION_TOKEN_FIELD: 'continuationToken'
 };
+/**
+ * SLA Summary pagination constants for page-number-based pagination
+ */
+const SLA_SUMMARY_PAGINATION = {
+    /** Field name for items in SLA summary response */
+    ITEMS_FIELD: 'data',
+    /** Dot-notation path for total count in nested pagination object */
+    TOTAL_COUNT_FIELD: 'pagination.totalCount'
+};
+/**
+ * SLA Summary OFFSET pagination parameter names (page-number style, no skip conversion)
+ */
+const SLA_SUMMARY_OFFSET_PARAMS = {
+    /** Page size parameter name */
+    PAGE_SIZE_PARAM: 'PageSize',
+    /** Page number parameter name (sent directly, not converted to skip) */
+    OFFSET_PARAM: 'PageNumber',
+    /** No count param needed */
+    COUNT_PARAM: undefined
+};
 /**
  * Process Instance pagination constants for token-based pagination
  */
@@ -6779,6 +6600,14 @@ const PROCESS_INSTANCE_TOKEN_PARAMS = {
     TOKEN_PARAM: 'nextPage'
 };
 
+/**
+ * Converts a UTC timestamp string (e.g., "5/8/2026 11:20:17 AM") to ISO 8601 UTC format.
+ * Returns the original value if parsing fails.
+ */
+function toISOUtc(value) {
+    const date = new Date(value + ' UTC');
+    return isNaN(date.getTime()) ? value : date.toISOString();
+}
 /**
  * Transforms data by mapping fields according to the provided field mapping
  * @param data The source data to transform
@@ -7335,7 +7164,8 @@ class PaginationHelpers {
         // Extract and transform items from response
         // Handle both plain array responses and envelope responses ({ value: [...], totalRecordCount: N })
         const rawItems = Array.isArray(response.data) ? response.data : response.data?.[itemsField];
-        const totalCount = Array.isArray(response.data) ? undefined : response.data?.[totalCountField];
+        const rawTotalCount = Array.isArray(response.data) ? undefined : resolveNestedField(response.data, totalCountField);
+        const totalCount = typeof rawTotalCount === 'number' ? rawTotalCount : undefined;
         // Parse items - automatically handle JSON string responses
         const parsedItems = typeof rawItems === 'string' ? JSON.parse(rawItems) : (rawItems || []);
         const items = transformFn ? parsedItems.map(transformFn) : parsedItems;
@@ -7577,9 +7407,17 @@ class BaseService {
                 const pageSizeParam = paginationParams?.pageSizeParam || ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM;
                 const offsetParam = paginationParams?.offsetParam || ODATA_OFFSET_PARAMS.OFFSET_PARAM;
                 const countParam = paginationParams?.countParam || ODATA_OFFSET_PARAMS.COUNT_PARAM;
+                // When true (default), converts pageNumber to a skip/offset value (e.g., page 3 with pageSize 10 → skip 20).
+                // When false, passes pageNumber directly as the offset param — used by APIs that accept a page number instead of a record offset.
+                const convertToSkip = paginationParams?.convertToSkip ?? true;
                 requestParams[pageSizeParam] = limitedPageSize;
-                if (params.pageNumber && params.pageNumber > 1) {
-                    requestParams[offsetParam] = (params.pageNumber - 1) * limitedPageSize;
+                if (convertToSkip) {
+                    if (params.pageNumber && params.pageNumber > 1) {
+                        requestParams[offsetParam] = (params.pageNumber - 1) * limitedPageSize;
+                    }
+                }
+                else {
+                    requestParams[offsetParam] = params.pageNumber || 1;
                 }
                 {
                     requestParams[countParam] = true;
@@ -7610,7 +7448,8 @@ class BaseService {
         // Extract items and metadata
         // Handle both plain array responses and envelope responses ({ value: [...], totalRecordCount: N })
         const items = Array.isArray(response.data) ? response.data : (response.data[itemsField] || []);
-        const totalCount = Array.isArray(response.data) ? undefined : response.data[totalCountField];
+        const rawTotalCount = Array.isArray(response.data) ? undefined : resolveNestedField(response.data, totalCountField);
+        const totalCount = typeof rawTotalCount === 'number' ? rawTotalCount : undefined;
         const continuationToken = response.data[continuationTokenField];
         // Determine if there are more pages
         const hasMore = this.determineHasMorePages(paginationType, {
@@ -9264,6 +9103,53 @@ function createProcessWithMethods(processData, service) {
     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
  */
@@ -9497,6 +9383,41 @@ exports.DebugMode = void 0;
  * Case Instance Types
  * Types and interfaces for Maestro case instance management
  */
+/**
+ * SLA status for a case instance
+ */
+exports.SlaSummaryStatus = void 0;
+(function (SlaSummaryStatus) {
+    /** Case is within SLA deadline */
+    SlaSummaryStatus["ON_TRACK"] = "On Track";
+    /** Case is approaching SLA deadline based on at-risk percentage threshold */
+    SlaSummaryStatus["AT_RISK"] = "At Risk";
+    /** Case has exceeded SLA deadline */
+    SlaSummaryStatus["OVERDUE"] = "Overdue";
+    /** Case instance has completed */
+    SlaSummaryStatus["COMPLETED"] = "Completed";
+    /** SLA status cannot be determined (no SLA deadline defined) */
+    SlaSummaryStatus["UNKNOWN"] = "Unknown";
+})(exports.SlaSummaryStatus || (exports.SlaSummaryStatus = {}));
+/**
+ * Instance status values for case instances and process instances
+ */
+exports.InstanceStatus = void 0;
+(function (InstanceStatus) {
+    /** Instance status not yet populated by the backend */
+    InstanceStatus["UNKNOWN"] = "";
+    InstanceStatus["CANCELLED"] = "Cancelled";
+    InstanceStatus["CANCELING"] = "Canceling";
+    InstanceStatus["COMPLETED"] = "Completed";
+    InstanceStatus["FAULTED"] = "Faulted";
+    InstanceStatus["PAUSED"] = "Paused";
+    InstanceStatus["PAUSING"] = "Pausing";
+    InstanceStatus["PENDING"] = "Pending";
+    InstanceStatus["RESUMING"] = "Resuming";
+    InstanceStatus["RETRYING"] = "Retrying";
+    InstanceStatus["RUNNING"] = "Running";
+    InstanceStatus["UPGRADING"] = "Upgrading";
+})(exports.InstanceStatus || (exports.InstanceStatus = {}));
 /**
  * Case stage task type
  */
@@ -9531,6 +9452,8 @@ exports.EscalationTriggerType = void 0;
 (function (EscalationTriggerType) {
     EscalationTriggerType["SLA_BREACHED"] = "sla-breached";
     EscalationTriggerType["AT_RISK"] = "at-risk";
+    /** Default value when no escalation rule is defined */
+    EscalationTriggerType["NONE"] = "None";
 })(exports.EscalationTriggerType || (exports.EscalationTriggerType = {}));
 /**
  * SLA duration unit
@@ -9598,6 +9521,16 @@ function createCaseInstanceMethods(instanceData, service) {
             if (!instanceData.instanceId)
                 throw new Error('Case instance ID is undefined');
             return service.getActionTasks(instanceData.instanceId, options);
+        },
+        async getSlaSummary(options) {
+            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 });
         }
     };
 }
@@ -9613,6 +9546,40 @@ function createCaseInstanceWithMethods(instanceData, service) {
     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
  */
@@ -9988,6 +9955,177 @@ class MaestroProcessesService extends BaseService {
         // 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')
@@ -9995,6 +10133,18 @@ __decorate([
 __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
@@ -10079,6 +10229,177 @@ class CasesService extends BaseService {
             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
@@ -10101,6 +10422,18 @@ class CasesService extends BaseService {
 __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
@@ -11152,6 +11485,104 @@ class CaseInstancesService extends BaseService {
         };
         return await this.taskService.getAll(enhancedOptions);
     }
+    /**
+     * Get SLA summary for all case instances across folders.
+     *
+     * Returns SLA status, due times, escalation info, and instance metadata for each case instance.
+     * The default page size is 50, so only the top 50 items are returned when no pagination options are provided.
+     *
+     * @param options - Optional filtering and pagination options
+     * @returns Promise resolving to {@link SlaSummaryResponse}, paginated or non-paginated based on options
+     * @example
+     * ```typescript
+     * // Non-paginated (returns top 50 items by default)
+     * const summary = await caseInstances.getSlaSummary();
+     * console.log(`Found ${summary.totalCount} cases`);
+     *
+     * // Filter by case instance ID
+     * const filtered = await caseInstances.getSlaSummary({
+     *   caseInstanceId: '<caseInstanceId>'
+     * });
+     *
+     * // Filter by time range
+     * const timeFiltered = await caseInstances.getSlaSummary({
+     *   startTimeUtc: new Date('2026-01-01'),
+     *   endTimeUtc: new Date('2026-01-31')
+     * });
+     *
+     * // With pagination
+     * const page1 = await caseInstances.getSlaSummary({ pageSize: 25 });
+     * if (page1.hasNextPage) {
+     *   const page2 = await caseInstances.getSlaSummary({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page3 = await caseInstances.getSlaSummary({ jumpToPage: 3, pageSize: 25 });
+     * ```
+     */
+    async getSlaSummary(options) {
+        const apiOptions = options ? {
+            ...options,
+            startTimeUtc: options.startTimeUtc?.toISOString(),
+            endTimeUtc: options.endTimeUtc?.toISOString()
+        } : undefined;
+        return PaginationHelpers.getAll({
+            serviceAccess: this.createPaginationServiceAccess(),
+            getEndpoint: () => MAESTRO_ENDPOINTS.INSIGHTS.SLA_SUMMARY,
+            method: HTTP_METHODS.POST,
+            excludeFromPrefix: ['caseInstanceId', 'startTimeUtc', 'endTimeUtc'],
+            transformFn: (item) => ({
+                ...item,
+                slaDueTime: toISOUtc(item.slaDueTime),
+                lastModifiedTime: toISOUtc(item.lastModifiedTime)
+            }),
+            pagination: {
+                paginationType: PaginationType.OFFSET,
+                itemsField: SLA_SUMMARY_PAGINATION.ITEMS_FIELD,
+                totalCountField: SLA_SUMMARY_PAGINATION.TOTAL_COUNT_FIELD,
+                paginationParams: {
+                    pageSizeParam: SLA_SUMMARY_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+                    offsetParam: SLA_SUMMARY_OFFSET_PARAMS.OFFSET_PARAM,
+                    countParam: SLA_SUMMARY_OFFSET_PARAMS.COUNT_PARAM,
+                    convertToSkip: false
+                }
+            }
+        }, 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')
@@ -11180,6 +11611,12 @@ __decorate([
 __decorate([
     track('CaseInstances.GetActionTasks')
 ], CaseInstancesService.prototype, "getActionTasks", null);
+__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.
@@ -11587,6 +12024,32 @@ class BucketService extends FolderScopedService {
         // 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
      *
@@ -11876,6 +12339,9 @@ class BucketService extends FolderScopedService {
 __decorate([
     track('Buckets.GetById')
 ], BucketService.prototype, "getById", null);
+__decorate([
+    track('Buckets.GetByName')
+], BucketService.prototype, "getByName", null);
 __decorate([
     track('Buckets.GetAll')
 ], BucketService.prototype, "getAll", null);
@@ -13053,6 +13519,17 @@ const ConversationMap = {
     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
  */
@@ -13412,8 +13889,8 @@ var WordGroupType;
 // 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) {
@@ -13422,6 +13899,14 @@ var ModelType;
     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) {
@@ -13446,6 +13931,13 @@ var GptFieldType;
     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";
@@ -13532,8 +14024,10 @@ var index = /*#__PURE__*/Object.freeze({
     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; },
@@ -13627,17 +14121,10 @@ function getAppBase() {
     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;
@@ -13651,17 +14138,10 @@ exports.MessageMap = MessageMap;
 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;