@uipath/uipath-typescript 1.3.9 → 1.3.11

package/dist/buckets/index.d.ts

@@ -503,6 +503,45 @@ interface BlobItem {
      */
     lastModified: string | null;
 }
+/**
+ * Represents a file or directory entry in a bucket
+ */
+interface BucketFile {
+    /**
+     * Full path to the file or directory
+     */
+    path: string;
+    /**
+     * Content type of the file (empty for directories)
+     */
+    contentType: string;
+    /**
+     * Size of the file in bytes
+     */
+    size: number;
+    /**
+     * Whether the entry is a directory
+     */
+    isDirectory: boolean;
+    /**
+     * Identifier of the file, when available
+     */
+    id: string | null;
+}
+/**
+ * Options for listing files in a bucket directory
+ */
+type BucketGetFilesOptions = RequestOptions & PaginationOptions & FolderScopedOptions & {
+    /**
+     * Regex pattern to filter file names (e.g., '.*\\.pdf$')
+     */
+    fileNameRegex?: string;
+};
+/**
+ * Options for deleting a file from a bucket
+ */
+interface BucketDeleteFileOptions extends FolderScopedOptions {
+}
 /**
  * Options for uploading files to a bucket
  */
@@ -708,6 +747,64 @@ interface BucketServiceModel {
      * ```
      */
     uploadFile(options: BucketUploadFileOptions): Promise<BucketUploadResponse>;
+    /**
+     * Deletes a file from a bucket
+     *
+     * @param bucketId - The ID of the bucket
+     * @param path - The full path to the file to delete
+     * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`)
+     * @returns Promise resolving when the file is deleted
+     * @example
+     * ```typescript
+     * // Delete a file from a bucket
+     * await buckets.deleteFile(<bucketId>, '/folder/file.pdf', { folderId: <folderId> });
+     * ```
+     */
+    deleteFile(bucketId: number, path: string, options?: BucketDeleteFileOptions): Promise<void>;
+    /**
+     * Lists all files in a bucket.
+     *
+     * Returns a flat, recursive listing of all files in the bucket. Supports regex filtering
+     * and filter / orderby / select / expand. {@link BucketFile} entries include
+     * `isDirectory` so callers can distinguish folders from files.
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param bucketId - The ID of the bucket
+     * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional parameters for regex filtering, query options, and pagination
+     * {@link BucketGetFilesOptions}
+     * @returns Promise resolving to either an array of files NonPaginatedResponse<BucketFile> or a PaginatedResponse<BucketFile> when pagination options are used.
+     * {@link BucketFile}
+     * @example
+     * ```typescript
+     * // List all files in the bucket
+     * const files = await buckets.getFiles(<bucketId>, { folderId: <folderId> });
+     *
+     * // Filter by regex pattern
+     * const pdfs = await buckets.getFiles(<bucketId>, {
+     *   folderId: <folderId>,
+     *   fileNameRegex: '.*\\.pdf$'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await buckets.getFiles(<bucketId>, { folderId: <folderId>, pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await buckets.getFiles(<bucketId>, { folderId: <folderId>, cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await buckets.getFiles(<bucketId>, {
+     *   folderId: <folderId>,
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getFiles<T extends BucketGetFilesOptions = BucketGetFilesOptions>(bucketId: number, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<BucketFile> : NonPaginatedResponse<BucketFile>>;
 }
 
 declare class BucketService extends FolderScopedService implements BucketServiceModel {
@@ -904,6 +1001,72 @@ declare class BucketService extends FolderScopedService implements BucketService
      * @returns Promise resolving to blob file access information
      */
     private _getUri;
