import { Observable, Observer, Subscription, TeardownLogic } from 'rxjs';
import { Action } from './action';
import { Controller } from './controller';
import { Effect, EffectHandler, EffectOptions } from './effect';
import { Query } from './query';
import { Store, StoreOptions } from './store';
import { AnyObject } from './utils';
/**
 * A controller-like boundary for effects and business logic.
 *
 * `Scope` collects all subscriptions which are made by child entities and provides
 * `destroy()` method to unsubscribe from them.
 */
export type Scope = Controller<{
    /**
     * Register subscription-like or teardown function to be called with
     * `destroy()` method.
     */
    add: (teardown: TeardownLogic) => void;
    /**
     * Creates a store which will be destroyed with the scope.
     *
     * @param initialState Initial state
     * @param options Parameters for the store
     */
    createStore<State>(initialState: State, options?: StoreOptions<State>): Store<State>;
    /**
     * Creates a controller which will be destroyed with the scope.
     */
    createController: <ControllerProps extends AnyObject = AnyObject>(factory: () => Controller<ControllerProps>) => Controller<ControllerProps>;
    /**
     * Creates an effect which will be destroyed with the scope.
     */
    createEffect: <Event = void, Result = void, ErrorType = Error>(handler: EffectHandler<Event, Result>, options?: EffectOptions<Event, Result>) => Effect<Event, Result, ErrorType>;
    /**
     * Creates an effect which handles `source` by `handler`, and it will be
     * destroyed with the scope.
     */
    handle: <Event, Result = void, ErrorType = Error>(source: Observable<Event> | Action<Event> | Query<Event>, handler: EffectHandler<Event, Result>, options?: EffectOptions<Event, Result>) => Effect<Event, Result, ErrorType>;
    /**
     * Subscribes to the `source` observable until the scope will be destroyed.
     */
    subscribe: {
        <T>(source: Observable<T>): Subscription;
        <T>(source: Observable<T>, next: (value: T) => void): Subscription;
        <T>(source: Observable<T>, observer: Partial<Observer<T>>): Subscription;
    };
}>;
/**
 * `ExternalScope` and `Scope` types allow to distinct which third-party code can invoke `destroy()` method.
 */
export type ExternalScope = Omit<Scope, 'destroy'>;
/**
 * Creates `Scope` instance.
 */
export declare function createScope(): Scope;