@cognite/underscore 1.0.1 → 1.48535.0

package/README.md

@@ -15,11 +15,13 @@ See the collection of functions [here](./docs/modules.md).
 ## Importing
 
 The library has two modules. Non-React functions is imported the following way:
+
 ```ts
 import { someFunction } from '@cognite/underscore';
 ```
 
 But React functions are imported the following way:
+
 ```ts
 import { someFunction } from '@cognite/underscore/react';
 ```

package/dist/arrays.d.ts

@@ -1,41 +1,41 @@
 /**
- * Inserts an element at a specific index in an array.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} array - The array.
- * @param {number} index - The index at which to insert the element.
- * @param {T} item - The element to insert.
- */
+* Inserts an element at a specific index in an array.
+*
+* @template T - The type of elements in the array.
+* @param {T[]} array - The array.
+* @param {number} index - The index at which to insert the element.
+* @param {T} item - The element to insert.
+*/
 export declare function insertAt<T>(array: T[], index: number, item: T): void;
 /**
- * Removes an element from an array, but only removed the first occurrence.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} array - The array.
- * @param {T} item - The element to remove.
- */
+* Removes an element from an array, but only removed the first occurrence.
+*
+* @template T - The type of elements in the array.
+* @param {T[]} array - The array.
+* @param {T} item - The element to remove.
+*/
 export declare function remove<T>(array: T[], item: T): void;
 /**
- * Removes an element by the index from an array.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} array - The array.
- * @param {number} index - The index of the element to remove.
- */
+* Removes an element by the index from an array.
+*
+* @template T - The type of elements in the array.
+* @param {T[]} array - The array.
+* @param {number} index - The index of the element to remove.
+*/
 export declare function removeAt<T>(array: T[], index: number): void;
 /**
- * Swaps two elements in an array at index `i` and `j`.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} array - The array.
- * @param {number} i - The index of the first element.
- * @param {number} j - The index of the second element.
- */
+* Swaps two elements in an array at index `i` and `j`.
+*
+* @template T - The type of elements in the array.
+* @param {T[]} array - The array.
+* @param {number} i - The index of the first element.
+* @param {number} j - The index of the second element.
+*/
 export declare function swap<T>(array: T[], i: number, j: number): void;
 /**
- * Shuffles the elements of the given array using the Fisher-Yates algorithm.
- *
- * @template T - The type of elements in the array.
- * @param {T[]} array - The array.
- */
+* Shuffles the elements of the given array using the Fisher-Yates algorithm.
+*
+* @template T - The type of elements in the array.
+* @param {T[]} array - The array.
+*/
 export declare function shuffle<T>(array: T[]): void;

package/dist/arrays.js

