@uipath/uipath-typescript 1.3.9 → 1.3.10

package/dist/index.mjs

@@ -4512,6 +4512,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`,
 };
 /**
  * Orchestrator Process Service Endpoints
@@ -4637,6 +4639,12 @@ const DATA_FABRIC_ENDPOINTS = {
     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`,
     },
 };
 
@@ -5482,7 +5490,7 @@ function normalizeBaseUrl(url) {
  * SDK's public API.
  */
 /** SDK version placeholder — patched by the SDK publish workflow. */
-const SDK_VERSION = '1.3.9';
+const SDK_VERSION = '1.3.10';
 const CLOUD_ROLE_NAME = 'uipath-ts-sdk';
 const SDK_SERVICE_NAME = 'UiPath.TypeScript.Sdk';
 const SDK_LOGGER_NAME = 'uipath-ts-sdk-telemetry';
@@ -6208,14 +6216,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);
         }
     }
@@ -7111,9 +7130,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,
@@ -7141,13 +7160,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) {
@@ -7206,6 +7225,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,
@@ -7223,6 +7243,7 @@ class PaginationHelpers {
             getAllEndpoint: config.getEndpoint(),
             getByFolderEndpoint: byFolderEndpoint,
             folderId,
+            headers: config.headers,
             additionalParams: prefixedOptions,
             transformFn: config.transformFn,
             method: config.method,
@@ -9010,7 +9031,7 @@ class ChoiceSetService extends BaseService {
      *
      * @example
      * ```typescript
-     * import { ChoiceSets } from '@uipath/uipath-typescript/choicesets';
+     * import { ChoiceSets } from '@uipath/uipath-typescript/entities';
      *
      * const choiceSets = new ChoiceSets(sdk);
      *
@@ -9059,6 +9080,188 @@ class ChoiceSetService extends BaseService {
             }
         }, 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')
@@ -9066,6 +9269,24 @@ __decorate([
 __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
@@ -12319,6 +12540,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
      *
@@ -12352,6 +12687,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) {
@@ -13149,33 +13490,32 @@ class ProcessService extends FolderScopedService {
             }
         }, 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
@@ -13183,8 +13523,8 @@ class ProcessService extends FolderScopedService {
             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