+    /**
+     * Lists all files in a bucket.
+     *
+     * Returns a flat, recursive listing of all files in the bucket. Supports regex filtering
+     * and filter / orderby / select / expand. {@link BucketFile} entries include
+     * `isDirectory` so callers can distinguish folders from files.
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param bucketId - The ID of the bucket
+     * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional parameters for regex filtering, query options, and pagination
+     * @returns Promise resolving to either an array of files NonPaginatedResponse<BucketFile> or a PaginatedResponse<BucketFile> when pagination options are used.
+     *
+     * @example
+     * ```typescript
+     * import { Buckets } from '@uipath/uipath-typescript/buckets';
+     *
+     * const buckets = new Buckets(sdk);
+     *
+     * // List all files in the bucket
+     * const files = await buckets.getFiles(<bucketId>, { folderId: <folderId> });
+     *
+     * // Filter by regex pattern
+     * const pdfs = await buckets.getFiles(<bucketId>, {
+     *   folderId: <folderId>,
+     *   fileNameRegex: '.*\\.pdf$'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await buckets.getFiles(<bucketId>, { folderId: <folderId>, pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await buckets.getFiles(<bucketId>, { folderId: <folderId>, cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await buckets.getFiles(<bucketId>, {
+     *   folderId: <folderId>,
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getFiles<T extends BucketGetFilesOptions = BucketGetFilesOptions>(bucketId: number, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<BucketFile> : NonPaginatedResponse<BucketFile>>;
+    /**
+     * Deletes a file from a bucket
+     *
+     * @param bucketId - The ID of the bucket
+     * @param path - The full path to the file to delete
+     * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`)
+     * @returns Promise resolving when the file is deleted
+     *
+     * @example
+     * ```typescript
+     * import { Buckets } from '@uipath/uipath-typescript/buckets';
+     *
+     * const buckets = new Buckets(sdk);
+     *
+     * // Delete a file from a bucket
+     * await buckets.deleteFile(<bucketId>, '/folder/file.pdf', { folderId: <folderId> });
+     * ```
+     */
+    deleteFile(bucketId: number, path: string, options?: BucketDeleteFileOptions): Promise<void>;
     /**
      * Gets a direct upload URL for a file in the bucket
      *
@@ -914,4 +1077,4 @@ declare class BucketService extends FolderScopedService implements BucketService
 }
 
 export { BucketOptions, BucketService, BucketService as Buckets };
-export type { BlobItem, BucketGetAllOptions, BucketGetByIdOptions, BucketGetByNameOptions, BucketGetFileMetaDataOptions, BucketGetFileMetaDataResponse, BucketGetFileMetaDataWithPaginationOptions, BucketGetReadUriOptions, BucketGetResponse, BucketGetUriOptions, BucketGetUriResponse, BucketServiceModel, BucketUploadFileOptions, BucketUploadResponse, ResponseDictionary };
+export type { BlobItem, BucketDeleteFileOptions, BucketFile, BucketGetAllOptions, BucketGetByIdOptions, BucketGetByNameOptions, BucketGetFileMetaDataOptions, BucketGetFileMetaDataResponse, BucketGetFileMetaDataWithPaginationOptions, BucketGetFilesOptions, BucketGetReadUriOptions, BucketGetResponse, BucketGetUriOptions, BucketGetUriResponse, BucketServiceModel, BucketUploadFileOptions, BucketUploadResponse, ResponseDictionary };

package/dist/buckets/index.mjs

@@ -611,14 +611,25 @@ class ApiClient {
             if (!text) {
                 return undefined;
             }
-            return JSON.parse(text);
+            try {
+                return JSON.parse(text);
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    throw new ServerError({
+                        message: `Server returned non-JSON response (${response.status} ${response.url}): ${error.message}`,
+                        statusCode: response.status,
+                    });
+                }
+                throw error;
+            }
         }
         catch (error) {
             // If it's already one of our errors, re-throw it
             if (error.type && error.type.includes('Error')) {
                 throw error;
             }
-            // Otherwise, it's likely a network error
+            // Otherwise, it's a genuine network/fetch failure
             throw ErrorFactory.createNetworkError(error);
         }
     }
@@ -1262,9 +1273,9 @@ class PaginationHelpers {
      * @returns Promise resolving to a paginated result
      */
     static async getAllPaginated(params) {
-        const { serviceAccess, getEndpoint, folderId, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        const { serviceAccess, getEndpoint, folderId, headers: providedHeaders, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
         const endpoint = getEndpoint(folderId);
-        const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+        const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
         const paginatedResponse = await serviceAccess.requestWithPagination(method, endpoint, paginationParams, {
             headers,
             params: additionalParams,
@@ -1292,13 +1303,13 @@ class PaginationHelpers {
      * @returns Promise resolving to an object with data and totalCount
      */
     static async getAllNonPaginated(params) {
-        const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, headers: providedHeaders, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
         // Set default field names
         const itemsField = options.itemsField || DEFAULT_ITEMS_FIELD;
         const totalCountField = options.totalCountField || DEFAULT_TOTAL_COUNT_FIELD;
         // Determine endpoint and headers based on folderId
         const endpoint = folderId ? getByFolderEndpoint : getAllEndpoint;
-        const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+        const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
         // Make the API call based on method
         let response;
         if (method === HTTP_METHODS.POST) {
@@ -1357,6 +1368,7 @@ class PaginationHelpers {
                 serviceAccess: config.serviceAccess,
                 getEndpoint: config.getEndpoint,
                 folderId,
+                headers: config.headers,
                 paginationParams: cursor ? { cursor, pageSize } : jumpToPage ? { jumpToPage, pageSize } : { pageSize },
                 additionalParams: prefixedOptions,
                 transformFn: config.transformFn,
@@ -1374,6 +1386,7 @@ class PaginationHelpers {
             getAllEndpoint: config.getEndpoint(),
             getByFolderEndpoint: byFolderEndpoint,
             folderId,
+            headers: config.headers,
             additionalParams: prefixedOptions,
             transformFn: config.transformFn,
             method: config.method,
@@ -1918,6 +1931,8 @@ const BUCKET_ENDPOINTS = {
     GET_FILE_META_DATA: (id) => `${ORCHESTRATOR_BASE}/api/Buckets/${id}/ListFiles`,
     GET_READ_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetReadUri`,
     GET_WRITE_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetWriteUri`,
+    DELETE_FILE: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.DeleteFile`,
+    GET_FILES: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetFiles`,
 };
 
 /**
@@ -2291,6 +2306,120 @@ class BucketService extends FolderScopedService {
         }
         return transformedData;
     }
+    /**
+     * Lists all files in a bucket.
+     *
+     * Returns a flat, recursive listing of all files in the bucket. Supports regex filtering
+     * and filter / orderby / select / expand. {@link BucketFile} entries include
+     * `isDirectory` so callers can distinguish folders from files.
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param bucketId - The ID of the bucket
+     * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional parameters for regex filtering, query options, and pagination
+     * @returns Promise resolving to either an array of files NonPaginatedResponse<BucketFile> or a PaginatedResponse<BucketFile> when pagination options are used.
+     *
+     * @example
+     * ```typescript
+     * import { Buckets } from '@uipath/uipath-typescript/buckets';
+     *
+     * const buckets = new Buckets(sdk);
+     *
+     * // List all files in the bucket
+     * const files = await buckets.getFiles(<bucketId>, { folderId: <folderId> });
+     *
+     * // Filter by regex pattern
+     * const pdfs = await buckets.getFiles(<bucketId>, {
+     *   folderId: <folderId>,
+     *   fileNameRegex: '.*\\.pdf$'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await buckets.getFiles(<bucketId>, { folderId: <folderId>, pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await buckets.getFiles(<bucketId>, { folderId: <folderId>, cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await buckets.getFiles(<bucketId>, {
+     *   folderId: <folderId>,
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    async getFiles(bucketId, options) {
+        if (!bucketId) {
+            throw new ValidationError({ message: 'bucketId is required for getFiles' });
+        }
+        const { folderId, folderKey, folderPath, ...restOptions } = options ?? {};
+        const headers = resolveFolderHeaders({
+            folderId,
+            folderKey,
+            folderPath,
+            resourceType: 'Buckets.getFiles',
+            fallbackFolderKey: this.config.folderKey,
+        });
+        const transformBucketFile = (file) => transformData(pascalToCamelCaseKeys(file), BucketMap);
+        return PaginationHelpers.getAll({
+            serviceAccess: this.createPaginationServiceAccess(),
+            getEndpoint: () => BUCKET_ENDPOINTS.GET_FILES(bucketId),
+            transformFn: transformBucketFile,
+            pagination: {
+                paginationType: PaginationType.OFFSET,
+                itemsField: ODATA_PAGINATION.ITEMS_FIELD,
+                totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
+                paginationParams: {
+                    pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+                    offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
+                    countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM,
+                },
+            },
+            excludeFromPrefix: ['directory', 'recursive', 'fileNameRegex'],
+            headers,
+        }, { ...restOptions, directory: '/', recursive: true });
+    }
+    /**
+     * Deletes a file from a bucket
+     *
+     * @param bucketId - The ID of the bucket
+     * @param path - The full path to the file to delete
+     * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`)
+     * @returns Promise resolving when the file is deleted
+     *
+     * @example
+     * ```typescript
+     * import { Buckets } from '@uipath/uipath-typescript/buckets';
+     *
+     * const buckets = new Buckets(sdk);
+     *
+     * // Delete a file from a bucket
+     * await buckets.deleteFile(<bucketId>, '/folder/file.pdf', { folderId: <folderId> });
+     * ```
+     */
+    async deleteFile(bucketId, path, options) {
+        if (!bucketId) {
+            throw new ValidationError({ message: 'bucketId is required for deleteFile' });
+        }
+        if (!path) {
+            throw new ValidationError({ message: 'path is required for deleteFile' });
+        }
+        const headers = resolveFolderHeaders({
+            folderId: options?.folderId,
+            folderKey: options?.folderKey,
+            folderPath: options?.folderPath,
+            resourceType: 'Buckets.deleteFile',
+            fallbackFolderKey: this.config.folderKey,
+        });
+        await this.delete(BUCKET_ENDPOINTS.DELETE_FILE(bucketId), {
+            params: { path },
+            headers,
+        });
+    }
     /**
      * Gets a direct upload URL for a file in the bucket
      *
@@ -2324,6 +2453,12 @@ __decorate([
 __decorate([
     track('Buckets.GetReadUri')
 ], BucketService.prototype, "getReadUri", null);
+__decorate([
+    track('Buckets.GetFiles')
+], BucketService.prototype, "getFiles", null);
+__decorate([
+    track('Buckets.DeleteFile')
+], BucketService.prototype, "deleteFile", null);
 
 var BucketOptions;
 (function (BucketOptions) {

package/dist/cases/index.cjs

@@ -126,6 +126,8 @@ const MAESTRO_ENDPOINTS = {
         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`,
+        /** Top elements ranked by failure count */
+        TOP_ELEMENTS_WITH_FAILURE: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/TopElementswithFailure`,
         /** Instance status aggregated by date for time-series charts */
         INSTANCE_STATUS_BY_DATE: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/InstanceStatusByDate`,
         /** Top processes ranked by total duration */
@@ -748,14 +750,25 @@ class ApiClient {
             if (!text) {
                 return undefined;
             }
-            return JSON.parse(text);
+            try {
+                return JSON.parse(text);
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    throw new ServerError({
+                        message: `Server returned non-JSON response (${response.status} ${response.url}): ${error.message}`,
+                        statusCode: response.status,
+                    });
+                }
+                throw error;
+            }
         }
         catch (error) {
             // If it's already one of our errors, re-throw it
             if (error.type && error.type.includes('Error')) {
                 throw error;
             }
-            // Otherwise, it's likely a network error
+            // Otherwise, it's a genuine network/fetch failure
             throw ErrorFactory.createNetworkError(error);
         }
     }
@@ -1522,9 +1535,9 @@ class PaginationHelpers {
      * @returns Promise resolving to a paginated result
      */
     static async getAllPaginated(params) {
-        const { serviceAccess, getEndpoint, folderId, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        const { serviceAccess, getEndpoint, folderId, headers: providedHeaders, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
         const endpoint = getEndpoint(folderId);
-        const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+        const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
         const paginatedResponse = await serviceAccess.requestWithPagination(method, endpoint, paginationParams, {
             headers,
             params: additionalParams,
@@ -1552,13 +1565,13 @@ class PaginationHelpers {
      * @returns Promise resolving to an object with data and totalCount
      */
     static async getAllNonPaginated(params) {
-        const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, headers: providedHeaders, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
         // Set default field names
         const itemsField = options.itemsField || DEFAULT_ITEMS_FIELD;
         const totalCountField = options.totalCountField || DEFAULT_TOTAL_COUNT_FIELD;
         // Determine endpoint and headers based on folderId
         const endpoint = folderId ? getByFolderEndpoint : getAllEndpoint;
-        const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+        const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
         // Make the API call based on method
         let response;
         if (method === HTTP_METHODS.POST) {
@@ -1617,6 +1630,7 @@ class PaginationHelpers {
                 serviceAccess: config.serviceAccess,
                 getEndpoint: config.getEndpoint,
                 folderId,
+                headers: config.headers,
                 paginationParams: cursor ? { cursor, pageSize } : jumpToPage ? { jumpToPage, pageSize } : { pageSize },
                 additionalParams: prefixedOptions,
                 transformFn: config.transformFn,
@@ -1634,6 +1648,7 @@ class PaginationHelpers {
             getAllEndpoint: config.getEndpoint(),
             getByFolderEndpoint: byFolderEndpoint,
             folderId,
+            headers: config.headers,
             additionalParams: prefixedOptions,
             transformFn: config.transformFn,
             method: config.method,
@@ -2098,6 +2113,52 @@ class CasesService extends BaseService {
         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 the top 10 BPMN elements ranked by failure count within a time range.
+     *
+     * Returns an array of up to 10 elements sorted by how many times they failed,
+     * useful for identifying the most error-prone activities in case processes.
+     *
+     * @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 ElementGetTopFailedCountResponse}
+     * @example
+     * ```typescript
+     * import { Cases } from '@uipath/uipath-typescript/cases';
+     *
+     * const cases = new Cases(sdk);
+     *
+     * // Get top failing elements for the last 7 days
+     * const topFailing = await cases.getTopElementFailedCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date()
+     * );
+     *
+     * for (const element of topFailing) {
+     *   console.log(`${element.elementName} (${element.elementType}): ${element.failedCount} failures`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Get top failing elements for a specific process
+     * const filtered = await cases.getTopElementFailedCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date(),
+     *   { processKey: '<processKey>' }
+     * );
+     * ```
+     */
+    async getTopElementFailedCount(startTime, endTime, options) {
+        const { data } = await this.post(MAESTRO_ENDPOINTS.INSIGHTS.TOP_ELEMENTS_WITH_FAILURE, buildInsightsTopBody(startTime, endTime, true, options));
+        return (data ?? []).map(item => ({
+            elementName: item.elementName,
+            elementType: item.elementType,
+            processKey: item.processKey,
+            failedCount: item.count,
+        }));
+    }
     /**
      * Get all instances status counts aggregated by date for case management processes.
      *
@@ -2253,6 +2314,9 @@ __decorate([
 __decorate([
     track('Cases.GetTopRunCount')
 ], CasesService.prototype, "getTopRunCount", null);
+__decorate([
+    track('Cases.GetTopElementFailedCount')
+], CasesService.prototype, "getTopElementFailedCount", null);
 __decorate([
     track('Cases.GetInstanceStatusTimeline')
 ], CasesService.prototype, "getInstanceStatusTimeline", null);

package/dist/cases/index.d.ts

@@ -39,6 +39,20 @@ interface GetTopFaultedCountResponse extends GetTopBaseResponse {
     /** Number of faulted instances in the given time range */
     faultedCount: number;
 }
+/**
+ * SDK response for top elements with failure.
+ * Shared by both MaestroProcesses and Cases — no service-specific enrichment.
+ */
+interface ElementGetTopFailedCountResponse {
+    /** BPMN element name (falls back to element ID if name is empty) */
+    elementName: string;
+    /** BPMN element type (e.g. ServiceTask, ReceiveTask, IntermediateCatchEvent) */
+    elementType: string;
+    /** The unique process key this element belongs to */
+    processKey: string;
+    /** Number of failed executions of this element in the given time range */
+    failedCount: number;
+}
 /**
  * Time bucketing granularity for insights time-series queries.
  *
@@ -371,6 +385,44 @@ interface CasesServiceModel {
      * ```
      */
     getTopFaultedCount(startTime: Date, endTime: Date, options?: TopQueryOptions): Promise<CaseGetTopFaultedCountResponse[]>;
+    /**
+     * Get the top 10 BPMN elements ranked by failure count within a time range.
+     *
+     * Returns an array of up to 10 elements sorted by how many times they failed,
+     * useful for identifying the most error-prone activities in case processes.
+     *
+     * @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 ElementGetTopFailedCountResponse}
+     * @example
+     * ```typescript
+     * import { Cases } from '@uipath/uipath-typescript/cases';
+     *
+     * const cases = new Cases(sdk);
+     *
+     * // Get top failing elements for the last 7 days
+     * const topFailing = await cases.getTopElementFailedCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date()
+     * );
+     *
+     * for (const element of topFailing) {
+     *   console.log(`${element.elementName} (${element.elementType}): ${element.failedCount} failures`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Get top failing elements for a specific process
+     * const filtered = await cases.getTopElementFailedCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date(),
+     *   { processKey: '<processKey>' }
+     * );
+     * ```
+     */
+    getTopElementFailedCount(startTime: Date, endTime: Date, options?: TopQueryOptions): Promise<ElementGetTopFailedCountResponse[]>;
     /**
      * Get all instances status counts aggregated by date for case management processes.
      *
@@ -1759,6 +1811,44 @@ declare class CasesService extends BaseService implements CasesServiceModel {
      * ```
      */
     getTopRunCount(startTime: Date, endTime: Date, options?: TopQueryOptions): Promise<CaseGetTopRunCountResponse[]>;
+    /**
+     * Get the top 10 BPMN elements ranked by failure count within a time range.
+     *
+     * Returns an array of up to 10 elements sorted by how many times they failed,
+     * useful for identifying the most error-prone activities in case processes.
+     *
+     * @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 ElementGetTopFailedCountResponse}
+     * @example
+     * ```typescript
+     * import { Cases } from '@uipath/uipath-typescript/cases';
+     *
+     * const cases = new Cases(sdk);
+     *
+     * // Get top failing elements for the last 7 days
+     * const topFailing = await cases.getTopElementFailedCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date()
+     * );
+     *
+     * for (const element of topFailing) {
+     *   console.log(`${element.elementName} (${element.elementType}): ${element.failedCount} failures`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Get top failing elements for a specific process
+     * const filtered = await cases.getTopElementFailedCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date(),
+     *   { processKey: '<processKey>' }
+     * );
+     * ```
+     */
+    getTopElementFailedCount(startTime: Date, endTime: Date, options?: TopQueryOptions): Promise<ElementGetTopFailedCountResponse[]>;
     /**
      * Get all instances status counts aggregated by date for case management processes.
      *
@@ -2134,4 +2224,4 @@ declare class CaseInstancesService extends BaseService implements CaseInstancesS
 }
 
 export { CaseInstancesService as CaseInstances, CaseInstancesService, CasesService as Cases, CasesService, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, InstanceFinalStatus, InstanceStatus, SLADurationUnit, SlaSummaryStatus, StageTaskType, TimeInterval, createCaseInstanceWithMethods };
-export type { CaseAppConfig, CaseAppOverview, CaseGetAllResponse, CaseGetStageResponse, CaseGetTopDurationResponse, CaseGetTopFaultedCountResponse, CaseGetTopRunCountResponse, CaseInstanceExecutionHistoryResponse, CaseInstanceGetAllOptions, CaseInstanceGetAllWithPaginationOptions, CaseInstanceGetResponse, CaseInstanceMethods, CaseInstanceOperationOptions, CaseInstanceOperationResponse, CaseInstanceReopenOptions, CaseInstanceRun, CaseInstanceSlaSummaryOptions, CaseInstanceStageSLAOptions, CaseInstanceStageSLAResponse, CaseInstanceStageSLAStage, CaseInstancesServiceModel, CasesServiceModel, ElementExecutionMetadata, ElementRunMetadata, EscalationAction, EscalationRecipient, EscalationRule, EscalationTriggerMetadata, GetTopBaseResponse, GetTopDurationResponse, GetTopFaultedCountResponse, GetTopRunCountResponse, InstanceStatusTimelineResponse, RawCaseInstanceGetResponse, SlaSummaryResponse, StageSLA, StageTask, TimelineOptions, TopQueryOptions };
+export type { CaseAppConfig, CaseAppOverview, CaseGetAllResponse, CaseGetStageResponse, CaseGetTopDurationResponse, CaseGetTopFaultedCountResponse, CaseGetTopRunCountResponse, CaseInstanceExecutionHistoryResponse, CaseInstanceGetAllOptions, CaseInstanceGetAllWithPaginationOptions, CaseInstanceGetResponse, CaseInstanceMethods, CaseInstanceOperationOptions, CaseInstanceOperationResponse, CaseInstanceReopenOptions, CaseInstanceRun, CaseInstanceSlaSummaryOptions, CaseInstanceStageSLAOptions, CaseInstanceStageSLAResponse, CaseInstanceStageSLAStage, CaseInstancesServiceModel, CasesServiceModel, ElementExecutionMetadata, ElementGetTopFailedCountResponse, ElementRunMetadata, EscalationAction, EscalationRecipient, EscalationRule, EscalationTriggerMetadata, GetTopBaseResponse, GetTopDurationResponse, GetTopFaultedCountResponse, GetTopRunCountResponse, InstanceStatusTimelineResponse, RawCaseInstanceGetResponse, SlaSummaryResponse, StageSLA, StageTask, TimelineOptions, TopQueryOptions };