@oscarpalmer/atoms 0.193.1 → 0.195.0

package/dist/internal/abort.d.mts

@@ -0,0 +1,10 @@
+import { GenericCallback } from "../models.mjs";
+//#region src/internal/abort.d.ts
+type Aborter = {
+  callback: GenericCallback;
+  signal: AbortSignal;
+  cancel: () => void;
+};
+declare function createAborter(value: unknown, onAbort: () => void): Aborter | undefined;
+//#endregion
+export { Aborter, createAborter };

package/dist/internal/abort.mjs

@@ -0,0 +1,14 @@
+//#region src/internal/abort.ts
+function createAborter(value, onAbort) {
+	if (!(value instanceof AbortSignal)) return;
+	value.addEventListener(ABORT_EVENT, onAbort, ABORT_OPTIONS);
+	return {
+		callback: onAbort,
+		signal: value,
+		cancel: () => value.removeEventListener(ABORT_EVENT, onAbort)
+	};
+}
+const ABORT_EVENT = "abort";
+const ABORT_OPTIONS = { once: true };
+//#endregion
+export { createAborter };

package/dist/internal/array/chunk.mjs

@@ -15,7 +15,7 @@ function chunk(array, size) {
 	if (!Array.isArray(array)) return [];
 	if (array.length === 0) return [];
 	const { length } = array;
-	const actualSize = typeof size === "number" && size > 0 && size <= MAX_SIZE ? size : MAX_SIZE;
+	const actualSize = typeof size === "number" && size > 0 && size <= CHUNK_MAX_SIZE ? size : CHUNK_MAX_SIZE;
 	if (length <= actualSize) return [array];
 	const chunks = [];
 	let index = 0;
@@ -25,6 +25,6 @@ function chunk(array, size) {
 	}
 	return chunks;
 }
-const MAX_SIZE = 5e3;
+const CHUNK_MAX_SIZE = 5e3;
 //#endregion
 export { chunk };

package/dist/internal/array/find.mjs

