semantic-typescript 0.5.0 → 0.6.0

package/dist/asynchronous/semantic.d.ts

@@ -0,0 +1,257 @@
+import { type BiConsumer, type BiFunctional, type BiPredicate, type Comparator, type Consumer, type Functional, type Indexed, type Predicate, type Supplier, type AsynchronousGenerator, type TriFunctional, type TriPredicate } from "../utility";
+import type { AsynchronousCollector } from "./collector";
+export declare class AsynchronousSemantic<E> {
+    protected generator: AsynchronousGenerator<E>;
+    protected readonly AsynchronousSemantic: Symbol;
+    [Symbol.toStringTag]: string;
+    constructor(generator: AsynchronousGenerator<E>);
+    concat(other: AsynchronousSemantic<E>): AsynchronousSemantic<E>;
+    concat(other: AsyncIterable<E>): AsynchronousSemantic<E>;
+    distinct(): AsynchronousSemantic<E>;
+    distinct<K>(keyExtractor: Functional<E, K>): AsynchronousSemantic<E>;
+    distinct<K>(keyExtractor: BiFunctional<E, bigint, K>): AsynchronousSemantic<E>;
+    dropWhile(predicate: Predicate<E>): AsynchronousSemantic<E>;
+    dropWhile(predicate: BiPredicate<E, bigint>): AsynchronousSemantic<E>;
+    filter(predicate: Predicate<E>): AsynchronousSemantic<E>;
+    filter(predicate: BiPredicate<E, bigint>): AsynchronousSemantic<E>;
+    flat(mapper: Functional<E, Iterable<E>>): AsynchronousSemantic<E>;
+    flat(mapper: BiFunctional<E, bigint, Iterable<E>>): AsynchronousSemantic<E>;
+    flat(mapper: Functional<E, AsynchronousSemantic<E>>): AsynchronousSemantic<E>;
+    flat(mapper: BiFunctional<E, bigint, AsynchronousSemantic<E>>): AsynchronousSemantic<E>;
+    flatMap<R>(mapper: Functional<E, Iterable<R>>): AsynchronousSemantic<R>;
+    flatMap<R>(mapper: BiFunctional<E, bigint, Iterable<R>>): AsynchronousSemantic<R>;
+    flatMap<R>(mapper: Functional<E, AsynchronousSemantic<R>>): AsynchronousSemantic<R>;
+    flatMap<R>(mapper: BiFunctional<E, bigint, AsynchronousSemantic<R>>): AsynchronousSemantic<R>;
+    limit(count: number): AsynchronousSemantic<E>;
+    limit(count: bigint): AsynchronousSemantic<E>;
+    map<R>(mapper: Functional<E, R>): AsynchronousSemantic<R>;
+    map<R>(mapper: BiFunctional<E, bigint, R>): AsynchronousSemantic<R>;
+    peek(consumer: Consumer<E>): AsynchronousSemantic<E>;
+    peek(consumer: BiConsumer<E, bigint>): AsynchronousSemantic<E>;
+    redirect(redirector: BiFunctional<E, bigint, bigint>): AsynchronousSemantic<E>;
+    reverse(): AsynchronousSemantic<E>;
+    shuffle(): AsynchronousSemantic<E>;
+    shuffle(mapper: BiFunctional<E, bigint, bigint>): AsynchronousSemantic<E>;
+    skip(count: number): AsynchronousSemantic<E>;
+    skip(count: bigint): AsynchronousSemantic<E>;
+    source(): AsynchronousGenerator<E>;
+    sub(start: number, end: number): AsynchronousSemantic<E>;
+    sub(start: bigint, end: bigint): AsynchronousSemantic<E>;
+    takeWhile(predicate: Predicate<E>): AsynchronousSemantic<E>;
+    takeWhile(predicate: BiPredicate<E, bigint>): AsynchronousSemantic<E>;
+    toAsynchronousCollectable(): AsynchronousCollectable<E>;
+    toAsynchronousCollectable<C extends AsynchronousCollectable<E>>(mapper: Functional<AsynchronousGenerator<E>, C>): C;
+    toBigintStatistics(): AsynchronousBigIntStatistics<E>;
+    toNumericStatistics(): AsynchronousNumericStatistics<E>;
+    toOrdered(): AsynchronousOrderedCollectable<E>;
+    toUnordered(): AsynchronousUnorderedCollectable<E>;
+    toWindow(): AsynchronousWindowCollectable<E>;
+    translate(offset: number): AsynchronousSemantic<E>;
+    translate(offset: bigint): AsynchronousSemantic<E>;
+    translate(translator: BiFunctional<E, bigint, bigint>): AsynchronousSemantic<E>;
+}
+export declare abstract class AsynchronousCollectable<E> implements AsyncIterable<E> {
+    protected readonly AsynchronousCollectable: symbol;
+    [Symbol.toStringTag]: string;
+    constructor();
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    anyMatch(predicate: Predicate<E>): Promise<boolean>;
+    allMatch(predicate: Predicate<E>): Promise<boolean>;
+    collect<A, R>(collector: AsynchronousCollector<E, A, R>): Promise<R>;
+    collect<A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Promise<R>;
+    collect<A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Promise<R>;
+    collect<A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Promise<R>;
+    collect<A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Promise<R>;
+    collect<A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Promise<R>;
+    collect<A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Promise<R>;
+    collect<A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Promise<R>;
+    collect<A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Promise<R>;
+    count(): Promise<bigint>;
+    error(): Promise<void>;
+    error(accumulator: BiFunctional<string, E, string>): Promise<void>;
+    error(accumulator: TriFunctional<string, E, bigint, string>): Promise<void>;
+    error(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): Promise<void>;
+    error(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Promise<void>;
+    isEmpty(): Promise<boolean>;
+    findAny(): Promise<E>;
+    findAt(index: number): Promise<E>;
+    findAt(index: bigint): Promise<E>;
+    findFirst(): Promise<E>;
+    findLast(): Promise<E>;
+    findMaximum(): Promise<E>;
+    findMaximum(comparator: Comparator<E>): Promise<E>;
+    findMinimum(): Promise<E>;
+    findMinimum(comparator: Comparator<E>): Promise<E>;
+    forEach(action: Consumer<E>): Promise<void>;
+    forEach(action: BiConsumer<E, bigint>): Promise<void>;
+    group<K>(classifier: Functional<E, K>): Promise<Map<K, Array<E>>>;
+    group<K>(classifier: BiFunctional<E, bigint, K>): Promise<Map<K, Array<E>>>;
+    groupBy<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Promise<Map<K, Array<V>>>;
+    groupBy<K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, K>): Promise<Map<K, Array<V>>>;
+    join(): Promise<string>;
+    join(delimiter: string): Promise<string>;
+    join(prefix: string, delimiter: string, suffix: string): Promise<string>;
+    join(prefiex: string, accumulator: BiFunctional<string, E, string>, suffix: string): Promise<string>;
+    join(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Promise<string>;
+    log(): Promise<void>;
+    log(accumulator: BiFunctional<string, E, string>): Promise<void>;
+    log(accumulator: TriFunctional<string, E, bigint, string>): Promise<void>;
+    log(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): Promise<void>;
+    log(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Promise<void>;
+    nonMatch(predicate: Predicate<E>): Promise<boolean>;
+    nonMatch(predicate: BiPredicate<E, bigint>): Promise<boolean>;
+    partition(count: bigint): Promise<Array<Array<E>>>;
+    partitionBy(classifier: Functional<E, bigint>): Promise<Array<Array<E>>>;
+    partitionBy(classifier: BiFunctional<E, bigint, bigint>): Promise<Array<Array<E>>>;
+    reduce(accumulator: BiFunctional<E, E, E>): Promise<E>;
+    reduce(accumulator: TriFunctional<E, E, bigint, E>): Promise<E>;
+    reduce(identity: E, accumulator: BiFunctional<E, E, E>): Promise<E>;
+    reduce(identity: E, accumulator: TriFunctional<E, E, bigint, E>): Promise<E>;
+    reduce<R>(identity: R, accumulator: BiFunctional<R, E, R>, finisher: Functional<R, R>): Promise<R>;
+    reduce<R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: Functional<R, R>): Promise<R>;
+    semantic(): AsynchronousSemantic<E>;
+    abstract source(): AsynchronousGenerator<E>;
+    toArray(): Promise<Array<E>>;
+    toMap<K, E>(keyExtractor: Functional<E, K>): Promise<Map<K, E>>;
+    toMap<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Promise<Map<K, V>>;
+    toMap<K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Promise<Map<K, V>>;
+    toSet(): Promise<Set<E>>;
+    write<S = string>(stream: WritableStream<S>): Promise<WritableStream<S>>;
+    write<S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): Promise<WritableStream<S>>;
+    write<S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): Promise<WritableStream<S>>;
+}
+export declare class AsynchronousOrderedCollectable<E> extends AsynchronousCollectable<E> {
+    protected readonly OrderedCollectable: symbol;
+    protected buffer: Array<Indexed<E>>;
+    protected listeners: Array<Consumer<Array<Indexed<E>>>>;
+    protected complete: boolean;
+    [Symbol.toStringTag]: string;
+    constructor(generator: AsynchronousGenerator<E>);
+    constructor(generator: AsynchronousGenerator<E>, comparator: Comparator<E>);
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    findAny(): Promise<E>;
+    findAt(index: number): Promise<E>;
+    findAt(index: bigint): Promise<E>;
+    findFirst(): Promise<E>;
+    findLast(): Promise<E>;
+    findMaximum(): Promise<E>;
+    findMaximum(comparator: Comparator<E>): Promise<E>;
+    findMinimum(): Promise<E>;
+    findMinimum(comparator: Comparator<E>): Promise<E>;
+    source(): AsynchronousGenerator<E>;
+    isEmpty(): Promise<boolean>;
+    count(): Promise<bigint>;
+}
+export declare class AsynchronousUnorderedCollectable<E> extends AsynchronousCollectable<E> {
+    protected readonly AsynchronousUnorderedCollectable: symbol;
+    [Symbol.toStringTag]: string;
+    protected buffer: Map<bigint, E>;
+    protected complete: boolean;
+    protected listeners: Array<Consumer<Map<bigint, E>>>;
+    constructor(generator: AsynchronousGenerator<E>);
+    source(): AsynchronousGenerator<E>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+}
+export declare abstract class AsynchronousStatistics<E, D extends number | bigint> extends AsynchronousOrderedCollectable<E> {
+    protected readonly AsynchronousStatistics: symbol;
+    [Symbol.toStringTag]: string;
+    constructor(generator: AsynchronousGenerator<E>);
+    constructor(generator: AsynchronousGenerator<E>, comparator: Comparator<E>);
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    abstract average(): Promise<D>;
+    abstract average(mapper: Functional<E, D>): Promise<D>;
+    abstract range(): Promise<D>;
+    abstract range(mapper: Functional<E, D>): Promise<D>;
+    abstract variance(): Promise<D>;
+    abstract variance(mapper: Functional<E, D>): Promise<D>;
+    abstract standardDeviation(): Promise<D>;
+    abstract standardDeviation(mapper: Functional<E, D>): Promise<D>;
+    abstract mean(): Promise<D>;
+    abstract mean(mapper: Functional<E, D>): Promise<D>;
+    abstract median(): Promise<D>;
+    abstract median(mapper: Functional<E, D>): Promise<D>;
+    abstract mode(): Promise<D>;
+    abstract mode(mapper: Functional<E, D>): Promise<D>;
+    frequency(): Promise<Map<E, bigint>>;
+    abstract summate(): Promise<D>;
+    abstract summate(mapper: Functional<E, D>): Promise<D>;
+    abstract quantile(quantile: number): Promise<D>;
+    abstract quantile(quantile: number, mapper: Functional<E, D>): Promise<D>;
+    abstract interquartileRange(): Promise<D>;
+    abstract interquartileRange(mapper: Functional<E, D>): Promise<D>;
+    abstract skewness(): Promise<D>;
+    abstract skewness(mapper: Functional<E, D>): Promise<D>;
+    abstract kurtosis(): Promise<D>;
+    abstract kurtosis(mapper: Functional<E, D>): Promise<D>;
+}
+export declare class AsynchronousBigIntStatistics<E> extends AsynchronousStatistics<E, bigint> {
+    protected readonly BigIntStatistics: symbol;
+    [Symbol.toStringTag]: string;
+    constructor(generator: AsynchronousGenerator<E>);
+    constructor(generator: AsynchronousGenerator<E>, comparator: Comparator<E>);
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    average(): Promise<bigint>;
+    average(mapper: Functional<E, bigint>): Promise<bigint>;
+    range(): Promise<bigint>;
+    range(mapper: Functional<E, bigint>): Promise<bigint>;
+    variance(): Promise<bigint>;
+    variance(mapper: Functional<E, bigint>): Promise<bigint>;
+    standardDeviation(): Promise<bigint>;
+    standardDeviation(mapper: Functional<E, bigint>): Promise<bigint>;
+    mean(): Promise<bigint>;
+    mean(mapper: Functional<E, bigint>): Promise<bigint>;
+    median(): Promise<bigint>;
+    median(mapper: Functional<E, bigint>): Promise<bigint>;
+    mode(): Promise<bigint>;
+    mode(mapper: Functional<E, bigint>): Promise<bigint>;
+    summate(): Promise<bigint>;
+    summate(mapper: Functional<E, bigint>): Promise<bigint>;
+    quantile(quantile: number): Promise<bigint>;
+    quantile(quantile: number, mapper: Functional<E, bigint>): Promise<bigint>;
+    interquartileRange(): Promise<bigint>;
+    interquartileRange(mapper: Functional<E, bigint>): Promise<bigint>;
+    skewness(): Promise<bigint>;
+    skewness(mapper: Functional<E, bigint>): Promise<bigint>;
+    kurtosis(): Promise<bigint>;
+    kurtosis(mapper: Functional<E, bigint>): Promise<bigint>;
+}
+export declare class AsynchronousNumericStatistics<E> extends AsynchronousStatistics<E, number> {
+    protected readonly AsynchronousNumericStatistics: symbol;
+    [Symbol.toStringTag]: string;
+    constructor(generator: AsynchronousGenerator<E>);
+    constructor(generator: AsynchronousGenerator<E>, comparator: Comparator<E>);
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    average(): Promise<number>;
+    average(mapper: Functional<E, number>): Promise<number>;
+    range(): Promise<number>;
+    range(mapper: Functional<E, number>): Promise<number>;
+    variance(): Promise<number>;
+    variance(mapper: Functional<E, number>): Promise<number>;
+    standardDeviation(): Promise<number>;
+    standardDeviation(mapper: Functional<E, number>): Promise<number>;
+    mean(): Promise<number>;
+    mean(mapper: Functional<E, number>): Promise<number>;
+    median(): Promise<number>;
+    median(mapper: Functional<E, number>): Promise<number>;
+    mode(): Promise<number>;
+    mode(mapper: Functional<E, number>): Promise<number>;
+    summate(): Promise<number>;
+    summate(mapper: Functional<E, number>): Promise<number>;
+    quantile(quantile: number): Promise<number>;
+    quantile(quantile: number, mapper: Functional<E, number>): Promise<number>;
+    interquartileRange(): Promise<number>;
+    interquartileRange(mapper: Functional<E, number>): Promise<number>;
+    skewness(): Promise<number>;
+    skewness(mapper: Functional<E, number>): Promise<number>;
+    kurtosis(): Promise<number>;
+    kurtosis(mapper: Functional<E, number>): Promise<number>;
+}
+export declare class AsynchronousWindowCollectable<E> extends AsynchronousOrderedCollectable<E> {
+    protected readonly WindowCollectable: symbol;
+    [Symbol.toStringTag]: string;
+    constructor(generator: AsynchronousGenerator<E>);
+    constructor(generator: AsynchronousGenerator<E>, comparator: Comparator<E>);
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    slide(size: bigint, step?: bigint): AsynchronousSemantic<AsynchronousSemantic<E>>;
+    tumble(size: bigint): AsynchronousSemantic<AsynchronousSemantic<E>>;
+}