@uipath/uipath-typescript 1.3.9 → 1.3.11

package/dist/index.umd.js

@@ -4516,6 +4516,8 @@
         GET_FILE_META_DATA: (id) => `${ORCHESTRATOR_BASE}/api/Buckets/${id}/ListFiles`,
         GET_READ_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetReadUri`,
         GET_WRITE_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetWriteUri`,
+        DELETE_FILE: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.DeleteFile`,
+        GET_FILES: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetFiles`,
     };
     /**
      * Orchestrator Process Service Endpoints
@@ -4598,6 +4600,8 @@
             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 */
@@ -4641,6 +4645,12 @@
         CHOICESETS: {
             GET_ALL: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
             GET_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/query_expansion`,
+            CREATE: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
+            UPDATE: (choiceSetId) => `${DATAFABRIC_BASE}/api/Entity/${choiceSetId}/metadata`,
+            DELETE: (choiceSetId) => `${DATAFABRIC_BASE}/api/Entity/${choiceSetId}/delete`,
+            INSERT_BY_NAME: (choiceSetName) => `${DATAFABRIC_BASE}/api/EntityService/${choiceSetName}/choiceset/insert`,
+            UPDATE_BY_NAME: (choiceSetName, valueId) => `${DATAFABRIC_BASE}/api/EntityService/${choiceSetName}/choiceset/${valueId}/update`,
+            DELETE_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/choiceset/delete`,
         },
     };
 
@@ -9239,7 +9249,7 @@
      * 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 = '$CONNECTION_STRING';
+    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';
     const VERSION = 'Version';
     const SERVICE = 'Service';
     const CLOUD_ORGANIZATION_NAME = 'CloudOrganizationName';
@@ -9565,7 +9575,7 @@
      * SDK's public API.
      */
     /** SDK version placeholder — patched by the SDK publish workflow. */
-    const SDK_VERSION = '1.3.9';
+    const SDK_VERSION = '1.3.11';
     const CLOUD_ROLE_NAME = 'uipath-ts-sdk';
     const SDK_SERVICE_NAME = 'UiPath.TypeScript.Sdk';
     const SDK_LOGGER_NAME = 'uipath-ts-sdk-telemetry';
@@ -10291,14 +10301,25 @@
                 if (!text) {
                     return undefined;
                 }
-                return JSON.parse(text);
+                try {
+                    return JSON.parse(text);
+                }
+                catch (error) {
+                    if (error instanceof SyntaxError) {
+                        throw new ServerError({
+                            message: `Server returned non-JSON response (${response.status} ${response.url}): ${error.message}`,
+                            statusCode: response.status,
+                        });
+                    }
+                    throw error;
+                }
             }
             catch (error) {
                 // If it's already one of our errors, re-throw it
                 if (error.type && error.type.includes('Error')) {
                     throw error;
                 }
-                // Otherwise, it's likely a network error
+                // Otherwise, it's a genuine network/fetch failure
                 throw ErrorFactory.createNetworkError(error);
             }
         }