@@ -40,7 +40,7 @@ function findValues(type, array, parameters, mapper) {
 	const { length } = array;
 	const { bool, key, value } = getFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (type === "unique" && callbacks?.keyed == null && length >= UNIQUE_THRESHOLD) {
+	if (type === "unique" && callbacks?.keyed == null && length >= FIND_UNIQUE_THRESHOLD) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
@@ -77,6 +77,6 @@ const FIND_VALUE_INDEX = "index";
 const FIND_VALUE_ITEM = "item";
 const FIND_VALUES_ALL = "all";
 const FIND_VALUES_UNIQUE = "unique";
-const UNIQUE_THRESHOLD = 100;
+const FIND_UNIQUE_THRESHOLD = 100;
 //#endregion
 export { FIND_VALUES_ALL, FIND_VALUES_UNIQUE, FIND_VALUE_INDEX, FIND_VALUE_ITEM, findAbsoluteValueOrDefault, findValue, findValues, getFindParameters };

package/dist/{array → internal/array}/get.d.mts

@@ -1,5 +1,5 @@
-import { NumericalKeys, PlainObject } from "../models.mjs";
-//#region src/array/get.d.ts
+import { NumericalKeys, PlainObject } from "../../models.mjs";
+//#region src/internal/array/get.d.ts
 /**
  * Get an array from an object, where only values with numerical keys will be included
  *

package/dist/{array → internal/array}/get.mjs

@@ -1,5 +1,5 @@
-import { isNonPlainObject } from "../internal/is.mjs";
-//#region src/array/get.ts
+import { isNonPlainObject } from "../is.mjs";
+//#region src/internal/array/get.ts
 function getArray(value, indiced) {
 	if (Array.isArray(value)) return value;
 	if (value instanceof Map) return [...value.entries()];

package/dist/{array → internal/array}/match.d.mts

@@ -1,5 +1,5 @@
-import { PlainObject } from "../models.mjs";
-//#region src/array/match.d.ts
+import { PlainObject } from "../../models.mjs";
+//#region src/internal/array/match.d.ts
 /**
  * Comparison of an array within another array
  */

package/dist/{array → internal/array}/match.mjs

@@ -1,5 +1,5 @@
-import { getArrayCallback } from "../internal/array/callbacks.mjs";
-//#region src/array/match.ts
+import { getArrayCallback } from "./callbacks.mjs";
+//#region src/internal/array/match.ts
 function endsWithArray(haystack, needle, key) {
 	return endings.has(getPosition(haystack, needle, key)[1]);
 }
@@ -7,8 +7,8 @@ function getArrayComparison(haystack, needle, key) {
 	return getPosition(haystack, needle, key)[1];
 }
 function getName(start, haystack, needle) {
-	if (start === 0) return haystack === needle ? COMPARISON_SAME : COMPARISON_START;
-	return start + needle === haystack ? COMPARISON_END : COMPARISON_INSIDE;
+	if (start === 0) return haystack === needle ? MATCH_COMPARISON_SAME : MATCH_COMPARISON_START;
+	return start + needle === haystack ? MATCH_COMPARISON_END : MATCH_COMPARISON_INSIDE;
 }
 function getPosition(haystack, needle, key) {
 	if (!Array.isArray(haystack) || !Array.isArray(needle)) return invalid;
@@ -43,16 +43,16 @@ function indexOfArray(haystack, needle, key) {
 function startsWithArray(haystack, needle, key) {
 	return starts.has(getPosition(haystack, needle, key)[1]);
 }
-const COMPARISON_END = "end";
-const COMPARISON_INSIDE = "inside";
-const COMPARISON_INVALID = "invalid";
-const COMPARISON_OUTSIDE = "outside";
-const COMPARISON_SAME = "same";
-const COMPARISON_START = "start";
-const endings = /* @__PURE__ */ new Set([COMPARISON_END, COMPARISON_SAME]);
-const invalid = [-1, COMPARISON_INVALID];
-const outside = [-1, COMPARISON_OUTSIDE];
-const outsides = /* @__PURE__ */ new Set([COMPARISON_INVALID, COMPARISON_OUTSIDE]);
-const starts = /* @__PURE__ */ new Set([COMPARISON_START, COMPARISON_SAME]);
+const MATCH_COMPARISON_END = "end";
+const MATCH_COMPARISON_INSIDE = "inside";
+const MATCH_COMPARISON_INVALID = "invalid";
+const MATCH_COMPARISON_OUTSIDE = "outside";
+const MATCH_COMPARISON_SAME = "same";
+const MATCH_COMPARISON_START = "start";
+const endings = /* @__PURE__ */ new Set([MATCH_COMPARISON_END, MATCH_COMPARISON_SAME]);
+const invalid = [-1, MATCH_COMPARISON_INVALID];
+const outside = [-1, MATCH_COMPARISON_OUTSIDE];
+const outsides = /* @__PURE__ */ new Set([MATCH_COMPARISON_INVALID, MATCH_COMPARISON_OUTSIDE]);
+const starts = /* @__PURE__ */ new Set([MATCH_COMPARISON_START, MATCH_COMPARISON_SAME]);
 //#endregion
 export { endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray };

package/dist/internal/array/sets.d.mts

@@ -1,8 +1,8 @@
 //#region src/internal/array/sets.d.ts
 type CompareSetsType = 'difference' | 'intersection' | 'union';
 declare function compareSets(type: CompareSetsType, first: unknown[], second: unknown[], key?: unknown): unknown[];
-declare const COMPARE_SETS_DIFFERENCE: CompareSetsType;
-declare const COMPARE_SETS_INTERSECTION: CompareSetsType;
-declare const COMPARE_SETS_UNION: CompareSetsType;
+declare const SETS_COMPARE_DIFFERENCE: CompareSetsType;
+declare const SETS_COMPARE_INTERSECTION: CompareSetsType;
+declare const SETS_COMPARE_UNION: CompareSetsType;
 //#endregion
-export { COMPARE_SETS_DIFFERENCE, COMPARE_SETS_INTERSECTION, COMPARE_SETS_UNION, compareSets };
+export { SETS_COMPARE_DIFFERENCE, SETS_COMPARE_INTERSECTION, SETS_COMPARE_UNION, compareSets };

package/dist/internal/array/sets.mjs

@@ -2,9 +2,9 @@ import { getArrayCallback } from "./callbacks.mjs";
 //#region src/internal/array/sets.ts
 function compareSets(type, first, second, key) {
 	if (!Array.isArray(first)) return [];
-	const isDifference = type === COMPARE_SETS_DIFFERENCE;
-	const isIntersection = type === COMPARE_SETS_INTERSECTION;
-	const isUnion = type === COMPARE_SETS_UNION;
+	const isDifference = type === SETS_COMPARE_DIFFERENCE;
+	const isIntersection = type === SETS_COMPARE_INTERSECTION;
+	const isUnion = type === SETS_COMPARE_UNION;
 	if (first.length === 0) return isDifference ? first.slice() : isIntersection ? [] : second.slice();
 	if (!Array.isArray(second) || second.length === 0) return isIntersection ? [] : first.slice();
 	const callback = getArrayCallback(key);
@@ -25,8 +25,8 @@ function compareSets(type, first, second, key) {
 	}
 	return result;
 }
-const COMPARE_SETS_DIFFERENCE = "difference";
-const COMPARE_SETS_INTERSECTION = "intersection";
-const COMPARE_SETS_UNION = "union";
+const SETS_COMPARE_DIFFERENCE = "difference";
+const SETS_COMPARE_INTERSECTION = "intersection";
+const SETS_COMPARE_UNION = "union";
 //#endregion
-export { COMPARE_SETS_DIFFERENCE, COMPARE_SETS_INTERSECTION, COMPARE_SETS_UNION, compareSets };
+export { SETS_COMPARE_DIFFERENCE, SETS_COMPARE_INTERSECTION, SETS_COMPARE_UNION, compareSets };

package/dist/internal/defaults.d.mts

@@ -0,0 +1,5 @@
+//#region src/internal/defaults.d.ts
+declare function getBooleanOrDefault(value: unknown, defaultValue: boolean): boolean;
+declare function getNumberOrDefault(value: unknown, defaultValue: number, minimum?: number): number;
+//#endregion
+export { getBooleanOrDefault, getNumberOrDefault };

package/dist/internal/defaults.mjs

@@ -0,0 +1,9 @@
+//#region src/internal/defaults.ts
+function getBooleanOrDefault(value, defaultValue) {
+	return typeof value === "boolean" ? value : defaultValue;
+}
+function getNumberOrDefault(value, defaultValue, minimum) {
+	return typeof value === "number" && !Number.isNaN(value) && value >= (minimum ?? 0) ? value : defaultValue;
+}
+//#endregion
+export { getBooleanOrDefault, getNumberOrDefault };

package/dist/{function → internal/function}/assert.d.mts

@@ -1,5 +1,5 @@
-import { Constructor, NestedKeys, NestedValue, PlainObject } from "../models.mjs";
-//#region src/function/assert.d.ts
+import { Constructor, NestedKeys, NestedValue, PlainObject } from "../../models.mjs";
+//#region src/internal/function/assert.d.ts
 /**
  * Asserter for a property of a value
  */

package/dist/{function → internal/function}/assert.mjs

@@ -1,5 +1,5 @@
-import { hasValueResult } from "../internal/value/has.mjs";
-//#region src/function/assert.ts
+import { hasValueResult } from "../value/has.mjs";
+//#region src/internal/function/assert.ts
 /**
 * Asserts that a condition is true, throwing an error if it is not
 *
@@ -40,7 +40,7 @@ function assertCondition(condition, message, error) {
 * @param error Error constructor _(defaults to `Error`)_
 */
 function assertDefined(value, message, error) {
-	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED, error);
+	assert(() => value != null, message ?? ASSERT_MESSAGE_VALUE_DEFINED, error);
 }
 /**
 * Creates an _Asserter_ that asserts a value is an instance of a constructor, throwing an error if it is not
@@ -91,6 +91,6 @@ function assertProperty(path, condition, message, error) {
 		}, message, error);
 	};
 }
-const MESSAGE_VALUE_DEFINED = "Expected value to be defined";
+const ASSERT_MESSAGE_VALUE_DEFINED = "Expected value to be defined";
 //#endregion
 export { assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty };

package/dist/{function → internal/function}/memoize.d.mts

@@ -1,5 +1,5 @@
-import { GenericCallback } from "../models.mjs";
-//#region src/function/memoize.d.ts
+import { GenericCallback } from "../../models.mjs";
+//#region src/internal/function/memoize.d.ts
 /**
  * A _Memoized_ function instance, caching and retrieving results based on the its parameters _(or a custom cache key)_
  */

package/dist/{function → internal/function}/memoize.mjs

@@ -1,12 +1,12 @@
-import { isPlainObject } from "../internal/is.mjs";
-import { getString, join } from "../internal/string.mjs";
+import { isPlainObject } from "../is.mjs";
+import { getString, join } from "../string/misc.mjs";
 import { SizedMap } from "../sized/map.mjs";
-//#region src/function/memoize.ts
+//#region src/internal/function/memoize.ts
 function getMemoizationOptions(input) {
 	const { cacheKey, cacheSize } = isPlainObject(input) ? input : {};
 	return {
 		cacheKey: typeof cacheKey === "function" ? cacheKey : void 0,
-		cacheSize: typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : DEFAULT_CACHE_SIZE
+		cacheSize: typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : MEMOIZED_CACHE_SIZE_DEFAULT
 	};
 }
 /**
@@ -17,54 +17,41 @@ function getMemoizationOptions(input) {
 * @returns _Memoized_ instance
 */
 function memoize(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(MEMOIZED_ERROR_CALLBACK);
-	const state = { options: getMemoizationOptions(options) };
+	if (typeof callback !== "function") throw new TypeError(MEMOIZED_CALLBACK);
+	const state = {
+		cache: void 0,
+		getter: void 0,
+		options: getMemoizationOptions(options)
+	};
 	state.cache = new SizedMap(state.options.cacheSize);
 	state.getter = (...parameters) => {
-		const key = state.options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), SEPARATOR));
+		const key = state.options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), MEMOIZED_KEY_SEPARATOR));
 		if (state.cache.has(key)) return state.cache.get(key);
 		const value = callback(...parameters);
