import { Context, UseCase } from "almin";
import { DuplicateChecker } from "./DuplicateChecker";
export declare type Construct<T> = {
    new (...args: any[]): T;
};
export declare type Factory<T, Command = any> = (command: Command) => T;
export interface UseCaseBinderArgs<T, P> {
    context: Context<any>;
    CommandConstructors: T[];
    useCaseFactories: P[];
    duplicateChecker: DuplicateChecker;
}
export declare class UseCaseBinder<Command, P extends Factory<UseCase, any>> {
    private context;
    private CommandConstructors;
    private useCaseFactories;
    private duplicateChecker;
    private hasDelegateNewBiding;
    constructor(args: UseCaseBinderArgs<Construct<Command>, P>);
    /**
     * Bind the `CommandConstructor` to `useCase` instance.
     */
    bind<K extends Construct<Command>, V extends UseCase>(CommandConstructor: K, useCase: V): UseCaseBinder<K | Command, Factory<V> | P>;
    /**
     * Bind the `CommandConstructor` to `useCaseFactory`.
     * `useCaseFactory` is factory function to create a UseCase instance.
     */
    bindFactory<K extends Construct<Command>, V extends Factory<UseCase, any>>(CommandConstructor: K, useCaseFactory: V): UseCaseBinder<K | Command, V | P>;
    send(command: Command): Promise<void>;
    private releaseBinding;
}
/**
 * A mediator for UseCase and Command.
 * A UseCase is almin's UseCase implementation.
 * A Command is UseCase#execute
 *
 * @example
 *
 * ```
 * const container = UseCaseCommandBus
 *      .create(context)
 *      .bind(CommandA, new UseCaseA())
 *      .bind(CommandB, new UseCaseB());
 * container.send(new TestCommandA())
 *   .then(() => {})
 *   .catch(error => {});
 * ```
 *
 *
 */
export declare class UseCaseCommandBus {
    static create(context: Context<any>): UseCaseBinder<{}, never>;
}