API @deepkit/workflow

export class WorkflowEvent extends BaseEvent {
    nextState?: any;
    nextStateEvent?: any;
    clearNext();
    /**
     * @see WorkflowNextEvent.next
     */
    next(nextState: string, event?: any);
    hasNext(): boolean;
}

export class WorkflowDefinition<T extends WorkflowPlaces> {
    transitions: WorkflowTransition<T>[];
    tokens: {
        [name in keyof T]?: EventToken<any>;
    };
    next: {
        [name in keyof T]?: (keyof T & string)[];
    };
    symbol;
    constructor(public readonly name: string, public readonly places: T, transitions: WorkflowTransitions<T> = {});
    getEventToken<K extends keyof T>(name: K): EventToken<ExtractClassType<T[K]>>;
    addTransition(from: keyof T & string, to: keyof T & string, label?: string);
    create(state: keyof T & string, eventDispatcher: EventDispatcher, injector?: InjectorContext, stopwatch?: Stopwatch): Workflow<T>;
    getTransitionsFrom(state: keyof T & string): (keyof T & string)[];
    buildApplier(eventDispatcher: EventDispatcher);
}

export class WorkflowStateSubject<T extends WorkflowPlaces> implements WorkflowState<T> {
    constructor(public value: keyof T & string);
    get();
    set(v: keyof T & string);
}

export class Workflow<T extends WorkflowPlaces> {
    constructor(public definition: WorkflowDefinition<T>, public state: WorkflowState<T>, private eventDispatcher: EventDispatcher, private injector: InjectorContext, private stopwatch?: Stopwatch);
    can(nextState: keyof T & string): boolean;
    /**
     * @throws WorkflowError when next state is not possible to apply.
     */
    apply<K extends keyof T>(nextState: K, event?: ExtractClassType<T[K]>): Promise<void>;
    isDone(): boolean;
}

export class WorkflowError extends CustomError {
}

<T extends WorkflowPlaces>(name: string, definition: T, transitions?: WorkflowTransitions<T>): WorkflowDefinition<T> & WorkflowDefinitionEvents<T>

type WorkflowPlaces = { [name: string]: ClassType<WorkflowEvent> };

interface WorkflowNextEvent<T extends WorkflowPlaces> {
    nextState?: keyof T & string;

    /**
     * Schedule to apply the next workflow step when all event listeners have been called.
     */
    next<S extends keyof T & string>(nextState: S, event?: ExtractClassType<T[S]>): void;
}

type WorkflowDefinitionEvents<T extends WorkflowPlaces> = {
    [K in keyof T & string as `on${Capitalize<K>}`]: EventToken<BaseEvent & Omit<ExtractClassType<T[K]>, 'next' | 'nextState'> & WorkflowNextEvent<T>>
}

interface WorkflowState<T> {
    get(): keyof T & string;

    set(v: keyof T & string): void;
}