import { IsNever, WhenNever } from './Basics';
import Either from './Either';
import * as Scheduler from './Scheduler';
export declare class Router<AppMsg, SelfMsg> {
    private readonly process;
    private readonly dispatch;
    constructor(process: Scheduler.Process<never, unknown, IM<AppMsg, SelfMsg>>, dispatch: (msg: AppMsg) => void);
    sendToApp(msg: AppMsg): Task<never, void>;
    sendToSelf(msg: SelfMsg): Task<never, void>;
}
export interface Manager<AppMsg = unknown, SelfMsg = unknown, State = unknown> {
    init: Task<never, State>;
    onEffects(router: Router<AppMsg, SelfMsg>, commands: Array<Cmd<AppMsg>>, subscriptions: Array<Sub<AppMsg>>, state: State): Task<never, State>;
    onSelfMsg(router: Router<AppMsg, SelfMsg>, msg: SelfMsg, state: State): Task<never, State>;
}
interface Effects<AppMsg> {
    commands: Array<Cmd<AppMsg>>;
    subscriptions: Array<Sub<AppMsg>>;
}
declare abstract class Bag<T> {
    static gather<T>(sequence: Array<Manager>, effectDict: WeakMap<Manager, Effects<T>>, bag: Bag<T>): void;
    abstract map<R>(fn: (effect: T) => R): Bag<R>;
    protected abstract gather(sequence: Array<Manager>, effectDict: WeakMap<Manager, Effects<T>>): void;
}
export declare abstract class Cmd<T> extends Bag<T> {
    static readonly none: Cmd<never>;
    static batch<T>(cmds: Array<Cmd<T>>): Cmd<T>;
    protected abstract readonly manager: Manager<T>;
    abstract map<R>(fn: (effect: T) => R): Cmd<R>;
    protected gather(sequence: Array<Manager>, effectDict: WeakMap<Manager, Effects<T>>): void;
}
export declare abstract class Sub<T> extends Bag<T> {
    static readonly none: Sub<never>;
    static batch<T>(cmds: Array<Sub<T>>): Sub<T>;
    protected abstract readonly manager: Manager<T>;
    abstract map<R>(fn: (effect: T) => R): Sub<R>;
    protected gather(sequence: Array<Manager>, effectDict: WeakMap<Manager, Effects<T>>): void;
}
declare abstract class IM<AppMsg, SelfMsg> {
    abstract step<State>(manager: Manager<AppMsg, SelfMsg, State>, router: Router<AppMsg, SelfMsg>, state: State): Task<never, State>;
}
export declare class Worker<Model, Msg> {
    private readonly update;
    private readonly subscriptions;
    private model;
    private readonly runtime;
    private readonly subscribers;
    constructor([initialModel, initialCmd]: [Model, Cmd<Msg>], update: (msg: Msg, model: Model) => [Model, Cmd<Msg>], subscriptions: (model: Model) => Sub<Msg>);
    getModel(): Model;
    dispatch(msg: Msg): void;
    subscribe(subscriber: () => void): () => void;
}
export declare class Program<Flags, Model, Msg> {
    private readonly init_;
    private readonly update;
    private readonly subscriptions;
    static worker<Flags, Model, Msg>(config: {
        init(flags: Flags): [Model, Cmd<Msg>];
        update(msg: Msg, model: Model): [Model, Cmd<Msg>];
        subscriptions(model: Model): Sub<Msg>;
    }): Program<Flags, Model, Msg>;
    private constructor();
    init(flags: Flags): Worker<Model, Msg>;
}
export declare class Task<E, T> {
    protected internal: Scheduler.Task<E, T>;
    static succeed<T>(value: T): Task<never, T>;
    static fail<E>(error: E): Task<E, never>;
    static sequence<E, T>(tasks: Array<Task<E, T>>): Task<E, Array<T>>;
    static binding<E, T>(callback: (done: (task: Task<E, T>) => void) => void | (() => void)): Task<E, T>;
    constructor(internal: Scheduler.Task<E, T>);
    map<R>(fn: (value: T) => R): Task<E, R>;
    chain<G, R>(fn: (value: T) => Task<WhenNever<E, G>, R>): Task<WhenNever<E, G>, R>;
    mapError<S>(fn: (error: E) => S): Task<S, T>;
    onError<G, S>(fn: (error: E) => Task<S, WhenNever<T, G>>): Task<S, WhenNever<T, G>>;
    perform<Msg>(tagger: IsNever<E, (value: T) => Msg, never>): Cmd<Msg>;
    attempt<Msg>(tagger: (either: Either<E, T>) => Msg): Cmd<Msg>;
    spawn(): Task<never, Process>;
    execute(): Scheduler.Task<E, T>;
}
export declare class Process {
    protected readonly internal: Scheduler.Process;
    static sleep(time: number): Task<never, void>;
    constructor(internal: Scheduler.Process);
    kill(): Task<never, void>;
    execute(): Scheduler.Process;
}
export {};