import { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';
import { PartialObserver } from 'rxjs/Observer';
import { Command, ObservableOrValue } from './Interfaces';
export declare type ExecutionAction<T = any> = (parameter: any) => ObservableOrValue<T>;
export declare type InterrogationAction<T = any> = (condition: T, parameter?: any) => boolean;
export declare class ObservableCommand<T = any, TCondition = any> extends Subscription implements Command<T, TCondition> {
    protected readonly executeAction: ExecutionAction<T>;
    protected readonly interrogationAction: InterrogationAction<TCondition | undefined>;
    private condition;
    private initialCondition;
    static coerceCondition<T>(condition: T): boolean;
    protected isExecutingSubject: BehaviorSubject<boolean>;
    protected conditionSubject: BehaviorSubject<TCondition | undefined>;
    protected canExecuteSubject: BehaviorSubject<boolean>;
    protected requestsSubject: Subject<any>;
    protected resultsSubject: Subject<T>;
    protected thrownErrorsSubject: Subject<Error>;
    constructor(executeAction: ExecutionAction<T>, interrogationAction?: InterrogationAction<TCondition | undefined>, condition?: Observable<TCondition> | undefined, initialCondition?: TCondition | undefined);
    readonly isExecutingObservable: Observable<boolean>;
    readonly isExecuting: boolean;
    readonly conditionObservable: Observable<TCondition | undefined>;
    readonly canExecuteObservable: Observable<boolean>;
    readonly conditionValue: TCondition | undefined;
    readonly canExecute: boolean;
    isCommand(): boolean;
    canExecuteFor(parameter: any): boolean;
    observeExecution(parameter?: any): Observable<T>;
    execute(parameter?: any, observer?: PartialObserver<T>): Subscription;
    execute(parameter?: any, next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
    readonly requests: Observable<any>;
    readonly results: Observable<T>;
    readonly thrownErrors: Observable<Error>;
}
export declare function command<T = any>(): Command<T>;
export declare function command<T>(execute: ExecutionAction<T>): Command<T>;
export declare function command<T>(canExecute: Observable<boolean>, execute?: ExecutionAction<T>): Command<T>;
export declare function command<T>(execute: ExecutionAction<T>, canExecute: Observable<boolean>): Command<T>;
export declare function command<T, TCondition>(execute: ExecutionAction<T>, condition: Observable<TCondition>, interrogation: InterrogationAction<TCondition>, initialCondition?: TCondition): Command<T>;