-		state.cache?.set(key, value);
+		state.cache.set(key, value);
 		return value;
 	};
 	const instance = {
-		clear: () => {
-			state.cache?.clear();
-		},
-		delete: (key) => {
-			return state.cache?.delete(key) ?? false;
-		},
-		destroy: () => {
-			state.cache?.clear();
-			state.cache = void 0;
-			state.getter = void 0;
-		},
-		get: (key) => {
-			return state.cache?.get(key);
-		},
-		has: (key) => {
-			return state.cache?.has(key) ?? false;
-		},
-		run: (...parameters) => {
-			if (state.cache == null || state.getter == null) throw new Error(MEMOIZED_ERROR_DESTROYED);
-			return state.getter(...parameters);
-		}
+		clear: () => state.cache.clear(),
+		delete: (key) => state.cache.delete(key),
+		get: (key) => state.cache.get(key),
+		has: (key) => state.cache.has(key),
+		run: (...parameters) => state.getter(...parameters)
 	};
 	Object.defineProperties(instance, {
 		maximum: {
 			enumerable: true,
-			get: () => state.cache?.maximum ?? NaN
+			get: () => state.cache.maximum
 		},
 		size: {
 			enumerable: true,
-			get: () => state.cache?.size ?? NaN
+			get: () => state.cache.size
 		}
 	});
 	return Object.freeze(instance);
 }
