semantic-typescript 0.5.3 → 0.6.0

package/dist/guard.d.ts

@@ -1,7 +1,8 @@
-import type { Collectable, OrderedCollectable, Statistics, UnorderedCollectable, WindowCollectable } from "./semantic";
-import type { Collector } from "./collector";
+import type { AsynchronousCollector } from "./asynchronous/collector";
+import type { AsynchronousBigIntStatistics, AsynchronousNumericStatistics, AsynchronousOrderedCollectable, AsynchronousSemantic, AsynchronousStatistics, AsynchronousUnorderedCollectable, AsynchronousWindowCollectable } from "./asynchronous/semantic";
 import type { Optional } from "./optional";
-import type { Semantic } from "./semantic";
+import type { SynchronousCollector } from "./synchronous/collector";
+import type { SynchronousBigIntStatistics, SynchronousNumericStatistics, SynchronousOrderedCollectable, SynchronousSemantic, SynchronousStatistics, SynchronousUnorderedCollectable, SynchronousWindowCollectable } from "./synchronous/semantic";
 import type { AsyncFunction, MaybePrimitive, Primitive } from "./utility";
 export declare let isBoolean: (target: unknown) => target is boolean;
 export declare let isString: (target: unknown) => target is string;
@@ -11,18 +12,27 @@ export declare let isObject: (target: unknown) => target is object;
 export declare let isSymbol: (target: unknown) => target is symbol;
 export declare let isBigInt: (target: unknown) => target is bigint;
 export declare let isPrimitive: (target: MaybePrimitive<unknown>) => target is Primitive;
-export declare let isAsyncIterable: (target: unknown) => target is Iterable<unknown>;
+export declare let isAsyncIterable: (target: unknown) => target is AsyncIterable<unknown>;
 export declare let isIterable: (target: unknown) => target is Iterable<unknown>;
-export declare let isSemantic: (target: unknown) => target is Semantic<unknown>;
-export declare let isCollector: (target: unknown) => target is Collector<unknown, unknown, unknown>;
-export declare let isCollectable: (target: unknown) => target is Collectable<unknown>;
-export declare let isOrderedCollectable: (target: unknown) => target is OrderedCollectable<unknown>;
-export declare let isWindowCollectable: (target: unknown) => target is WindowCollectable<unknown>;
-export declare let isUnorderedCollectable: (target: unknown) => target is UnorderedCollectable<unknown>;
-export declare let isStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
-export declare let isNumericStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
-export declare let isBigIntStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
-export declare let isOptional: <T>(target: unknown) => target is Optional<T>;
+export declare let isAsynchronousSemantic: (target: unknown) => target is AsynchronousSemantic<unknown>;
+export declare let isSynchronousSemantic: (target: unknown) => target is SynchronousSemantic<unknown>;
+export declare let isAsynchronousCollectable: (target: unknown) => target is AsynchronousSemantic<unknown>;
+export declare let isSynchronousCollectable: (target: unknown) => target is SynchronousSemantic<unknown>;
+export declare let isAsynchronousOrderedCollectable: (target: unknown) => target is AsynchronousOrderedCollectable<unknown>;
+export declare let isSynchronousOrderedCollectable: (target: unknown) => target is SynchronousOrderedCollectable<unknown>;
+export declare let isAsynchronousUnorderedCollectable: (target: unknown) => target is AsynchronousUnorderedCollectable<unknown>;
+export declare let isSynchronousUnorderedCollectable: (target: unknown) => target is SynchronousUnorderedCollectable<unknown>;
+export declare let isAsynchronousStatistics: (target: unknown) => target is AsynchronousStatistics<unknown, number | bigint>;
+export declare let isSynchronousStatistics: (target: unknown) => target is SynchronousStatistics<unknown, number | bigint>;
+export declare let isAsynchronousBigIntStatistics: (target: unknown) => target is AsynchronousBigIntStatistics<unknown>;
+export declare let isSynchronousBigIntStatistics: (target: unknown) => target is SynchronousBigIntStatistics<unknown>;
+export declare let isAsynchronousNumericStatistics: (target: unknown) => target is AsynchronousNumericStatistics<unknown>;
+export declare let isSynchronousNumericStatistics: (target: unknown) => target is SynchronousNumericStatistics<unknown>;
+export declare let isAsynchronousWindowCollectable: (target: unknown) => target is AsynchronousWindowCollectable<unknown>;
+export declare let isSynchronousWindowCollectable: (target: unknown) => target is SynchronousWindowCollectable<unknown>;
+export declare let isSynchronousCollector: (target: unknown) => target is SynchronousCollector<unknown, unknown, unknown>;
+export declare let isAsynchronousCollector: (target: unknown) => target is AsynchronousCollector<unknown, unknown, unknown>;
+export declare let isOptional: (target: unknown) => target is Optional<unknown>;
 export declare let isPromise: (target: unknown) => target is Promise<unknown>;
 export declare let isAsyncFunction: (target: unknown) => target is AsyncFunction;
 export declare let isGeneratorFunction: (target: unknown) => target is Generator<unknown, unknown, unknown>;