@@ -1,23 +1,58 @@
-import { randomInteger as e } from "./random.js";
-//#region libs/shared/underscore/src/arrays.ts
-function t(e, t, n) {
-	e.splice(t, 0, n);
+import { randomInteger } from "./random.js";
+/**
+ * Inserts an element at a specific index in an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array.
+ * @param {number} index - The index at which to insert the element.
+ * @param {T} item - The element to insert.
+ */ export function insertAt(array, index, item) {
+    array.splice(index, 0, item);
 }
-function n(e, t) {
-	let n = e.indexOf(t);
-	n !== -1 && r(e, n);
+/**
+ * Removes an element from an array, but only removed the first occurrence.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array.
+ * @param {T} item - The element to remove.
+ */ export function remove(array, item) {
+    const index = array.indexOf(item);
+    if (index !== -1) {
+        removeAt(array, index);
+    }
 }
-function r(e, t) {
-	e.splice(t, 1);
+/**
+ * Removes an element by the index from an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array.
+ * @param {number} index - The index of the element to remove.
+ */ export function removeAt(array, index) {
+    array.splice(index, 1);
 }
-function i(e, t, n) {
-	[e[t], e[n]] = [e[n], e[t]];
+/**
+ * Swaps two elements in an array at index `i` and `j`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array.
+ * @param {number} i - The index of the first element.
+ * @param {number} j - The index of the second element.
+ */ export function swap(array, i, j) {
+    [array[i], array[j]] = [
+        array[j],
+        array[i]
+    ];
 }
-function a(t) {
-	for (let n = t.length - 1; n >= 0; n--) {
-		let r = e(0, n + 1);
-		i(t, n, r);
-	}
+/**
+ * Shuffles the elements of the given array using the Fisher-Yates algorithm.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array.
+ */ export function shuffle(array) {
+    for(let i = array.length - 1; i >= 0; i--){
+        const j = randomInteger(0, i + 1);
+        swap(array, i, j);
+    }
 }
-//#endregion
-export { t as insertAt, n as remove, r as removeAt, a as shuffle, i as swap };
+
+//# sourceMappingURL=arrays.js.map

package/dist/arrays.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/arrays.ts"],"sourcesContent":["import { randomInteger } from './random';\n\n/**\n * Inserts an element at a specific index in an array.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} array - The array.\n * @param {number} index - The index at which to insert the element.\n * @param {T} item - The element to insert.\n */\nexport function insertAt<T>(array: T[], index: number, item: T): void {\n  array.splice(index, 0, item);\n}\n\n/**\n * Removes an element from an array, but only removed the first occurrence.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} array - The array.\n * @param {T} item - The element to remove.\n */\nexport function remove<T>(array: T[], item: T): void {\n  const index = array.indexOf(item);\n  if (index !== -1) {\n    removeAt(array, index);\n  }\n}\n\n/**\n * Removes an element by the index from an array.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} array - The array.\n * @param {number} index - The index of the element to remove.\n */\nexport function removeAt<T>(array: T[], index: number): void {\n  array.splice(index, 1);\n}\n\n/**\n * Swaps two elements in an array at index `i` and `j`.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} array - The array.\n * @param {number} i - The index of the first element.\n * @param {number} j - The index of the second element.\n */\nexport function swap<T>(array: T[], i: number, j: number): void {\n  [array[i], array[j]] = [array[j], array[i]];\n}\n\n/**\n * Shuffles the elements of the given array using the Fisher-Yates algorithm.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} array - The array.\n */\nexport function shuffle<T>(array: T[]): void {\n  for (let i = array.length - 1; i >= 0; i--) {\n    const j = randomInteger(0, i + 1);\n    swap(array, i, j);\n  }\n}\n"],"names":["randomInteger","insertAt","array","index","item","splice","remove","indexOf","removeAt","swap","i","j","shuffle","length"],"mappings":"AAAA,SAASA,aAAa,QAAQ,cAAW;AAEzC;;;;;;;CAOC,GACD,OAAO,SAASC,SAAYC,KAAU,EAAEC,KAAa,EAAEC,IAAO;IAC5DF,MAAMG,MAAM,CAACF,OAAO,GAAGC;AACzB;AAEA;;;;;;CAMC,GACD,OAAO,SAASE,OAAUJ,KAAU,EAAEE,IAAO;IAC3C,MAAMD,QAAQD,MAAMK,OAAO,CAACH;IAC5B,IAAID,UAAU,CAAC,GAAG;QAChBK,SAASN,OAAOC;IAClB;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASK,SAAYN,KAAU,EAAEC,KAAa;IACnDD,MAAMG,MAAM,CAACF,OAAO;AACtB;AAEA;;;;;;;CAOC,GACD,OAAO,SAASM,KAAQP,KAAU,EAAEQ,CAAS,EAAEC,CAAS;IACtD,CAACT,KAAK,CAACQ,EAAE,EAAER,KAAK,CAACS,EAAE,CAAC,GAAG;QAACT,KAAK,CAACS,EAAE;QAAET,KAAK,CAACQ,EAAE;KAAC;AAC7C;AAEA;;;;;CAKC,GACD,OAAO,SAASE,QAAWV,KAAU;IACnC,IAAK,IAAIQ,IAAIR,MAAMW,MAAM,GAAG,GAAGH,KAAK,GAAGA,IAAK;QAC1C,MAAMC,IAAIX,cAAc,GAAGU,IAAI;QAC/BD,KAAKP,OAAOQ,GAAGC;IACjB;AACF"}

package/dist/assert.d.ts

@@ -1,8 +1,8 @@
 /**
- * Whatever gets passed into the condition parameter must be true if the assert returns. That means that for the rest of the scope, that condition must be truthy from the perspective of the type checker.
- * Adapted from {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions}
- *
- * @param condition - A condition which is guaranteed to be true for the rest of the calling scope after this function returns.
- * @param msg - The message which should be included in the error given that the condition fails.
- */
+* Whatever gets passed into the condition parameter must be true if the assert returns. That means that for the rest of the scope, that condition must be truthy from the perspective of the type checker.
+* Adapted from {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions}
+*
+* @param condition - A condition which is guaranteed to be true for the rest of the calling scope after this function returns.
+* @param msg - The message which should be included in the error given that the condition fails.
+*/
 export declare function assert(condition: unknown, msg?: string): asserts condition;

package/dist/assert.js

@@ -1,6 +1,13 @@
-//#region libs/shared/underscore/src/assert.ts
-function e(e, t) {
-	if (!e) throw Error(t);
+/**
+ * Whatever gets passed into the condition parameter must be true if the assert returns. That means that for the rest of the scope, that condition must be truthy from the perspective of the type checker.
+ * Adapted from {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions}
+ *
+ * @param condition - A condition which is guaranteed to be true for the rest of the calling scope after this function returns.
+ * @param msg - The message which should be included in the error given that the condition fails.
+ */ export function assert(condition, msg) {
+    if (!Boolean(condition)) {
+        throw new Error(msg);
+    }
 }
-//#endregion
-export { e as assert };
+
+//# sourceMappingURL=assert.js.map

package/dist/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/assert.ts"],"sourcesContent":["/**\n * Whatever gets passed into the condition parameter must be true if the assert returns. That means that for the rest of the scope, that condition must be truthy from the perspective of the type checker.\n * Adapted from {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions}\n *\n * @param condition - A condition which is guaranteed to be true for the rest of the calling scope after this function returns.\n * @param msg - The message which should be included in the error given that the condition fails.\n */\nexport function assert(condition: unknown, msg?: string): asserts condition {\n  if (!Boolean(condition)) {\n    throw new Error(msg);\n  }\n}\n"],"names":["assert","condition","msg","Boolean","Error"],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,SAASA,OAAOC,SAAkB,EAAEC,GAAY;IACrD,IAAI,CAACC,QAAQF,YAAY;QACvB,MAAM,IAAIG,MAAMF;IAClB;AACF"}

package/dist/brand.d.ts

@@ -1,42 +1,45 @@
 declare const brand: unique symbol;
 /**
- * Adds a compile-time-only "brand" to a base type, producing a nominal type.
- * TypeScript's structural typing normally treats any two types with the same shape as
- * interchangeable, so a `UserId` and an `OrderId` that are both `string` can be passed to each
- * other's functions by mistake.
- * `Brand` closes that hole by attaching a unique, unused property to the type, so values of
- * different brands are no longer assignable to one another even though they share a base type.
- * The branded property does not exist at runtime — it is erased during compilation and only
- * affects type checking.
- *
- * Declare a custom branded type by aliasing `Brand` with a base type and a unique name:
- * ```ts
- * type UserId = Brand<string, 'UserId'>;
- * type OrderId = Brand<string, 'OrderId'>;
- * ```
- *
- * Because there is no runtime representation, values must be converted into a branded type with
- * a type assertion, typically inside a small constructor function that documents and centralizes
- * the conversion:
- * ```ts
- * function toUserId(id: string): UserId {
- *   return id as UserId;
- * }
- * ```
- *
- * Once created, a branded value can still be used wherever the base type is expected...
- * ```ts
- * function logId(id: string) {}
- * logId(toUserId('abc')); // OK, UserId is a string
- * ```
- * ...but the reverse requires an explicit conversion, and brands are not interchangeable:
- * ```ts
- * function getUser(id: UserId) {}
- * getUser('abc');             // Error, plain string is not a UserId
- * getUser(toOrderId('abc'));  // Error, OrderId is not a UserId
- * ```
- */
-export type Brand<Base, Name extends string> = Base & {
-    readonly [brand]: Name;
+* Adds a compile-time-only "brand" to a base type, producing a nominal type.
+* TypeScript's structural typing normally treats any two types with the same shape as
+* interchangeable, so a `UserId` and an `OrderId` that are both `string` can be passed to each
+* other's functions by mistake.
+* `Brand` closes that hole by attaching a unique, unused property to the type, so values of
+* different brands are no longer assignable to one another even though they share a base type.
+* The branded property does not exist at runtime — it is erased during compilation and only
+* affects type checking.
+*
+* Declare a custom branded type by aliasing `Brand` with a base type and a unique name:
+* ```ts
+* type UserId = Brand<string, 'UserId'>;
+* type OrderId = Brand<string, 'OrderId'>;
+* ```
+*
+* Because there is no runtime representation, values must be converted into a branded type with
+* a type assertion, typically inside a small constructor function that documents and centralizes
+* the conversion:
+* ```ts
+* function toUserId(id: string): UserId {
+*   return id as UserId;
+* }
+* ```
+*
+* Once created, a branded value can still be used wherever the base type is expected...
+* ```ts
+* function logId(id: string) {}
+* logId(toUserId('abc')); // OK, UserId is a string
+* ```
+* ...but the reverse requires an explicit conversion, and brands are not interchangeable:
+* ```ts
+* function getUser(id: UserId) {}
+* getUser('abc');             // Error, plain string is not a UserId
+* getUser(toOrderId('abc'));  // Error, OrderId is not a UserId
+* ```
+*/
+export type Brand<
+	Base,
+	Name extends string
+> = Base & {
+	readonly [brand]: Name;
 };
 export {};

package/dist/brand.js

@@ -0,0 +1,39 @@
+/**
+ * Adds a compile-time-only "brand" to a base type, producing a nominal type.
+ * TypeScript's structural typing normally treats any two types with the same shape as
+ * interchangeable, so a `UserId` and an `OrderId` that are both `string` can be passed to each
+ * other's functions by mistake.
+ * `Brand` closes that hole by attaching a unique, unused property to the type, so values of
+ * different brands are no longer assignable to one another even though they share a base type.
+ * The branded property does not exist at runtime — it is erased during compilation and only
+ * affects type checking.
+ *
+ * Declare a custom branded type by aliasing `Brand` with a base type and a unique name:
+ * ```ts
+ * type UserId = Brand<string, 'UserId'>;
+ * type OrderId = Brand<string, 'OrderId'>;
+ * ```
+ *
+ * Because there is no runtime representation, values must be converted into a branded type with
+ * a type assertion, typically inside a small constructor function that documents and centralizes
+ * the conversion:
+ * ```ts
+ * function toUserId(id: string): UserId {
+ *   return id as UserId;
+ * }
+ * ```
+ *
+ * Once created, a branded value can still be used wherever the base type is expected...
+ * ```ts
+ * function logId(id: string) {}
+ * logId(toUserId('abc')); // OK, UserId is a string
+ * ```
+ * ...but the reverse requires an explicit conversion, and brands are not interchangeable:
+ * ```ts
+ * function getUser(id: UserId) {}
+ * getUser('abc');             // Error, plain string is not a UserId
+ * getUser(toOrderId('abc'));  // Error, OrderId is not a UserId
+ * ```
+ */ export { };
+
+//# sourceMappingURL=brand.js.map

package/dist/brand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/brand.ts"],"sourcesContent":["declare const brand: unique symbol;\n\n/**\n * Adds a compile-time-only \"brand\" to a base type, producing a nominal type.\n * TypeScript's structural typing normally treats any two types with the same shape as\n * interchangeable, so a `UserId` and an `OrderId` that are both `string` can be passed to each\n * other's functions by mistake.\n * `Brand` closes that hole by attaching a unique, unused property to the type, so values of\n * different brands are no longer assignable to one another even though they share a base type.\n * The branded property does not exist at runtime — it is erased during compilation and only\n * affects type checking.\n *\n * Declare a custom branded type by aliasing `Brand` with a base type and a unique name:\n * ```ts\n * type UserId = Brand<string, 'UserId'>;\n * type OrderId = Brand<string, 'OrderId'>;\n * ```\n *\n * Because there is no runtime representation, values must be converted into a branded type with\n * a type assertion, typically inside a small constructor function that documents and centralizes\n * the conversion:\n * ```ts\n * function toUserId(id: string): UserId {\n *   return id as UserId;\n * }\n * ```\n *\n * Once created, a branded value can still be used wherever the base type is expected...\n * ```ts\n * function logId(id: string) {}\n * logId(toUserId('abc')); // OK, UserId is a string\n * ```\n * ...but the reverse requires an explicit conversion, and brands are not interchangeable:\n * ```ts\n * function getUser(id: UserId) {}\n * getUser('abc');             // Error, plain string is not a UserId\n * getUser(toOrderId('abc'));  // Error, OrderId is not a UserId\n * ```\n */\nexport type Brand<Base, Name extends string> = Base & {\n  readonly [brand]: Name;\n};\n"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCC,GACD,WAEE"}

package/dist/chunk-and-process-in-parallel.d.ts

@@ -1,112 +1,118 @@
 /**
- * Options for {@link chunkAndProcessInParallel}.
- */
+* Options for {@link chunkAndProcessInParallel}.
+*/
 export interface ChunkAndProcessOptions {
-    /**
-     * Maximum number of chunks to process in parallel.
-     * @default 10
-     */
-    numWorkers?: number;
+	/**
+	* Maximum number of chunks to process in parallel.
+	* @default 10
+	*/
+	numWorkers?: number;
 }
 /**
- * Error thrown when {@link chunkAndProcessInParallel} fails partway through processing.
- *
- * This error provides detailed information about which items were successfully processed,
- * which items failed, and which items were never attempted.
- *
- * @template T - The type of input elements.
- */
-export declare class PartialExecutionError<T, U> extends Error {
-    /**
-     * The underlying error that caused the failure.
-     */
-    readonly reason: Error;
-    /**
-     * Input items from chunks that were successfully processed before the error occurred.
-     */
-    readonly succeeded: T[];
-    /**
-     * Results from the chunks that were successfully processed before the error occurred.
-     */
-    readonly succeededResults: U[];
-    /**
-     * Input items from the chunk that failed and caused the error.
-     */
-    readonly failed: T[];
-    /**
-     * Input items from chunks that were never processed due to the error.
-     * This includes both chunks that were never started and chunks that were
-     * in-progress when the error occurred.
-     */
-    readonly unprocessed: T[];
-    constructor(reason: Error, succeeded: T[], succeededResults: U[], failed: T[], unprocessed: T[]);
+* Error thrown when {@link chunkAndProcessInParallel} fails partway through processing.
+*
+* This error provides detailed information about which items were successfully processed,
+* which items failed, and which items were never attempted.
+*
+* @template T - The type of input elements.
+*/
+export declare class PartialExecutionError<
+	T,
+	U
+> extends Error {
+	/**
+	* The underlying error that caused the failure.
+	*/
+	readonly reason: Error;
+	/**
+	* Input items from chunks that were successfully processed before the error occurred.
+	*/
+	readonly succeeded: T[];
+	/**
+	* Results from the chunks that were successfully processed before the error occurred.
+	*/
+	readonly succeededResults: U[];
+	/**
+	* Input items from the chunk that failed and caused the error.
+	*/
+	readonly failed: T[];
+	/**
+	* Input items from chunks that were never processed due to the error.
+	* This includes both chunks that were never started and chunks that were
+	* in-progress when the error occurred.
+	*/
+	readonly unprocessed: T[];
+	constructor(reason: Error, succeeded: T[], succeededResults: U[], failed: T[], unprocessed: T[]);
 }
 /**
- * Splits an array into chunks and processes each chunk in parallel using a callback function.
- *
- * This function is useful for batch processing large datasets where you want to:
- * - Limit the number of items processed at once (e.g., API limits)
- * - Process multiple chunks simultaneously for better performance
- * - Control the degree of parallelism to avoid overwhelming resources
- *
- * The function maintains a saturated queue up to `numWorkers` concurrent operations.
- * When one chunk completes, the next chunk starts immediately, ensuring optimal throughput.
- *
- * All chunks are processed with controlled parallelism, and the results are flattened into
- * a single array. If any chunk fails, the entire operation fails.
- * The order of the result is maintained regardless of the completion order of the
- * chunks, but not that there is no requirement that the callback must return one
- * result per input element (i.e. the number of result elements might differ from the
- * number of input elements).
- *
- * @template T - The type of elements in the input array.
- * @template U - The type of elements in the output array.
- * @param workItems - The array of items to process.
- * @param chunkSize - The maximum size of each chunk. Must be a positive integer.
- * @param performWorkCallback - An async function that processes a chunk and returns results.
- * @param options - Optional configuration for parallelism control.
- * @returns A promise that resolves to a flattened array of all results.
- * @throws {Error} If `chunkSize` is not a positive integer or `numWorkers` is not a positive integer.
- * @throws {PartialExecutionError} If `performWorkCallback` throws an error for any chunk, providing details about succeeded, failed, and unprocessed items.
- *
- * @example
- * ```ts
- * // Batch retrieve assets from CDF with controlled parallelism
- * const assetIds = [1, 2, 3, ..., 10000];
- * const assets = await chunkAndProcessInParallel(
- *   assetIds,
- *   1000, // Retrieve 1000 assets per request
- *   async (chunk) => {
- *     const response = await client.assets.retrieve(
- *       chunk.map(id => ({ id }))
- *     );
- *     return response;
- *   },
- *   { numWorkers: 5 } // Process at most 5 chunks concurrently
- * );
- * // Result: All assets from all chunks combined
- * ```
- *
- * @example
- * ```ts
- * // Handle partial execution errors
- * try {
- *   const results = await chunkAndProcessInParallel(
- *     largeDataset,
- *     100,
- *     async (chunk) => processChunk(chunk),
- *     { numWorkers: 3 }
- *   );
- * } catch (error) {
- *   if (error instanceof PartialExecutionError) {
- *     console.log(`Successfully processed ${error.succeeded.length} items`);
- *     console.log(`Failed to process ${error.failed.length} items`);
- *     console.log(`Did not attempt ${error.unprocessed.length} items`);
- *     console.error('Failure reason:', error.reason);
- *     // Optionally retry only the failed and unprocessed items
- *   }
- *   throw error;
- * }
- * ```
- */
-export declare function chunkAndProcessInParallel<T, U>(workItems: T[], chunkSize: number, performWorkCallback: (workItemsChunk: T[]) => Promise<U[]>, options?: ChunkAndProcessOptions): Promise<U[]>;
+* Splits an array into chunks and processes each chunk in parallel using a callback function.
+*
+* This function is useful for batch processing large datasets where you want to:
+* - Limit the number of items processed at once (e.g., API limits)
+* - Process multiple chunks simultaneously for better performance
+* - Control the degree of parallelism to avoid overwhelming resources
+*
+* The function maintains a saturated queue up to `numWorkers` concurrent operations.
+* When one chunk completes, the next chunk starts immediately, ensuring optimal throughput.
+*
+* All chunks are processed with controlled parallelism, and the results are flattened into
+* a single array. If any chunk fails, the entire operation fails.
+* The order of the result is maintained regardless of the completion order of the
+* chunks, but not that there is no requirement that the callback must return one
+* result per input element (i.e. the number of result elements might differ from the
+* number of input elements).
+*
+* @template T - The type of elements in the input array.
+* @template U - The type of elements in the output array.
+* @param workItems - The array of items to process.
+* @param chunkSize - The maximum size of each chunk. Must be a positive integer.
+* @param performWorkCallback - An async function that processes a chunk and returns results.
+* @param options - Optional configuration for parallelism control.
+* @returns A promise that resolves to a flattened array of all results.
+* @throws {Error} If `chunkSize` is not a positive integer or `numWorkers` is not a positive integer.
+* @throws {PartialExecutionError} If `performWorkCallback` throws an error for any chunk, providing details about succeeded, failed, and unprocessed items.
+*
+* @example
+* ```ts
+* // Batch retrieve assets from CDF with controlled parallelism
+* const assetIds = [1, 2, 3, ..., 10000];
+* const assets = await chunkAndProcessInParallel(
+*   assetIds,
+*   1000, // Retrieve 1000 assets per request
+*   async (chunk) => {
+*     const response = await client.assets.retrieve(
+*       chunk.map(id => ({ id }))
+*     );
+*     return response;
+*   },
+*   { numWorkers: 5 } // Process at most 5 chunks concurrently
+* );
+* // Result: All assets from all chunks combined
+* ```
+*
+* @example
+* ```ts
+* // Handle partial execution errors
+* try {
+*   const results = await chunkAndProcessInParallel(
+*     largeDataset,
+*     100,
+*     async (chunk) => processChunk(chunk),
+*     { numWorkers: 3 }
+*   );
+* } catch (error) {
+*   if (error instanceof PartialExecutionError) {
+*     console.log(`Successfully processed ${error.succeeded.length} items`);
+*     console.log(`Failed to process ${error.failed.length} items`);
+*     console.log(`Did not attempt ${error.unprocessed.length} items`);
+*     console.error('Failure reason:', error.reason);
+*     // Optionally retry only the failed and unprocessed items
+*   }
+*   throw error;
+* }
+* ```
+*/
+export declare function chunkAndProcessInParallel<
+	T,
+	U
+>(workItems: T[], chunkSize: number, performWorkCallback: (workItemsChunk: T[]) => Promise<U[]>, options?: ChunkAndProcessOptions): Promise<U[]>;