import { Equals } from "@tsplus/stdlib/structure/Equals";
import { Hash } from "@tsplus/stdlib/structure/Hash";
import { Eval } from "@tsplus/stdlib/io/Eval/definition";
import { List } from "@tsplus/stdlib/collections/List/definition";
import { HashSet } from "@tsplus/stdlib/collections/HashSet/definition";
export declare const ParSeqSym: unique symbol;
export type ParSeqSym = typeof ParSeqSym;
export declare const _A: unique symbol;
export type _A = typeof _A;
/**
 * `ParSeq` is a data type that represents some notion of "events" that can
 * take place in parallel or in sequence. For example, a `ParSeq`
 * parameterized on some error type could be used to model the potentially
 * multiple ways that an application can fail. On the other hand, a `ParSeq`
 * parameterized on some request type could be used to model a collection of
 * requests to external data sources, some of which could be executed in
 * parallel and some of which must be executed sequentially.
 *
 * @tsplus type ParSeq
 */
export type ParSeq<A> = Empty | Single<A> | Then<A> | Both<A>;
/**
 * @tsplus type ParSeq.Ops
 */
export interface ParSeqOps {
    $: ParSeqAspects;
}
export declare const ParSeq: ParSeqOps;
/**
 * @tsplus type ParSeq.Aspects
 */
export interface ParSeqAspects {
}
/**
 * @tsplus type ParSeq/Empty
 */
export declare class Empty implements Equals {
    readonly _tag = "Empty";
    readonly [ParSeqSym]: ParSeqSym;
    readonly [_A]: () => never;
    [Equals.sym](that: unknown): boolean;
    [Hash.sym](): number;
    equalsSafe(that: ParSeq<unknown>): Eval<boolean>;
}
/**
 * @tsplus type ParSeq/Single
 */
export declare class Single<A> implements Equals {
    readonly a: A;
    readonly _tag = "Single";
    readonly [ParSeqSym]: ParSeqSym;
    readonly [_A]: () => A;
    constructor(a: A);
    [Equals.sym](that: unknown): boolean;
    [Hash.sym](): number;
    equalsSafe(that: ParSeq<unknown>): Eval<boolean>;
}
/**
 * @tsplus type ParSeq/Then
 */
export declare class Then<A> implements Equals {
    readonly left: ParSeq<A>;
    readonly right: ParSeq<A>;
    readonly _tag = "Then";
    readonly [ParSeqSym]: ParSeqSym;
    readonly [_A]: () => A;
    constructor(left: ParSeq<A>, right: ParSeq<A>);
    [Equals.sym](that: unknown): boolean;
    [Hash.sym](): number;
    equalsSafe(that: ParSeq<unknown>): Eval<boolean>;
    private eq;
}
/**
 * @tsplus type ParSeq/Both
 */
export declare class Both<A> implements Equals {
    readonly left: ParSeq<A>;
    readonly right: ParSeq<A>;
    readonly _tag = "Both";
    readonly [ParSeqSym]: ParSeqSym;
    readonly [_A]: () => A;
    constructor(left: ParSeq<A>, right: ParSeq<A>);
    [Equals.sym](that: unknown): boolean;
    [Hash.sym](): number;
    equalsSafe(that: ParSeq<unknown>): Eval<boolean>;
    private eq;
}
/**
 * Empty collection of events
 * @tsplus static ParSeq.Ops empty
 * @tsplus location "@tsplus/stdlib/collections/ParSeq/definition"
 */
export declare function empty<A = never>(): ParSeq<A>;
/**
 * Constructs a new collection of events that contains the specified event.
 * @tsplus static ParSeq.Ops single
 * @tsplus location "@tsplus/stdlib/collections/ParSeq/definition"
 */
export declare function single<A>(a: A): ParSeq<A>;
/**
 * Combines this collection of events with that collection of events to
 * return a new collection of events that represents this collection of
 * events in parallel with that collection of events.
 * @tsplus static ParSeq.Ops combinePar
 * @tsplus location "@tsplus/stdlib/collections/ParSeq/definition"
 */
export declare function combinePar_<A, A1>(left: ParSeq<A>, right: ParSeq<A1>): ParSeq<A | A1>;
/**
 * Combines this collection of events with that collection of events to
 * return a new collection of events that represents this collection of
 * events in parallel with that collection of events.
 *
 * @tsplus static ParSeq.Aspects combinePar
 */
export declare const combinePar: <A1>(right: ParSeq<A1>) => <A>(left: ParSeq<A>) => ParSeq<A | A1>;
/**
 * Combines this collection of events with that collection of events to
 * return a new collection of events that represents this collection of
 * events followed by that collection of events.
 * @tsplus static ParSeq.Ops combineSeq
 * @tsplus location "@tsplus/stdlib/collections/ParSeq/definition"
 */
export declare function combineSeq_<A, A1>(left: ParSeq<A>, right: ParSeq<A1>): ParSeq<A | A1>;
/**
 * Combines this collection of events with that collection of events to
 * return a new collection of events that represents this collection of
 * events followed by that collection of events.
 *
 * @tsplus static ParSeq.Aspects combineSeq
 */
export declare const combineSeq: <A1>(right: ParSeq<A1>) => <A>(left: ParSeq<A>) => ParSeq<A | A1>;
/**
 * @tsplus static ParSeq.Ops isParSeq
 * @tsplus location "@tsplus/stdlib/collections/ParSeq/definition"
 */
export declare function isParSeq(u: unknown): u is ParSeq<unknown>;
/**
 * Checks if the ParSeq is empty.
 * @tsplus getter ParSeq isEmpty
 * @tsplus location "@tsplus/stdlib/collections/ParSeq/definition"
 */
export declare function isEmpty<A>(self: ParSeq<A>): boolean;
//# sourceMappingURL=definition.d.ts.map