package/dist/guard.js

@@ -1,4 +1,4 @@
-import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, NumericStatisticsSymbol, OptionalSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
+import { AsynchronousBigIntStatisticsSymbol, AsynchronousCollectorSymbol, AsynchronousNumericStatisticsSymbol, AsynchronousOrderedCollectableSymbol, AsynchronousSemanticSymbol, AsynchronousStatisticsSymbol, AsynchronousUnorderedCollectableSymbol, AsynchronousWindowCollectableSymbol, OptionalSymbol, SynchronousBigIntStatisticsSymbol, SynchronousCollectorSymbol, SynchronousNumericStatisticsSymbol, SynchronousOrderedCollectableSymbol, SynchronousSemanticSymbol, SynchronousStatisticsSymbol, SynchronousUnorderedCollectableSymbol, SynchronousWindowCollectableSymbol } from "./symbol";
 export let isBoolean = (target) => {
     return typeof target === "boolean";
 };
@@ -35,57 +35,111 @@ export let isIterable = (target) => {
     }
     return false;
 };
-export let isSemantic = (target) => {
+export let isAsynchronousSemantic = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Semantic") === SemanticSymbol;
+        return Reflect.get(target, "AsynchronousSemantic") === AsynchronousSemanticSymbol;
     }
     return false;
 };
-export let isCollector = (target) => {
+export let isSynchronousSemantic = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Collector") === CollectorsSymbol;
+        return Reflect.get(target, "SynchronousSemantic") === SynchronousSemanticSymbol;
     }
     return false;
 };
-export let isCollectable = (target) => {
+export let isAsynchronousCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Collectable") === CollectableSymbol;
+        return Reflect.get(target, "AsynchronousCollectable") === AsynchronousSemanticSymbol || isAsynchronousSemantic(target) || isAsynchronousOrderedCollectable(target) || isAsynchronousUnorderedCollectable(target) || isAsynchronousStatistics(target) || isAsynchronousNumericStatistics(target) || isAsynchronousBigIntStatistics(target) || isAsynchronousWindowCollectable(target);
     }
     return false;
 };
-export let isOrderedCollectable = (target) => {
+export let isSynchronousCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "OrderedCollectable") === OrderedCollectableSymbol;
+        return Reflect.get(target, "SynchronousCollectable") === SynchronousSemanticSymbol || isSynchronousSemantic(target) || isSynchronousOrderedCollectable(target) || isSynchronousUnorderedCollectable(target) || isSynchronousStatistics(target) || isSynchronousNumericStatistics(target) || isSynchronousBigIntStatistics(target) || isSynchronousWindowCollectable(target);
     }
     return false;
 };
-export let isWindowCollectable = (target) => {
+export let isAsynchronousOrderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "WindowCollectable") === WindowCollectableSymbol;
+        return Reflect.get(target, "AsynchronousOrderedCollectable") === AsynchronousOrderedCollectableSymbol;
     }
     return false;
 };
-export let isUnorderedCollectable = (target) => {
+export let isSynchronousOrderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "UnorderedCollectable") === UnorderedCollectableSymbol;
+        return Reflect.get(target, "SynchronousOrderedCollectable") === SynchronousOrderedCollectableSymbol;
     }
     return false;
 };
-export let isStatistics = (target) => {
+export let isAsynchronousUnorderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Statistics") === StatisticsSymbol;
+        return Reflect.get(target, "AsynchronousUnorderedCollectable") === AsynchronousUnorderedCollectableSymbol;
     }
     return false;
 };
-export let isNumericStatistics = (target) => {
+export let isSynchronousUnorderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "NumericStatistics") === NumericStatisticsSymbol;
+        return Reflect.get(target, "SynchronousUnorderedCollectable") === SynchronousUnorderedCollectableSymbol;
     }
     return false;
 };
