@oscarpalmer/atoms 0.184.2 → 0.185.0

package/dist/internal/value/misc.d.mts

@@ -2,9 +2,9 @@ import { Result } from "../../result/models.mjs";
 
 //#region src/internal/value/misc.d.ts
 declare function findKey(needle: string, haystack: object): string;
-declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, undefined>;
+declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, string>;
 declare function getPaths(path: string, lowercase: boolean): string | string[];
-declare function handleValue(data: object, path: string, value: unknown, get: true, ignoreCase: boolean): Result<unknown, undefined>;
+declare function handleValue(data: object, path: string, value: unknown, get: true, ignoreCase: boolean): Result<unknown, string>;
 declare function handleValue(data: object, path: string, value: unknown, get: false, ignoreCase: boolean): void;
 //#endregion
 export { findKey, getNestedValue, getPaths, handleValue };

package/dist/internal/value/misc.mjs

@@ -7,7 +7,8 @@ function findKey(needle, haystack) {
 	return index > -1 ? keys[index] : needle;
 }
 function getNestedValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return error(void 0);
+	if (typeof data !== "object" || data === null) return error(NESTED_MESSAGE_INPUT);
+	if (typeof path !== "string" || path.trim().length === 0) return error(NESTED_MESSAGE_PATH);
 	const shouldIgnoreCase = ignoreCase === true;
 	const paths = getPaths(path, shouldIgnoreCase);
 	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
