import { Last } from 'ts-toolbelt/out/List/Last';
import { Length } from 'ts-toolbelt/out/List/Length';
import { Pop } from 'ts-toolbelt/out/List/Pop';
import { Merge } from 'ts-toolbelt/out/Object/Merge';
import { ListOf } from 'ts-toolbelt/out/Union/ListOf';
/**
 * Handling iteration as if it were events.
 *
 * Every element "yield'd" from an iterator must be a binary tuple,
 * where the 1st element is a symbol (representing the event) and the 2nd
 * is the value "emitted".
 *
 * You may only have 1 handler for each event and the handler can return
 * something to the iterator if neccessary.
 *
 * @example
 * const Foo = Symbol('foo')
 * const Bar = Symbol('bar')
 *
 * type MyGenerator = Generator<
 *   | [typeof Foo, string]
 *   | [typeof Bar, number],
 *   any,
 *   undefined
 * >
 *
 * function* myGenerator(): MyGenerator {
 *   yield [Foo, 'foo']
 *   yield [Bar, 123]
 * }
 *
 * const handler = IteratorHandler
 *   .create(myGenerator())
 *   .handle(Foo, (value) => console.info(value))
 *   .handle(Bar, (num) => console.info(num))
 *   .run()
 */
export default class IteratorHandler<T extends [symbol, unknown], R> {
    #private;
    static create<T extends [symbol, unknown], R>(iterator: Gen<T, R>): IteratorHandler<T, R>;
    constructor(iterator: Gen<T, R>, handlers: Handlers<T>);
    handle<EventName extends keyof Events<T>>(eventName: EventName, handler: Handler<Events<T>[EventName]>): IteratorHandler<T, R>;
    run(): void;
}
type _Events<L extends readonly [symbol, unknown][], R extends Record<symbol, unknown>> = Length<L> extends 0 ? R : Last<L> extends [infer K, infer V] ? K extends symbol ? _Events<Pop<L>, Merge<R, Record<K, V>>> : never : never;
type Events<T extends [symbol, unknown]> = _Events<ListOf<T>, {}>;
type Handler<T> = (value: T) => any;
type Handlers<T extends [symbol, unknown]> = Partial<{
    [K in keyof Events<T>]: Handler<Events<T>[K]>;
}>;
type Gen<T extends [symbol, unknown], R> = Generator<T, any, R>;
export {};