@uipath/uipath-typescript 1.3.9 → 1.3.10

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
@@ -4641,6 +4643,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`,
         },
     };
 
@@ -9565,7 +9573,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.10';
     const CLOUD_ROLE_NAME = 'uipath-ts-sdk';
     const SDK_SERVICE_NAME = 'UiPath.TypeScript.Sdk';
     const SDK_LOGGER_NAME = 'uipath-ts-sdk-telemetry';
@@ -10291,14 +10299,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 +11213,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 +11243,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 +11308,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 +11326,7 @@
                 getAllEndpoint: config.getEndpoint(),
                 getByFolderEndpoint: byFolderEndpoint,
                 folderId,
+                headers: config.headers,
                 additionalParams: prefixedOptions,
                 transformFn: config.transformFn,
                 method: config.method,
@@ -13093,7 +13114,7 @@
          *
          * @example
          * ```typescript
-         * import { ChoiceSets } from '@uipath/uipath-typescript/choicesets';
+         * import { ChoiceSets } from '@uipath/uipath-typescript/entities';
          *
          * const choiceSets = new ChoiceSets(sdk);
          *
@@ -13142,6 +13163,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 +13352,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
@@ -16402,6 +16623,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 +16770,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 +17573,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 +17606,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

package/dist/jobs/index.cjs

@@ -613,14 +613,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);
         }
     }
@@ -1221,9 +1232,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,
@@ -1251,13 +1262,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) {
@@ -1316,6 +1327,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,
@@ -1333,6 +1345,7 @@ class PaginationHelpers {
             getAllEndpoint: config.getEndpoint(),
             getByFolderEndpoint: byFolderEndpoint,
             folderId,
+            headers: config.headers,
             additionalParams: prefixedOptions,
             transformFn: config.transformFn,
             method: config.method,

package/dist/jobs/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);
         }
     }
@@ -1219,9 +1230,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,
@@ -1249,13 +1260,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) {
@@ -1314,6 +1325,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,
@@ -1331,6 +1343,7 @@ class PaginationHelpers {
             getAllEndpoint: config.getEndpoint(),
             getByFolderEndpoint: byFolderEndpoint,
             folderId,
+            headers: config.headers,
             additionalParams: prefixedOptions,
             transformFn: config.transformFn,
             method: config.method,