-export let isBigIntStatistics = (target) => {
+export let isAsynchronousStatistics = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "BigIntStatistics") === BigIntStatisticsSymbol;
+        return Reflect.get(target, "AsynchronousStatistics") === AsynchronousStatisticsSymbol;
+    }
+    return false;
+};
+export let isSynchronousStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "SynchronousStatistics") === SynchronousStatisticsSymbol;
+    }
+    return false;
+};
+export let isAsynchronousBigIntStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "AsynchronousBigIntStatistics") === AsynchronousBigIntStatisticsSymbol;
+    }
+    return false;
+};
+export let isSynchronousBigIntStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "SynchronousBigIntStatistics") === SynchronousBigIntStatisticsSymbol;
+    }
+    return false;
+};
+export let isAsynchronousNumericStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "AsynchronousBigIntStatistics") === AsynchronousNumericStatisticsSymbol;
+    }
+    return false;
+};
+export let isSynchronousNumericStatistics = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "AsynchronousNumericStatistics") === SynchronousNumericStatisticsSymbol;
+    }
+    return false;
+};
+export let isAsynchronousWindowCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "AsynchronousWindowCollectable") === AsynchronousWindowCollectableSymbol;
+    }
+    return false;
+};
+export let isSynchronousWindowCollectable = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "SynchronousWindowCollectable") === SynchronousWindowCollectableSymbol;
+    }
+    return false;
+};
+export let isSynchronousCollector = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "SynchronousCollector") === SynchronousCollectorSymbol;
+    }
+    return false;
+};
+export let isAsynchronousCollector = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "AsynchronousCollector") === AsynchronousCollectorSymbol;
     }
     return false;
 };

package/dist/hook.d.ts

@@ -1,5 +1,5 @@
 import { type DeepPropertyKey, type DeepPropertyValue } from "./utility";
