import { Iterable } from 'ix';
import { Observable } from 'rxjs/Observable';
import { PartialObserver } from 'rxjs/Observer';
import { IScheduler } from 'rxjs/Scheduler';
import { Subscription, TeardownLogic } from 'rxjs/Subscription';
import { Command, Property } from './Interfaces';
export declare function filterNullIterable<TFiltered>(this: Iterable<TFiltered | undefined | null>, callbackfn?: (value: TFiltered, index: number) => boolean): Iterable<TFiltered>;
export declare function addSubscription<T extends TeardownLogic>(this: Subscription, subscription: T): T;
export declare function addSubscriptions<T extends TeardownLogic>(this: Subscription, ...subscriptions: T[]): T[];
export declare function unsubscribeStatic<T>(subscription: T, unsubscribedValue?: T): T;
export declare function filterNullObservable<T>(this: Observable<T | undefined | null>, callbackfn?: (value: T, index: number) => boolean): Observable<T>;
export declare function toProperty<T>(this: Observable<T>, initialValue?: T, compare?: boolean | ((x: T, y: T) => boolean), keySelector?: (x: T) => any): Property<T>;
export declare function observeCommand<T, TRet>(this: Observable<T>, command: ((x: T) => Command<TRet>) | Command<TRet>): Observable<TRet>;
export declare function invokeCommand<T, TRet>(this: Observable<T>, command: ((parameter: T) => Command<TRet>) | Command<TRet>, observer: PartialObserver<T>): Subscription;
export declare function invokeCommand<T, TRet>(this: Observable<T>, command: ((parameter: T) => Command<TRet>) | Command<TRet>, next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
declare module 'ix/iterable/iterablex' {
    interface IterableX<T> {
        filterNull: typeof filterNullIterable;
    }
}
declare module 'rxjs/Subscription' {
    interface Subscription {
        addSubscription: typeof addSubscription;
        addSubscriptions: typeof addSubscriptions;
    }
    namespace Subscription {
        let unsubscribe: typeof unsubscribeStatic;
    }
}
declare module 'rxjs/Observable' {
    interface Observable<T> {
        filterNull: typeof filterNullObservable;
        toProperty: typeof toProperty;
        observeCommand: typeof observeCommand;
        invokeCommand: typeof invokeCommand;
    }
}
declare module 'rxjs/operator/startWith' {
    function startWith<T, TOther>(this: Observable<T>, value: TOther, scheduler?: IScheduler): Observable<T | TOther>;
    function startWith<T, TOther>(this: Observable<T>, ...array: Array<TOther | IScheduler>): Observable<T | TOther>;
}