@@ -11194,9 +11215,9 @@
          * @returns Promise resolving to a paginated result
          */
         static async getAllPaginated(params) {
-            const { serviceAccess, getEndpoint, folderId, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+            const { serviceAccess, getEndpoint, folderId, headers: providedHeaders, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
             const endpoint = getEndpoint(folderId);
-            const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+            const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
             const paginatedResponse = await serviceAccess.requestWithPagination(method, endpoint, paginationParams, {
                 headers,
                 params: additionalParams,
@@ -11224,13 +11245,13 @@
          * @returns Promise resolving to an object with data and totalCount
          */
         static async getAllNonPaginated(params) {
-            const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+            const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, headers: providedHeaders, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
             // Set default field names
             const itemsField = options.itemsField || DEFAULT_ITEMS_FIELD;
             const totalCountField = options.totalCountField || DEFAULT_TOTAL_COUNT_FIELD;
             // Determine endpoint and headers based on folderId
             const endpoint = folderId ? getByFolderEndpoint : getAllEndpoint;
-            const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+            const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
             // Make the API call based on method
             let response;
             if (method === HTTP_METHODS.POST) {
@@ -11289,6 +11310,7 @@
                     serviceAccess: config.serviceAccess,
                     getEndpoint: config.getEndpoint,
                     folderId,
+                    headers: config.headers,
                     paginationParams: cursor ? { cursor, pageSize } : jumpToPage ? { jumpToPage, pageSize } : { pageSize },
                     additionalParams: prefixedOptions,
                     transformFn: config.transformFn,
@@ -11306,6 +11328,7 @@
                 getAllEndpoint: config.getEndpoint(),
                 getByFolderEndpoint: byFolderEndpoint,
                 folderId,
+                headers: config.headers,
                 additionalParams: prefixedOptions,
                 transformFn: config.transformFn,
                 method: config.method,
@@ -12598,10 +12621,6 @@
          * @internal
          */
         async create(name, fields, options) {
-            this.validateName(name, 'entity');
-            for (const field of fields) {
-                this.validateName(field.fieldName, 'field');
-            }
             const opts = options ?? {};
             const payload = {
                 ...(opts.description !== undefined && { description: opts.description }),
@@ -12744,6 +12763,7 @@
                         ...(update.isUnique !== undefined && { isUnique: update.isUnique }),
                         ...(update.isRbacEnabled !== undefined && { isRbacEnabled: update.isRbacEnabled }),
                         ...(update.isEncrypted !== undefined && { isEncrypted: update.isEncrypted }),
+                        ...(update.isHiddenField !== undefined && { isHiddenField: update.isHiddenField }),
                         ...(update.defaultValue !== undefined && { defaultValue: update.defaultValue }),
                         ...(hasConstraintUpdate && f.sqlType && { sqlType: { ...f.sqlType, ...constraintUpdate } }),
                     };
@@ -12752,9 +12772,6 @@
             // Build and append new fields
             const newFields = [];
             if (options.addFields?.length) {
-                for (const field of options.addFields) {
-                    this.validateName(field.fieldName, 'field');
-                }
                 newFields.push(...options.addFields.map(f => this.buildSchemaFieldPayload(f)));
             }
             await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPSERT, {
@@ -12855,9 +12872,15 @@
         }
         /** Converts a user-facing EntityCreateFieldOptions to the raw API field payload */
         buildSchemaFieldPayload(field) {
-            this.validateName(field.fieldName, 'field');
             const fieldType = field.type ?? exports.EntityFieldDataType.STRING;
             this.validateFieldConstraints(fieldType, field, field.fieldName);
+            const isRelationship = fieldType === exports.EntityFieldDataType.RELATIONSHIP;
+            const isFile = fieldType === exports.EntityFieldDataType.FILE;
+            if ((isRelationship || isFile) && (!field.referenceEntityId || !field.referenceFieldId)) {
+                throw new ValidationError({
+                    message: `Field '${field.fieldName}' of type ${fieldType} requires both referenceEntityId and referenceFieldId (UUIDs of the target entity and field).`,
+                });
+            }
             const mapping = EntitySchemaFieldTypeMap[fieldType];
             return {
                 name: field.fieldName,
@@ -12872,10 +12895,13 @@
                 isUnique: field.isUnique ?? false,
                 isRbacEnabled: field.isRbacEnabled ?? false,
                 isEncrypted: field.isEncrypted ?? false,
+                isHiddenField: field.isHiddenField ?? false,
                 ...(field.defaultValue !== undefined && { defaultValue: field.defaultValue }),
                 ...(field.choiceSetId !== undefined && { choiceSetId: field.choiceSetId }),
-                ...(field.referenceEntityName !== undefined && { referenceEntityName: field.referenceEntityName }),
-                ...(field.referenceFieldName !== undefined && { referenceFieldName: field.referenceFieldName }),
+                ...((isRelationship || isFile) && { isForeignKey: true }),
+                ...(isRelationship && { referenceType: exports.ReferenceType.ManyToOne }),
+                ...(field.referenceEntityId !== undefined && { referenceEntity: { id: field.referenceEntityId } }),
+                ...(field.referenceFieldId !== undefined && { referenceField: { id: field.referenceFieldId } }),
             };
         }
         /**
@@ -12979,24 +13005,7 @@
                     return {};
             }
         }
-        validateName(name, context) {
-            if (name.length < 3 || name.length > 100 || !/^[a-zA-Z]\w*$/.test(name)) {
-                const suggestion = name.replace(/\W/g, '').replace(/^[0-9_]+/, '');
-                const defaultName = `My${context.charAt(0).toUpperCase() + context.slice(1)}`;
-                throw new ValidationError({
-                    message: `Invalid ${context} name '${name}'. Must start with a letter, contain only letters, numbers, and underscores, 3–100 characters (e.g., "${suggestion || defaultName}").`
-                });
-            }
-            if (context === 'field' && EntityService.RESERVED_FIELD_NAMES.has(name)) {
-                throw new ValidationError({
-                    message: `Field name '${name}' is reserved. Reserved names: ${[...EntityService.RESERVED_FIELD_NAMES].join(', ')}.`
-                });
-            }
-        }
     }
-    EntityService.RESERVED_FIELD_NAMES = new Set([
-        'Id', 'CreatedBy', 'CreateTime', 'UpdatedBy', 'UpdateTime'
-    ]);
     __decorate([
         track('Entities.GetById')
     ], EntityService.prototype, "getById", null);
@@ -13093,7 +13102,7 @@
          *
          * @example
          * ```typescript
-         * import { ChoiceSets } from '@uipath/uipath-typescript/choicesets';
+         * import { ChoiceSets } from '@uipath/uipath-typescript/entities';
          *
          * const choiceSets = new ChoiceSets(sdk);
          *
@@ -13142,6 +13151,188 @@
                 }
             }, options);
         }
+        /**
+         * Creates a new Data Fabric choice set
+         *
+         * @param name - Choice set name. Must start with a
+         *   letter, may contain only letters, numbers, and underscores, length
+         *   3–100 characters (e.g., `"expenseTypes"`).
+         * @param options - Optional choice-set-level settings ({@link ChoiceSetCreateOptions})
+         * @returns Promise resolving to the UUID of the created choice set
+         *
+         * @example
+         * ```typescript
+         * import { ChoiceSets } from '@uipath/uipath-typescript/entities';
+         *
+         * const choicesets = new ChoiceSets(sdk);
+         *
+         * // Minimal create
+         * const expenseTypesId = await choicesets.create("expense_types");
+         *
+         * // With display name and description
+         * const priorityLevelsId = await choicesets.create("priority_levels", {
+         *   displayName: "Priority Levels",
+         *   description: "Ticket priority categories",
+         * });
+         * ```
+         * @internal
+         */
+        async create(name, options) {
+            const opts = options ?? {};
+            const payload = {
+                ...(opts.description !== undefined && { description: opts.description }),
+                ...(opts.displayName !== undefined && { displayName: opts.displayName }),
+                entityDefinition: {
+                    name,
+                    fields: [],
+                    folderId: opts.folderKey ?? DATA_FABRIC_TENANT_FOLDER_ID,
+                },
+            };
+            const response = await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.CREATE, payload);
+            return response.data;
+        }
+        /**
+         * Updates an existing choice set's metadata (display name and/or description).
+         *
+         * **At least one of `displayName` or `description` must be provided** —
+         * the call throws `ValidationError` if both are omitted.
+         *
+         * @param choiceSetId - UUID of the choice set to update
+         * @param options - Metadata fields to change ({@link ChoiceSetUpdateOptions})
+         * @returns Promise resolving when the update is complete
+         *
+         * @example
+         * ```typescript
+         * // First, get the choice set ID using getAll()
+         * const allChoiceSets = await choicesets.getAll();
+         * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+         *
+         * await choicesets.updateById(expenseTypes.id, {
+         *   displayName: "Expense Categories",
+         *   description: "Updated description",
+         * });
+         * ```
+         * @internal
+         */
+        async updateById(choiceSetId, options) {
+            if (options.displayName === undefined && options.description === undefined) {
+                throw new ValidationError({
+                    message: 'updateById requires at least one of displayName or description.',
+                });
+            }
+            await this.patch(DATA_FABRIC_ENDPOINTS.CHOICESETS.UPDATE(choiceSetId), {
+                ...(options.displayName !== undefined && { displayName: options.displayName }),
+                ...(options.description !== undefined && { description: options.description }),
+            });
+        }
+        /**
+         * Deletes a Data Fabric choice set and all its values.
+         *
+         * @param choiceSetId - UUID of the choice set to delete
+         * @returns Promise resolving when the choice set is deleted
+         *
+         * @example
+         * ```typescript
+         * // First, get the choice set ID using getAll()
+         * const allChoiceSets = await choicesets.getAll();
+         * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+         *
+         * await choicesets.deleteById(expenseTypes.id);
+         * ```
+         * @internal
+         */
+        async deleteById(choiceSetId) {
+            await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.DELETE(choiceSetId), {});
+        }
+        /**
+         * Inserts a single value into a choice set.
+         *
+         * @param choiceSetId - UUID of the parent choice set
+         * @param name - Identifier name of the new value (e.g., `"TRAVEL"`)
+         * @param options - Optional fields ({@link ChoiceSetValueInsertOptions})
+         * @returns Promise resolving to the inserted value ({@link ChoiceSetValueInsertResponse})
+         *
+         * @example
+         * ```typescript
+         * // First, get the choice set ID using getAll()
+         * const allChoiceSets = await choicesets.getAll();
+         * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+         *
+         * const inserted = await choicesets.insertValueById(expenseTypes.id, 'TRAVEL', {
+         *   displayName: 'Travel',
+         * });
+         * console.log(inserted.id);
+         * ```
+         * @internal
+         */
+        async insertValueById(choiceSetId, name, options) {
+            const choiceSetName = await this.resolveChoiceSetName(choiceSetId);
+            const payload = {
+                Name: name,
+                ...(options?.displayName !== undefined && { DisplayName: options.displayName }),
+            };
+            const response = await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.INSERT_BY_NAME(choiceSetName), payload);
+            const camelCased = pascalToCamelCaseKeys(response.data);
+            return transformData(camelCased, EntityMap);
+        }
+        /**
+         * Updates an existing choice-set value's display name.
+         *
+         * Only `displayName` is mutable; the value's `name` (identifier) is fixed at
+         * insert time and cannot be changed.
+         *
+         * @param choiceSetId - UUID of the parent choice set
+         * @param valueId - UUID of the value to update
+         * @param displayName - New human-readable display name for the value
+         * @returns Promise resolving to the updated value ({@link ChoiceSetValueUpdateResponse})
+         *
+         * @example
+         * ```typescript
+         * // Get the choice set ID from getAll() and the value ID from getById()
+         * const allChoiceSets = await choicesets.getAll();
+         * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+         * const values = await choicesets.getById(expenseTypes.id);
+         * const travel = values.items.find(v => v.name === 'TRAVEL');
+         *
+         * await choicesets.updateValueById(expenseTypes.id, travel.id, 'Business Travel');
+         * ```
+         * @internal
+         */
+        async updateValueById(choiceSetId, valueId, displayName) {
+            const choiceSetName = await this.resolveChoiceSetName(choiceSetId);
+            const payload = { DisplayName: displayName };
+            const response = await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.UPDATE_BY_NAME(choiceSetName, valueId), payload);
+            const camelCased = pascalToCamelCaseKeys(response.data);
+            return transformData(camelCased, EntityMap);
+        }
+        /**
+         * Deletes one or more values from a choice set.
+         *
+         * @param choiceSetId - UUID of the parent choice set
+         * @param valueIds - Array of value UUIDs to delete
+         * @returns Promise resolving when the values are deleted
+         *
+         * @example
+         * ```typescript
+         * // Get the value IDs from getById()
+         * const values = await choicesets.getById('<choiceSetId>');
+         * const idsToDelete = values.items.slice(0, 2).map(v => v.id);
+         *
+         * await choicesets.deleteValuesById('<choiceSetId>', idsToDelete);
+         * ```
+         * @internal
+         */
+        async deleteValuesById(choiceSetId, valueIds) {
+            await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.DELETE_BY_ID(choiceSetId), valueIds);
+        }
+        async resolveChoiceSetName(choiceSetId) {
+            const all = await this.getAll();
+            const match = all.find(cs => cs.id === choiceSetId);
+            if (!match) {
+                throw new NotFoundError({ message: `Choice set with id '${choiceSetId}' not found.` });
+            }
+            return match.name;
+        }
     }
     __decorate([
         track('Choicesets.GetAll')
@@ -13149,6 +13340,24 @@
     __decorate([
         track('Choicesets.GetById')
     ], ChoiceSetService.prototype, "getById", null);
+    __decorate([
+        track('Choicesets.Create')
+    ], ChoiceSetService.prototype, "create", null);
+    __decorate([
+        track('Choicesets.UpdateById')
+    ], ChoiceSetService.prototype, "updateById", null);
+    __decorate([
+        track('Choicesets.DeleteById')
+    ], ChoiceSetService.prototype, "deleteById", null);
+    __decorate([
+        track('Choicesets.InsertValueById')
+    ], ChoiceSetService.prototype, "insertValueById", null);
+    __decorate([
+        track('Choicesets.UpdateValueById')
+    ], ChoiceSetService.prototype, "updateValueById", null);
+    __decorate([
+        track('Choicesets.DeleteValuesById')
+    ], ChoiceSetService.prototype, "deleteValuesById", null);
 
     /**
      * Maestro Process Models
@@ -14077,6 +14286,52 @@
             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 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 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 { MaestroProcesses } from '@uipath/uipath-typescript/maestro-processes';
+         *
+         * const maestroProcesses = new MaestroProcesses(sdk);
+         *
+         * // Get top failing elements for the last 7 days
+         * const topFailing = await maestroProcesses.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 maestroProcesses.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, false, 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 maestro processes.
          *
@@ -14217,6 +14472,9 @@
     __decorate([
         track('MaestroProcesses.GetTopRunCount')
     ], MaestroProcessesService.prototype, "getTopRunCount", null);
+    __decorate([
+        track('MaestroProcesses.GetTopElementFailedCount')
+    ], MaestroProcessesService.prototype, "getTopElementFailedCount", null);
     __decorate([
         track('MaestroProcesses.GetInstanceStatusTimeline')
     ], MaestroProcessesService.prototype, "getInstanceStatusTimeline", null);
@@ -14351,6 +14609,52 @@
             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.
          *
@@ -14506,6 +14810,9 @@
     __decorate([
         track('Cases.GetTopRunCount')
     ], CasesService.prototype, "getTopRunCount", null);
+    __decorate([
+        track('Cases.GetTopElementFailedCount')
+    ], CasesService.prototype, "getTopElementFailedCount", null);
     __decorate([
         track('Cases.GetInstanceStatusTimeline')
     ], CasesService.prototype, "getInstanceStatusTimeline", null);
@@ -16402,6 +16709,120 @@
             }
             return transformedData;
         }
+        /**
+         * Lists all files in a bucket.
+         *
+         * Returns a flat, recursive listing of all files in the bucket. Supports regex filtering
+         * and filter / orderby / select / expand. {@link BucketFile} entries include
+         * `isDirectory` so callers can distinguish folders from files.
+         *
+         * The method returns either:
+         * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+         * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+         *
+         * @param bucketId - The ID of the bucket
+         * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional parameters for regex filtering, query options, and pagination
+         * @returns Promise resolving to either an array of files NonPaginatedResponse<BucketFile> or a PaginatedResponse<BucketFile> when pagination options are used.
+         *
+         * @example
+         * ```typescript
+         * import { Buckets } from '@uipath/uipath-typescript/buckets';
+         *
+         * const buckets = new Buckets(sdk);
+         *
+         * // List all files in the bucket
+         * const files = await buckets.getFiles(<bucketId>, { folderId: <folderId> });
+         *
+         * // Filter by regex pattern
+         * const pdfs = await buckets.getFiles(<bucketId>, {
+         *   folderId: <folderId>,
+         *   fileNameRegex: '.*\\.pdf$'
+         * });
+         *
+         * // First page with pagination
+         * const page1 = await buckets.getFiles(<bucketId>, { folderId: <folderId>, pageSize: 10 });
+         *
+         * // Navigate using cursor
+         * if (page1.hasNextPage) {
+         *   const page2 = await buckets.getFiles(<bucketId>, { folderId: <folderId>, cursor: page1.nextCursor });
+         * }
+         *
+         * // Jump to specific page
+         * const page5 = await buckets.getFiles(<bucketId>, {
+         *   folderId: <folderId>,
+         *   jumpToPage: 5,
+         *   pageSize: 10
+         * });
+         * ```
+         */
+        async getFiles(bucketId, options) {
+            if (!bucketId) {
+                throw new ValidationError({ message: 'bucketId is required for getFiles' });
+            }
+            const { folderId, folderKey, folderPath, ...restOptions } = options ?? {};
+            const headers = resolveFolderHeaders({
+                folderId,
+                folderKey,
+                folderPath,
+                resourceType: 'Buckets.getFiles',
+                fallbackFolderKey: this.config.folderKey,
+            });
+            const transformBucketFile = (file) => transformData(pascalToCamelCaseKeys(file), BucketMap);
+            return PaginationHelpers.getAll({
+                serviceAccess: this.createPaginationServiceAccess(),
+                getEndpoint: () => BUCKET_ENDPOINTS.GET_FILES(bucketId),
+                transformFn: transformBucketFile,
+                pagination: {
+                    paginationType: PaginationType.OFFSET,
+                    itemsField: ODATA_PAGINATION.ITEMS_FIELD,
+                    totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
+                    paginationParams: {
+                        pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+                        offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
+                        countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM,
+                    },
+                },
+                excludeFromPrefix: ['directory', 'recursive', 'fileNameRegex'],
+                headers,
+            }, { ...restOptions, directory: '/', recursive: true });
+        }
+        /**
+         * Deletes a file from a bucket
+         *
+         * @param bucketId - The ID of the bucket
+         * @param path - The full path to the file to delete
+         * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`)
+         * @returns Promise resolving when the file is deleted
+         *
+         * @example
+         * ```typescript
+         * import { Buckets } from '@uipath/uipath-typescript/buckets';
+         *
+         * const buckets = new Buckets(sdk);
+         *
+         * // Delete a file from a bucket
+         * await buckets.deleteFile(<bucketId>, '/folder/file.pdf', { folderId: <folderId> });
+         * ```
+         */
+        async deleteFile(bucketId, path, options) {
+            if (!bucketId) {
+                throw new ValidationError({ message: 'bucketId is required for deleteFile' });
+            }
+            if (!path) {
+                throw new ValidationError({ message: 'path is required for deleteFile' });
+            }
+            const headers = resolveFolderHeaders({
+                folderId: options?.folderId,
+                folderKey: options?.folderKey,
+                folderPath: options?.folderPath,
+                resourceType: 'Buckets.deleteFile',
+                fallbackFolderKey: this.config.folderKey,
+            });
+            await this.delete(BUCKET_ENDPOINTS.DELETE_FILE(bucketId), {
+                params: { path },
+                headers,
+            });
+        }
         /**
          * Gets a direct upload URL for a file in the bucket
          *
@@ -16435,6 +16856,12 @@
     __decorate([
         track('Buckets.GetReadUri')
     ], BucketService.prototype, "getReadUri", null);
+    __decorate([
+        track('Buckets.GetFiles')
+    ], BucketService.prototype, "getFiles", null);
+    __decorate([
+        track('Buckets.DeleteFile')
+    ], BucketService.prototype, "deleteFile", null);
 
     exports.BucketOptions = void 0;
     (function (BucketOptions) {
@@ -17232,33 +17659,32 @@
                 }
             }, options);
         }
-        /**
-         * Starts a process execution (job)
-         *
-         * @param request - Process start request body
-         * @param folderId - Required folder ID
-         * @param options - Optional query parameters
-         * @returns Promise resolving to the created jobs
-         *
-         * @example
-         * ```typescript
-         * import { Processes } from '@uipath/uipath-typescript/processes';
-         *
-         * const processes = new Processes(sdk);
-         *
-         * // Start a process by process key
-         * const jobs = await processes.start({
-         *   processKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
-         * }, 123); // folderId is required
-         *
-         * // Start a process by name with specific robots
-         * const jobs = await processes.start({
-         *   processName: "MyProcess"
-         * }, 123); // folderId is required
-         * ```
-         */
-        async start(request, folderId, options = {}) {
-            const headers = createHeaders({ [FOLDER_ID]: folderId });
+        async start(request, optionsOrFolderId, legacyOptions) {
+            // Normalize the two overload forms into a single internal shape.
+            let folderId;
+            let folderKey;
+            let folderPath;
+            let queryOptions;
+            if (typeof optionsOrFolderId === 'number') {
+                // Deprecated positional form: start(request, folderId, options?)
+                folderId = optionsOrFolderId;
+                queryOptions = legacyOptions ?? {};
+            }
+            else {
+                // Preferred form: start(request, options?)
+                const { folderId: fid, folderKey: fkey, folderPath: fpath, ...rest } = optionsOrFolderId ?? {};
+                folderId = fid;
+                folderKey = fkey;
+                folderPath = fpath;
+                queryOptions = rest;
+            }
+            const headers = resolveFolderHeaders({
+                folderId,
+                folderKey,
+                folderPath,
+                resourceType: 'processes.start',
+                fallbackFolderKey: this.config.folderKey,
+            });
             // Transform SDK field names to API field names (e.g., processKey → releaseKey)
             const apiRequest = transformRequest(request, ProcessMap);
             // Create the request object according to API spec
@@ -17266,8 +17692,8 @@
                 startInfo: apiRequest
             };
             // Prefix all query parameter keys with '$' for OData
-            const keysToPrefix = Object.keys(options);
-            const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+            const keysToPrefix = Object.keys(queryOptions);
+            const apiOptions = addPrefixToKeys(queryOptions, ODATA_PREFIX, keysToPrefix);
             const response = await this.post(PROCESS_ENDPOINTS.START_PROCESS, requestBody, {
                 params: apiOptions,
                 headers