-import type { Comparator, Generator } from "./utility";
+import type { Comparator, SynchronousGenerator } from "./utility";
 export declare let useCompare: <T>(t1: T, t2: T) => number;
 interface UseRandom {
     <N extends number | bigint>(start: N): N extends number ? number : (N extends bigint ? bigint : never);
@@ -20,12 +20,12 @@ interface UseTraverse {
     <T extends object>(t: T, callback: UseTraversePathCallback<T>): void;
 }
 export declare let useTraverse: UseTraverse;
-export declare let useGenerator: <E>(iterable: Iterable<E>) => Generator<E>;
+export declare let useGenerator: <E>(iterable: Iterable<E>) => SynchronousGenerator<E>;
 interface UseArrange {
-    <E>(source: Iterable<E>): Generator<E>;
-    <E>(source: Iterable<E>, comparator: Comparator<E>): Generator<E>;
-    <E>(source: Generator<E>): Generator<E>;
-    <E>(source: Generator<E>, comparator: Comparator<E>): Generator<E>;
+    <E>(source: Iterable<E>): SynchronousGenerator<E>;
+    <E>(source: Iterable<E>, comparator: Comparator<E>): SynchronousGenerator<E>;
+    <E>(source: SynchronousGenerator<E>): SynchronousGenerator<E>;
+    <E>(source: SynchronousGenerator<E>, comparator: Comparator<E>): SynchronousGenerator<E>;
 }
 export declare let useArrange: UseArrange;
 export declare let useToNumber: <T = unknown>(target: T) => number;

package/dist/hook.js

@@ -1,4 +1,4 @@
-import { useToArray } from "./collector";
+import { useSynchronousToArray } from "./synchronous/collector";
 import { isBigInt, isFunction, isIterable, isNumber, isObject, isPrimitive } from "./guard";
 import { invalidate, validate } from "./utility";
 export let useCompare = (t1, t2) => {
@@ -210,7 +210,7 @@ export let useArrange = (source, comparator) => {
         }
     }
     else if (isFunction(source)) {
-        let collector = useToArray();
+        let collector = useSynchronousToArray();
         let buffer = collector.collect(source);
         if (validate(comparator) && isFunction(comparator)) {
             return useGenerator(buffer.sort(comparator));

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export * from "./collector";
+export * from "./asynchronous/collector";
+export * from "./synchronous/collector";
 export * from "./factory";
 export * from "./guard";
 export * from "./hook";
 export * from "./optional";
-export * from "./semantic";
 export * from "./symbol";
 export * from "./utility";

package/dist/index.js

@@ -1,8 +1,8 @@
-export * from "./collector";
+export * from "./asynchronous/collector";
+export * from "./synchronous/collector";
 export * from "./factory";
 export * from "./guard";
 export * from "./hook";
 export * from "./optional";
-export * from "./semantic";
 export * from "./symbol";
 export * from "./utility";

package/dist/optional.d.ts

@@ -1,4 +1,4 @@
-import type { Semantic } from "./semantic";
+import type { SynchronousSemantic } from "./synchronous/semantic";
 import { type Consumer, type Functional, type MaybeInvalid, type Predicate, type Runnable, type Valid } from "./utility";
 export declare class Optional<T> {
     protected value: MaybeInvalid<T>;
@@ -15,7 +15,7 @@ export declare class Optional<T> {
     flat(mapper: Functional<T, Optional<T>>): Optional<T>;
     flatMap<R>(mapper: Functional<T, Optional<R>>): Optional<R>;
     orElse(other: MaybeInvalid<T>): MaybeInvalid<T>;
-    semantic(): Semantic<T>;
+    semantic(): SynchronousSemantic<T>;
     static empty<T>(): Optional<T>;
     static of<T>(value: MaybeInvalid<T>): Optional<T>;
     static ofNullable<T>(value?: MaybeInvalid<T>): Optional<T>;

package/dist/symbol.d.ts

@@ -1,11 +1,20 @@
 export declare let OptionalSymbol: symbol;
-export declare let SemanticSymbol: symbol;
-export declare let CollectorsSymbol: symbol;
-export declare let CollectableSymbol: symbol;
-export declare let OrderedCollectableSymbol: symbol;
-export declare let WindowCollectableSymbol: symbol;
-export declare let StatisticsSymbol: symbol;
-export declare let NumericStatisticsSymbol: symbol;
-export declare let BigIntStatisticsSymbol: symbol;
-export declare let AsyncCollectableSymbol: symbol;
-export declare let UnorderedCollectableSymbol: symbol;
+export declare let AsynchronousSemanticSymbol: symbol;
+export declare let SynchronousSemanticSymbol: symbol;
+export declare let AsynchronousCollectorSymbol: symbol;
+export declare let SynchronousCollectorSymbol: symbol;
+export declare let DispatchCollectableSymbol: symbol;
+export declare let AsynchronousCollectableSymbol: symbol;
+export declare let SynchronousCollectableSymbol: symbol;
+export declare let AsynchronousOrderedCollectableSymbol: symbol;
+export declare let SynchronousOrderedCollectableSymbol: symbol;
+export declare let AsynchronousUnorderedCollectableSymbol: symbol;
+export declare let SynchronousUnorderedCollectableSymbol: symbol;
+export declare let AsynchronousWindowCollectableSymbol: symbol;
+export declare let SynchronousWindowCollectableSymbol: symbol;
+export declare let AsynchronousStatisticsSymbol: symbol;
+export declare let SynchronousStatisticsSymbol: symbol;
+export declare let AsynchronousNumericStatisticsSymbol: symbol;
+export declare let SynchronousNumericStatisticsSymbol: symbol;
+export declare let AsynchronousBigIntStatisticsSymbol: symbol;
+export declare let SynchronousBigIntStatisticsSymbol: symbol;

package/dist/symbol.js

@@ -1,11 +1,20 @@
 export let OptionalSymbol = Symbol.for("Optional");
-export let SemanticSymbol = Symbol.for("Semantic");
-export let CollectorsSymbol = Symbol.for("Collector");
-export let CollectableSymbol = Symbol.for("Collectable");
-export let OrderedCollectableSymbol = Symbol.for("OrderedCollectable");
-export let WindowCollectableSymbol = Symbol.for("WindowCollectable");
-export let StatisticsSymbol = Symbol.for("Statistics");
-export let NumericStatisticsSymbol = Symbol.for("NumericStatistics");
-export let BigIntStatisticsSymbol = Symbol.for("BigIntStatistics");
-export let AsyncCollectableSymbol = Symbol.for("AsyncCollectable");
-export let UnorderedCollectableSymbol = Symbol.for("UnorderedCollectable");
+export let AsynchronousSemanticSymbol = Symbol.for("AsynchronousSemantic");
+export let SynchronousSemanticSymbol = Symbol.for("SynchronousSemantic");
+export let AsynchronousCollectorSymbol = Symbol.for("AsynchronousCollector");
+export let SynchronousCollectorSymbol = Symbol.for("SynchronousCollector");
+export let DispatchCollectableSymbol = Symbol.for("DispatchCollectable");
+export let AsynchronousCollectableSymbol = Symbol.for("AsynchronousCollectable");
+export let SynchronousCollectableSymbol = Symbol.for("SynchronousCollectable");
+export let AsynchronousOrderedCollectableSymbol = Symbol.for("OrderedAsynchronousCollectable");
+export let SynchronousOrderedCollectableSymbol = Symbol.for("OrderedSynchronousCollectable");
+export let AsynchronousUnorderedCollectableSymbol = Symbol.for("AsynchronousUnorderedCollectable");
+export let SynchronousUnorderedCollectableSymbol = Symbol.for("SynchronousUnorderedCollectable");
+export let AsynchronousWindowCollectableSymbol = Symbol.for("AsynchronousWindowCollectable");
+export let SynchronousWindowCollectableSymbol = Symbol.for("SynchronousWindowCollectable");
+export let AsynchronousStatisticsSymbol = Symbol.for("AsynchronousStatistics");
+export let SynchronousStatisticsSymbol = Symbol.for("AsynchronousStatistics");
+export let AsynchronousNumericStatisticsSymbol = Symbol.for("AsynchronousNumericStatistics");
+export let SynchronousNumericStatisticsSymbol = Symbol.for("SynchronousNumericStatisticsSymbol");
+export let AsynchronousBigIntStatisticsSymbol = Symbol.for("AsynchronousBigIntStatistics");
+export let SynchronousBigIntStatisticsSymbol = Symbol.for("SynchronousBigIntStatisticsSymbol");

package/dist/synchronous/collector.d.ts

@@ -0,0 +1,232 @@
+import { Optional } from "../optional";
+import type { Supplier, Predicate, BiPredicate, TriPredicate, BiFunctional, TriFunctional, Functional, SynchronousGenerator, Comparator, Consumer, BiConsumer } from "../utility";
+export declare class SynchronousCollector<E, A, R> {
+    protected identity: Supplier<A>;
+    protected interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
+    protected accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
+    protected finisher: Functional<A, R>;
+    protected readonly SynchronousCollector: symbol;
+    protected constructor(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
+    collect(generator: SynchronousGenerator<E>): R;
+    collect(iterable: Iterable<E>): R;
+    collect(start: number, end: number): R;
+    collect(start: bigint, end: bigint): R;
+    static full<E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    static full<E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+}
+interface UseSynchronousAnyMatch {
+    <E>(predicate: Predicate<E>): SynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): SynchronousCollector<E, boolean, boolean>;
+}
+export declare let useSynchronousAnyMatch: UseSynchronousAnyMatch;
+interface UseSynchronousAllMatch {
+    <E>(predicate: Predicate<E>): SynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): SynchronousCollector<E, boolean, boolean>;
+}
+export declare let useSynchronousAllMatch: UseSynchronousAllMatch;
+interface UseSynchronousCollect {
+    <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+}
+export declare let useSynchronousCollect: UseSynchronousCollect;
+export declare let useSynchronousCount: <E = unknown>() => SynchronousCollector<E, bigint, bigint>;
+interface UseSynchronousError {
+    <E = unknown>(): SynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: BiFunctional<string, E, string>): SynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): SynchronousCollector<E, string, string>;
+}
+export declare let useSynchronousError: UseSynchronousError;
+interface UseSynchronousFindAt {
+    <E>(index: number): SynchronousCollector<E, Array<E>, Optional<E>>;
+    <E>(index: bigint): SynchronousCollector<E, Array<E>, Optional<E>>;
+}
+export declare let useSynchronousFindAt: UseSynchronousFindAt;
+export declare let useSynchronousFindFirst: <E>() => SynchronousCollector<E, Optional<E>, Optional<E>>;
+export declare let useSynchronousFindAny: <E>() => SynchronousCollector<E, Optional<E>, Optional<E>>;
+export declare let useSynchronousFindLast: <E>() => SynchronousCollector<E, Optional<E>, Optional<E>>;
+interface UseSynchronousFindMaximum {
+    <E>(): SynchronousCollector<E, Optional<E>, Optional<E>>;
+    <E>(comparator: Comparator<E>): SynchronousCollector<E, Optional<E>, Optional<E>>;
+}
+export declare let useSynchronousFindMaximum: UseSynchronousFindMaximum;
+interface UseSynchronousFindMinimum {
+    <E>(): SynchronousCollector<E, Optional<E>, Optional<E>>;
+    <E>(comparator: Comparator<E>): SynchronousCollector<E, Optional<E>, Optional<E>>;
+}
+export declare let useSynchronousFindMinimum: UseSynchronousFindMinimum;
+interface UseSynchronousForEach {
+    <E>(action: Consumer<E>): SynchronousCollector<E, bigint, bigint>;
+    <E>(action: BiConsumer<E, bigint>): SynchronousCollector<E, bigint, bigint>;
+}
+export declare let useSynchronousForEach: UseSynchronousForEach;
+interface UseSynchronousNonMatch {
+    <E>(predicate: Predicate<E>): SynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): SynchronousCollector<E, boolean, boolean>;
+}
+export declare let useSynchronousNoneMatch: UseSynchronousNonMatch;
+interface UseSynchronousGroup {
+    <E, K>(classifier: Functional<E, K>): SynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
+    <E, K>(classifier: BiFunctional<E, bigint, K>): SynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
+}
+export declare let useSynchronousGroup: UseSynchronousGroup;
+interface UseSynchronousGroupBy {
+    <E, K>(keyExtractor: Functional<E, K>): SynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): SynchronousCollector<E, Map<K, V[]>, Map<K, V[]>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): SynchronousCollector<E, Map<K, V[]>, Map<K, V[]>>;
+}
+export declare let useSynchronousGroupBy: UseSynchronousGroupBy;
+interface UseSynchronousJoin {
+    <E = unknown>(): SynchronousCollector<E, string, string>;
+    <E = unknown>(delimiter: string): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, delimiter: string, suffix: string): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefiex: string, accumulator: BiFunctional<string, E, string>, suffix: string): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): SynchronousCollector<E, string, string>;
+}
+export declare let useSynchronousJoin: UseSynchronousJoin;
+interface UseSynchronousLog {
+    <E = unknown>(): SynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: BiFunctional<string, E, string>): SynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): SynchronousCollector<E, string, string>;
+}
+export declare let useSynchronousLog: UseSynchronousLog;
+export declare let useSynchronousPartition: <E>(count: bigint) => SynchronousCollector<E, Array<Array<E>>, Array<Array<E>>>;
+interface UseSynchronousPartitionBy {
+    <E>(classifier: Functional<E, bigint>): SynchronousCollector<E, Array<E[]>, Array<E[]>>;
+    <E>(classifier: BiFunctional<E, bigint, bigint>): SynchronousCollector<E, Array<E[]>, Array<E[]>>;
+}
+export declare let useSynchronousPartitionBy: UseSynchronousPartitionBy;
+interface UseSynchronousReduce {
+    <E>(accumulator: BiFunctional<E, E, E>): SynchronousCollector<E, Optional<E>, Optional<E>>;
+    <E>(accumulator: TriFunctional<E, E, bigint, E>): SynchronousCollector<E, Optional<E>, Optional<E>>;
+    <E>(identity: E, accumulator: BiFunctional<E, E, E>): SynchronousCollector<E, E, E>;
+    <E>(identity: E, accumulator: TriFunctional<E, E, bigint, E>): SynchronousCollector<E, E, E>;
+    <E, R>(identity: R, accumulator: BiFunctional<R, E, R>, finisher: Functional<R, R>): SynchronousCollector<E, R, R>;
+    <E, R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: Functional<R, R>): SynchronousCollector<E, R, R>;
+}
+export declare let useSynchronousReduce: UseSynchronousReduce;
+export declare let useSynchronousToArray: <E>() => SynchronousCollector<E, E[], E[]>;
+interface UseSynchronousToMap {
+    <E, K>(keyExtractor: Functional<E, K>): SynchronousCollector<E, Map<K, E>, Map<K, E>>;
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): SynchronousCollector<E, Map<K, V>, Map<K, V>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): SynchronousCollector<E, Map<K, V>, Map<K, V>>;
+}
+export declare let useSynchronousToMap: UseSynchronousToMap;
+export declare let useSynchronousToSet: <E>() => SynchronousCollector<E, Set<E>, Set<E>>;
+interface UseSynchronousWrite {
+    <E, S = string>(stream: WritableStream<S>): SynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+    <E, S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): SynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+    <E, S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): SynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+}
+export declare let useSynchronousWrite: UseSynchronousWrite;
+interface UseSynchronousNumericSummate {
+    <E>(): SynchronousCollector<E, number, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, number, number>;
+}
+export declare let useSynchronousNumericSummate: UseSynchronousNumericSummate;
+interface UseSynchronousBigIntSummate {
+    <E>(): SynchronousCollector<E, bigint, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, bigint, bigint>;
+}
+export declare let useSynchronousBigIntSummate: UseSynchronousBigIntSummate;
+interface UseSynchronousNumericAverage {
+    <E>(): SynchronousCollector<E, NumericAverageAccumulator, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, NumericAverageAccumulator, number>;
+}
+interface NumericAverageAccumulator {
+    summate: number;
+    count: number;
+}
+export declare let useSynchronousNumericAverage: UseSynchronousNumericAverage;
+interface UseSynchronousBigIntAverage {
+    <E>(): SynchronousCollector<E, BigIntAverageAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, BigIntAverageAccumulator, bigint>;
+}
+interface BigIntAverageAccumulator {
+    summate: bigint;
+    count: bigint;
+}
+export declare let useSynchronousBigIntAverage: UseSynchronousBigIntAverage;
+export declare let useSynchronousFrequency: <E>() => SynchronousCollector<E, Map<E, bigint>, Map<E, bigint>>;
+interface UseSynchronousNumericMode {
+    <E>(): SynchronousCollector<E, Map<number, bigint>, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, Map<number, bigint>, number>;
+}
+export declare let useSynchronousNumericMode: UseSynchronousNumericMode;
+interface UseSynchronousBigIntMode {
+    <E>(): SynchronousCollector<E, Map<bigint, bigint>, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, Map<bigint, bigint>, bigint>;
+}
+export declare let useSynchronousBigIntMode: UseSynchronousBigIntMode;
+interface UseSynchronousNumericVariance {
+    <E>(): SynchronousCollector<E, VarianceAccumulator, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, VarianceAccumulator, number>;
+}
+interface VarianceAccumulator {
+    summate: number;
+    summateOfSquares: number;
+    count: number;
+}
+export declare let useSynchronousNumericVariance: UseSynchronousNumericVariance;
+interface UseSynchronousBigIntVariance {
+    <E>(): SynchronousCollector<E, BigIntVarianceAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, BigIntVarianceAccumulator, bigint>;
+}
+interface BigIntVarianceAccumulator {
+    summate: bigint;
+    summateOfSquares: bigint;
+    count: bigint;
+}
+export declare let useSynchronousBigIntVariance: UseSynchronousBigIntVariance;
+interface UseSynchronousNumericStandardDeviation {
+    <E>(): SynchronousCollector<E, StandardDeviationAccumulator, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, StandardDeviationAccumulator, number>;
+}
+interface StandardDeviationAccumulator {
+    summate: number;
+    summateOfSquares: number;
+    count: number;
+}
+export declare let useSynchronousNumericStandardDeviation: UseSynchronousNumericStandardDeviation;
+interface UseSynchronousBigIntStandardDeviation {
+    <E>(): SynchronousCollector<E, BigIntStandardDeviationAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, BigIntStandardDeviationAccumulator, bigint>;
+}
+interface BigIntStandardDeviationAccumulator {
+    summate: bigint;
+    summateOfSquares: bigint;
+    count: bigint;
+}
+export declare let useSynchronousBigIntStandardDeviation: UseSynchronousBigIntStandardDeviation;
+interface UseSynchronousNumericMedian {
+    <E>(): SynchronousCollector<E, number[], number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, number[], number>;
+}
+export declare let useSynchronousNumericMedian: UseSynchronousNumericMedian;
+interface UseSynchronousBigIntMedian {
+    <E>(): SynchronousCollector<E, bigint[], bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, bigint[], bigint>;
+}
+export declare let useSynchronousBigIntMedian: UseSynchronousBigIntMedian;
+export declare let useSynchronousToGeneratorFunction: <E>() => SynchronousCollector<E, Array<E>, globalThis.Generator<E, void, undefined>>;
+export declare let useSynchronousToAsyncGeneratorFunction: <E>() => SynchronousCollector<E, Array<E>, globalThis.AsyncGenerator<E, void, undefined>>;
+export {};