@@ -27,15 +28,20 @@ function getPaths(path, lowercase) {
 	return normalized.replace(EXPRESSION_BRACKET, ".$1").replace(EXPRESSION_DOTS, "").split(".");
 }
 function handleValue(data, path, value, get, ignoreCase) {
-	if (typeof data === "object" && data !== null && !ignoreKey(path)) {
+	if (typeof data === "object" && data !== null) {
+		if (ignoreKey(path)) return error(NESTED_MESSAGE_UNSAFE);
 		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return key in data ? ok(data[key]) : error(void 0);
+		if (get) return key in data ? ok(data[key]) : error(NESTED_MESSAGE_MISSING);
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
-	if (get) return error(void 0);
+	if (get) return error(NESTED_MESSAGE_MISSING);
 }
 const EXPRESSION_BRACKET = /\[(\w+)\]/g;
 const EXPRESSION_DOTS = /^\.|\.$/g;
 const EXPRESSION_NESTED = /\.|\[\w+\]/;
+const NESTED_MESSAGE_INPUT = "Expected data to be an object";
+const NESTED_MESSAGE_MISSING = "Expected property to exist in object";
+const NESTED_MESSAGE_PATH = "Expected path to be a string";
+const NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
 //#endregion
 export { findKey, getNestedValue, getPaths, handleValue };

package/dist/logger.d.mts

@@ -1,4 +1,9 @@
 //#region src/logger.d.ts
+/**
+ * A logger that can be used to log messages to the console
+ *
+ * _(Logging can be enabled or disabled by setting the `enabled` property)_
+ */
 declare class Logger {
   /**
    * Log any number of values at the "debug" log level
@@ -47,8 +52,14 @@ declare class Logger {
    */
   time(label: string): Time;
 }
+/**
+ * A named timer that can be used to log durations to the console
+ */
 declare class Time {
   #private;
+  /**
+   * Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
+   */
   get active(): boolean;
   /**
    * Log the current duration of the timer _(ignored if logging is disabled)_

package/dist/logger.mjs

@@ -1,5 +1,10 @@
 import { noop } from "./internal/function/misc.mjs";
 //#region src/logger.ts
+/**
+* A logger that can be used to log messages to the console
+*
+* _(Logging can be enabled or disabled by setting the `enabled` property)_
+*/
 var Logger = class {
 	/**
 	* Log any number of values at the "debug" log level
@@ -70,10 +75,16 @@ var Logger = class {
 		return new Time(label);
 	}
 };
+/**
+* A named timer that can be used to log durations to the console
+*/
 var Time = class {
 	#logger;
 	#stopper;
 	#state;
+	/**
+	* Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
+	*/
 	get active() {
 		return this.#state.started && !this.#state.stopped && enabled;
 	}

package/dist/promise/helpers.mjs

@@ -1,5 +1,5 @@
-import { getNumberOrDefault } from "../internal/number.mjs";
 import { error, ok } from "../result/misc.mjs";
+import { getNumberOrDefault } from "../internal/number.mjs";
 import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./models.mjs";
 //#region src/promise/helpers.ts
 function getPromiseOptions(input) {

package/dist/promise/index.d.mts

@@ -4,8 +4,6 @@ import { PromiseOptions, PromisesItems, PromisesOptions, PromisesResult, Promise
 //#region src/promise/index.d.ts
 /**
  * Wrap a promise with safety handlers, with optional abort capabilities and timeout
- *
- * Available as `attemptPromise` and `attempt.promise`
  * @param promise Promise to wrap
  * @param options Options for the promise
  * @returns Wrapped promise
@@ -13,8 +11,6 @@ import { PromiseOptions, PromisesItems, PromisesOptions, PromisesResult, Promise
 declare function attemptPromise<Value>(promise: Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
 /**
  * Wrap a promise-returning callback with safety handlers, with optional abort capabilities and timeout
- *
- * Available as `attemptPromise` and `attempt.promise`
  * @param callback Callback to wrap
  * @param options Options for the promise
  * @returns Promise-wrapped callback
@@ -22,8 +18,6 @@ declare function attemptPromise<Value>(promise: Promise<Value>, options?: Promis
 declare function attemptPromise<Value>(callback: () => Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
 /**
  * Wrap a callback with a promise and safety handlers, with optional abort capabilities and timeout
- *
- * Available as `attemptPromise` and `attempt.promise`
  * @param callback Callback to wrap
  * @param options Options for the promise
  * @returns Promise-wrapped callback

package/dist/promise/models.d.mts

@@ -2,6 +2,9 @@ import { GenericCallback } from "../models.mjs";
 import { Result } from "../result/models.mjs";
 
 //#region src/promise/models.d.ts
+/**
+ * A promise that can be canceled
+ */
 declare class CancelablePromise<Value = void> extends Promise<Value> {
   #private;
   constructor(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void);
@@ -11,8 +14,17 @@ declare class CancelablePromise<Value = void> extends Promise<Value> {
    */
   cancel(reason?: unknown): void;
 }
+/**
+ * A promise that was fulfilled
+ */
 type FulfilledPromise<Value> = {
+  /**
+   * Status of the promise
+   */
   status: typeof PROMISE_TYPE_FULFILLED;
+  /**
+   * Value of the promise
+   */
   value: Awaited<Value>;
 };
 type PromiseData = {
@@ -23,6 +35,9 @@ type PromiseHandlers = {
   resolve: (value: unknown[]) => void;
   reject: (reason: unknown) => void;
 };
+/**
+ * Options for a promise-handling function
+ */
 type PromiseOptions = {
   /**
    * AbortSignal for aborting the promise; when aborted, the promise will reject with the reason of the signal
@@ -51,20 +66,41 @@ type PromiseParameters = {
  * 	- Returns an array of values
  */
 type PromiseStrategy = 'complete' | 'first';
+/**
+ * An error thrown when a promise times out
+ */
 declare class PromiseTimeoutError extends Error {
   constructor();
 }
 type PromisesItems<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]> };
+/**
+ * Options for handling multiple promises
+ */
 type PromisesOptions = {
+  /**
+   * AbortSignal for aborting the promises; when aborted, the promises will reject with the reason of the signal
+   */
   signal?: AbortSignal;
+  /**
+   * Strategy for handling the promises; defaults to `complete`
+   */
   strategy?: PromiseStrategy;
 };
 type PromisesResult<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never };
 type PromisesUnwrapped<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never };
 type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
 type PromisesValues<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never : Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never };
+/**
+ * A promise that was rejected
+ */
 type RejectedPromise = {
+  /**
+   * Status of the promise
+   */
   status: typeof PROMISE_TYPE_REJECTED;
+  /**
+   * Reason for the rejection
+   */
   reason: unknown;
 };
 declare const PROMISE_ABORT_EVENT = "abort";

package/dist/promise/models.mjs

@@ -1,4 +1,7 @@
 //#region src/promise/models.ts
+/**
+* A promise that can be canceled
+*/
 var CancelablePromise = class extends Promise {
 	#rejector;
 	constructor(executor) {
@@ -17,6 +20,9 @@ var CancelablePromise = class extends Promise {
 		this.#rejector(reason);
 	}
 };
+/**
+* An error thrown when a promise times out
+*/
 var PromiseTimeoutError = class extends Error {
 	constructor() {
 		super(PROMISE_MESSAGE_TIMEOUT);

package/dist/queue.d.mts

@@ -1,6 +1,9 @@
 import { GenericAsyncCallback, GenericCallback } from "./models.mjs";
 
 //#region src/queue.d.ts
+/**
+ * A queue that can be used to manage (a)synchronous tasks with a specific key
+ */
 declare class KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> {
   #private;
   /**
@@ -91,6 +94,9 @@ declare class KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallb
    */
   resume(key?: string): void;
 }
+/**
+ * A queue that can be used to manage (a)synchronous tasks
+ */
 declare class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> {
   #private;
   /**
@@ -154,6 +160,9 @@ declare class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>,
    */
   resume(): void;
 }
+/**
+ * An error thrown by the Queue when an operation fails
+ */
 declare class QueueError extends Error {
   constructor(message: string);
 }
@@ -171,9 +180,12 @@ type QueueOptions = {
    */
   maximum?: number;
 };
+/**
+ * A queued item
+ */
 type Queued<Value> = {
   /**
-   * ID of the queued promise _(can be used to remove it from the queue)_
+   * ID of the queued item _(can be used to remove it from the queue)_
    */
   readonly id: number;
   /**

package/dist/queue.mjs

@@ -1,5 +1,8 @@
 import { getNumberOrDefault } from "./internal/number.mjs";
 //#region src/queue.ts
+/**
+* A queue that can be used to manage (a)synchronous tasks with a specific key
+*/
 var KeyedQueue = class {
 	#callback;
 	#options;
@@ -149,6 +152,9 @@ var KeyedQueue = class {
 		for (const queue of queues) queue[type]();
 	}
 };
+/**
+* A queue that can be used to manage (a)synchronous tasks
+*/
 var Queue = class {
 	#callback;
 	#handled = [];
@@ -326,6 +332,9 @@ var Queue = class {
 		this.#runners -= 1;
 	}
 };
+/**
+* An error thrown by the Queue when an operation fails
+*/
 var QueueError = class extends Error {
 	constructor(message) {
 		super(message);

package/dist/result/index.d.mts

@@ -1,8 +1,4 @@
 import { ExtendedResult, Result } from "./models.mjs";
-import { attemptPromise } from "../promise/index.mjs";
-import { matchResult } from "./match.mjs";
-import { attemptFlow } from "./work/flow.mjs";
-import { attemptPipe } from "./work/pipe.mjs";
 
 //#region src/result/index.d.ts
 /**
@@ -54,10 +50,6 @@ declare function attempt<Value, E>(callback: () => Value, error: E): ExtendedRes
 declare function attempt<Value>(callback: () => Value): Result<Value, Error>;
 declare namespace attempt {
   var async: typeof asyncAttempt;
-  var flow: typeof attemptFlow;
-  var match: typeof matchResult;
-  var pipe: typeof attemptPipe;
-  var promise: typeof attemptPromise;
 }
 //#endregion
 export { asyncAttempt, attempt };

package/dist/result/index.mjs

@@ -1,8 +1,4 @@
 import { getError, ok } from "./misc.mjs";
-import { attemptPromise } from "../promise/index.mjs";
-import { matchResult } from "./match.mjs";
-import { attemptFlow } from "./work/flow.mjs";
-import { attemptPipe } from "./work/pipe.mjs";
 //#region src/result/index.ts
 async function asyncAttempt(value, err) {
 	try {
@@ -21,9 +17,5 @@ function attempt(callback, err) {
 	}
 }
 attempt.async = asyncAttempt;
-attempt.flow = attemptFlow;
-attempt.match = matchResult;
-attempt.pipe = attemptPipe;
-attempt.promise = attemptPromise;
 //#endregion
 export { asyncAttempt, attempt };

package/dist/result/match.d.mts

@@ -3,12 +3,16 @@ import { AnyResult, ResultMatch } from "./models.mjs";
 //#region src/result/match.d.ts
 /**
  * Handles a result with match callbacks
+ *
+ * Available as `asyncMatchResult` and `matchResult.async`
  * @param result Result to handle
  * @param handler Match callbacks
  */
 declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | Promise<AnyResult<Value, E>> | (() => Promise<AnyResult<Value, E>>), handler: ResultMatch<Value, Returned, E>): Promise<Returned>;
 /**
  * Handles a result with match callbacks
+ *
+ * Available as `asyncMatchResult` and `matchResult.async`
  * @param result Result to handle
  * @param ok Ok callback
  * @param error Error callback
@@ -16,16 +20,12 @@ declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<
 declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | Promise<AnyResult<Value, E>> | (() => Promise<AnyResult<Value, E>>), ok: ResultMatch<Value, Returned, E>['ok'], error: ResultMatch<Value, Returned, E>['error']): Promise<Returned>;
 /**
  * Handles a result with match callbacks
- *
- * Available as `matchResult` and `attempt.match`
  * @param result Result to handle
  * @param handler Match callbacks
  */
 declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), handler: ResultMatch<Value, Returned, E>): Returned;
 /**
  * Handles a result with match callbacks
- *
- * Available as `matchResult` and `attempt.match`
  * @param result Result to handle
  * @param ok Ok callback
  * @param error Error callback

package/dist/result/work/flow.d.mts

@@ -13,168 +13,144 @@ type AttemptFlowPromise<Callback extends GenericCallback, Value> = (...args: Par
 /**
  * Create an asynchronous Flow, a function that attempts to pipe a value through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<Fn extends GenericCallback>(fn: Fn): AttemptFlowPromise<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second): AttemptFlowPromise<First, Second>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third): AttemptFlowPromise<First, Third>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth): AttemptFlowPromise<First, Fourth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth): AttemptFlowPromise<First, Fifth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth): AttemptFlowPromise<First, Sixth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh): AttemptFlowPromise<First, Seventh>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth): AttemptFlowPromise<First, Eighth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth): AttemptFlowPromise<First, Ninth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth, tenth: (value: Awaited<UnwrapValue<Ninth>>) => Tenth): AttemptFlowPromise<First, Tenth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<Fn extends GenericCallback>(fn: Fn, ...fns: Array<(value: Awaited<UnwrapValue<ReturnType<Fn>>>) => unknown>): AttemptFlowPromise<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
  *
- * Available as `attemptAsyncFlow` and `attempt.flow.async`
+ * Available as `attemptAsyncFlow` and `attemptFlow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow(...fns: GenericCallback[]): (...args: unknown[]) => Promise<Result<unknown>>;
 /**
  * Create a Flow, a function that attempts to pipe values through a function
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<Fn extends GenericCallback>(fn: Fn): AttemptFlow<Fn, ReturnType<Fn>>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second): AttemptFlow<First, Second>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third): AttemptFlow<First, Third>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth): AttemptFlow<First, Fourth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth): AttemptFlow<First, Fifth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth): AttemptFlow<First, Sixth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh): AttemptFlow<First, Seventh>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth): AttemptFlow<First, Eighth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth): AttemptFlow<First, Ninth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth, tenth: (value: UnwrapValue<Ninth>) => Tenth): AttemptFlow<First, Tenth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback>(first: First, ...fns: Array<(value: UnwrapValue<ReturnType<First>>) => unknown>): AttemptFlow<First, ReturnType<First>>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
- *
- * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow(...fns: GenericCallback[]): (...args: unknown[]) => Result<unknown>;