-const DEFAULT_CACHE_SIZE = 1024;
-const MEMOIZED_ERROR_CALLBACK = "Memoized requires a callback function";
-const MEMOIZED_ERROR_DESTROYED = "The Memoized instance has been destroyed";
-const SEPARATOR = "_";
+const MEMOIZED_CACHE_SIZE_DEFAULT = 1024;
+const MEMOIZED_CALLBACK = "Memoized requires a callback function";
+const MEMOIZED_KEY_SEPARATOR = "_";
 //#endregion
 export { memoize };

package/dist/internal/function/timer.mjs

@@ -1,9 +1,16 @@
 //#region src/internal/function/timer.ts
 function getAsyncTimer(type, callback, time) {
+	function cancel() {
+		clearTimer(id);
+		if (last != null && !last.running) {
+			last.reject();
+			last = void 0;
+		}
+	}
 	async function run(item) {
 		const now = performance.now();
 		start ??= now;
-		if (interval === 0 || now - start >= interval - OFFSET) {
+		if (interval === 0 || now - start >= interval - TIMER_OFFSET) {
 			start = throttle ? now : void 0;
 			item.running = true;
 			try {
@@ -23,7 +30,7 @@ function getAsyncTimer(type, callback, time) {
 	let last;
 	let start;
 	const timer = (...parameters) => {
-		timer.cancel();
+		cancel();
 		const next = {
 			parameters,
 			running: false
@@ -34,25 +41,23 @@ function getAsyncTimer(type, callback, time) {
 		});
 		last = next;
 		if (throttle) run(next);
-		else id = startTimer(() => {
-			run(next);
-		});
+		else id = startTimer(() => run(next));
 		return next.promise;
 	};
-	timer.cancel = () => {
-		clearTimer(id);
-		if (last != null && !last.running) last.reject();
-	};
+	Object.defineProperty(timer, TIMER_CANCEL, { value: () => cancel() });
 	return timer;
 }
 function getInterval(value) {
 	return typeof value === "number" && value > 0 ? value : 0;
 }
 function getTimer(type, callback, time) {
+	function cancel() {
+		clearTimer(id);
+	}
 	function run() {
 		const now = performance.now();
 		start ??= now;
-		if (interval === 0 || now - start >= interval - OFFSET) {
+		if (interval === 0 || now - start >= interval - TIMER_OFFSET) {
 			start = throttle ? now : void 0;
 			callback(...args);
 		} else id = startTimer(run);
@@ -63,18 +68,17 @@ function getTimer(type, callback, time) {
 	let id;
 	let start;
 	const timer = (...parameters) => {
-		timer.cancel();
+		cancel();
 		args = parameters;
 		if (throttle) run();
 		else id = startTimer(run);
 	};
-	timer.cancel = () => {
-		clearTimer(id);
-	};
+	Object.defineProperty(timer, TIMER_CANCEL, { value: () => cancel() });
 	return timer;
 }
-const OFFSET = 5;
+const TIMER_CANCEL = "cancel";
 const TIMER_DEBOUNCE = "debounce";
+const TIMER_OFFSET = 5;
 const TIMER_THROTTLE = "throttle";
 const TIMER_WAIT = "wait";
 // istanbul ignore next

package/dist/{function → internal/function}/work.d.mts

@@ -1,6 +1,6 @@
-import { GenericCallback } from "../models.mjs";
+import { GenericCallback } from "../../models.mjs";
 import { UnwrapValue } from "../result/models.mjs";
-//#region src/function/work.d.ts
+//#region src/internal/function/work.d.ts
 /**
  * A synchronous _Flow_, a function that pipe a value through a series of functions
  */

package/dist/{function → internal/function}/work.mjs

@@ -1,6 +1,6 @@
-import { isError, isOk } from "../internal/result.mjs";
+import { isError, isOk } from "../result/misc.mjs";
 import { assert } from "./assert.mjs";
-//#region src/function/work.ts
+//#region src/internal/function/work.ts
 function asyncFlow(...fns) {
 	assertFlowFunctions(fns);
 	return (...args) => asyncWork(args.map((value) => {
@@ -15,7 +15,6 @@ function flow(...fns) {
 		return isOk(value) ? value.value : value;
 	}), fns, true);
 }
-flow.async = asyncFlow;
 async function asyncPipe(value, ...pipes) {
 	assertPipeFunctions(pipes);
 	return asyncWork(value, pipes, false);
@@ -24,7 +23,6 @@ function pipe(value, ...pipes) {
 	assertPipeFunctions(pipes);
 	return work(value, pipes, false);
 }
-pipe.async = asyncPipe;
 async function asyncWork(initial, functions, flow) {
 	const { length } = functions;
 	let transformed = unwrapValue(initial);
@@ -36,10 +34,10 @@ async function asyncWork(initial, functions, flow) {
 }
 function unwrapValue(value, flow, nested) {
 	if (typeof value === "function") {
-		if (nested != null) throw new TypeError(MESSAGE_NESTING);
+		if (nested != null) throw new TypeError(WORK_MESSAGE_NESTING);
 		return unwrapValue(value(), flow, true);
 	}
-	if (flow != null && value instanceof Promise) throw new TypeError(flow ? MESSAGE_FLOW_PROMISE : MESSAGE_PIPE_PROMISE);
+	if (flow != null && value instanceof Promise) throw new TypeError(flow ? WORK_MESSAGE_FLOW_PROMISE : WORK_MESSAGE_PIPE_PROMISE);
 	if (isError(value)) throw value.error;
 	return isOk(value) ? value.value : value;
 }
@@ -52,12 +50,16 @@ function work(initial, functions, flow) {
 	}
 	return transformed;
 }
-const MESSAGE_FLOW_ARRAY = "Flow expected to receive an array of functions";
-const MESSAGE_FLOW_PROMISE = "Synchronous Flow received a promise. Use `flow.async` instead.";
-const MESSAGE_NESTING = "Return values are too deeply nested.";
-const MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions";
-const MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
-const assertFlowFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_FLOW_ARRAY, TypeError);
-const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_PIPE_ARRAY, TypeError);
+const WORK_MESSAGE_FLOW_ARRAY = "Flow expected to receive an array of functions";
+const WORK_MESSAGE_FLOW_PROMISE = "Synchronous Flow received a promise. Use `flow.async` instead.";
+const WORK_MESSAGE_NESTING = "Return values are too deeply nested.";
+const WORK_MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions";
+const WORK_MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
+const assertFlowFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_FLOW_ARRAY, TypeError);
+const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_PIPE_ARRAY, TypeError);
+flow.async = asyncFlow;
+pipe.async = asyncPipe;
+Object.defineProperty(flow, "async", { value: asyncFlow });
+Object.defineProperty(pipe, "async", { value: asyncPipe });
 //#endregion
 export { asyncFlow, asyncPipe, flow, pipe };

package/dist/internal/herald.d.mts

@@ -0,0 +1,71 @@
+import { GenericCallback } from "../models.mjs";
+import { Subscription, SubscriptionProperty } from "./subscription.mjs";
+//#region src/internal/herald.d.ts
+type Herald<Events extends Record<string, GenericCallback>> = {
+  readonly events: HeraldEvents<Events>;
+  /**
+   * Remove all event subscribers
+   */
+  clear(): void;
+  /**
+   * Emit an event with parameters
+   *
+   * @param event Event name
+   * @param parameters Event parameters
+   */
+  emit<Event extends keyof Events>(event: Event, ...parameters: Parameters<Events[Event]>): void;
+  /**
+   * Is the event observed by any subscribers?
+   *
+   * @param event Event name
+   * @returns `true` if the event is observed, otherwise `false`
+   */
+  observed<Event extends keyof Events>(event: Event): boolean;
+  /**
+   * Subscribe to an event with a callback
+   *
+   * @param event Event name
+   * @param callback Callback function
+   * @param signal Optional abort signal to cancel the subscription
+   * @returns Subscription instance
+   */
+  subscribe<Event extends keyof Events>(event: Event, callback: Events[Event], signal?: AbortSignal): Subscription;
+};
+type HeraldEvents<Events extends Record<string, GenericCallback>> = { [Key in keyof Events]: Key extends '*' ? never : (callback: Events[Key], signal?: AbortSignal) => void; };
+type HeraldOnCreate<Events extends Record<string, GenericCallback>> = <Event extends keyof Events>(event: Event, callback: Events[Event], subscription: Subscription) => void;
+type HeraldOptions<Events extends Record<string, GenericCallback>> = {
+  names: Array<keyof Events>;
+  property?: SubscriptionProperty;
+  onCreate?: HeraldOnCreate<Events>;
+};
+/**
+ * Create a _Herald_ for announcing named events
+ *
+ * @param names Event names
+ * @param property Optional property for subscription identification _(defaults to `$herald`)_
+ * @returns _Herald_ instance
+ */
+declare function herald<Events extends Record<string, GenericCallback>>(options: HeraldOptions<Events>): Herald<Events>;
+/**
+ * Is the value a herald?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a herald, otherwise `false`
+ */
+declare function isHerald<Events extends Record<string, GenericCallback> = Record<string, GenericCallback>>(value: unknown): value is Herald<Events>;
+/**
+ * Is the value events for a herald?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is events for a herald, otherwise `false`
+ */
+declare function isHeraldEvents<Events extends Record<string, GenericCallback> = Record<string, GenericCallback>>(value: unknown): value is HeraldEvents<Events>;
+/**
+ * Is the value a herald subscription?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a herald subscription, otherwise `false`
+ */
+declare function isHeraldSubscription(value: unknown): value is Subscription;
+//#endregion
+export { Herald, HeraldEvents, HeraldOptions, herald, isHerald, isHeraldEvents, isHeraldSubscription };