import { Observable, OperatorFunction } from 'rxjs';
export interface Action<T> {
    /** Make sure that the `type` is globally unique. */
    type: string;
    value: T;
}
export declare type ActionStream = Observable<Action<any>>;
export declare type ActionReducer<T> = (state: T, action: Action<any>) => T;
export declare type ValueReducer<T, A = any> = (state: T, value: A) => T;
export declare type StreamToState<T> = (action$: ActionStream) => Observable<T>;
export declare type ActionHandlerMap<T> = Record<string, ValueReducer<T>>;
/** Wrapper for creating `Action<T>`s. */
export interface Actor<T> {
    type: string;
    new: (value: T) => Action<T>;
}
/** Similar to Redux store. */
export interface Store<T> {
    action$: ActionStream;
    state$: Observable<T>;
    getState(): T;
    dispatch(action: Action<any>): void;
    destruct(): void;
}
/** Helper: testing content equality. */
export declare const jsonEqual: <T>(aa: T, bb: T) => boolean;
/** Helper: to use in place of `val => !!val`. */
export declare const forceBool: (val: boolean) => boolean;
/** Helper: to use in place of `val => +val`. */
export declare const forceNum: (val: number) => number;
/** Helper: to use in place of `val => val || orValue`. */
export declare const or_: <T>(orValue: T) => (val: T) => T;
/** Helper: to use in place of `val => val || []`. */
export declare const orArray: <T>(val: T[]) => T[];
/** Helper: to use in place of `val => val || null`. */
export declare const orNull: <T>(val: T) => T;
/** Helper: to use in place of `val => val || {}`. */
export declare const orObject: <T extends object>(val: T) => T;
/** Helper: to use in place of `val => val || 0`. */
export declare const orZero: (val: number) => number;
/** Sets `state[key] = value` if not identical and returns as new state. */
export declare const setPropertyIfNotSame: <T extends object, K extends keyof T>(state: T, key: K, value: T[K]) => T;
/** Returns a reducer based on `setPropertyIfNotSame`. */
export declare const redSetPropertyIfNotSame_: <T extends object, K extends keyof T>(key: K) => ValueReducer<T, T[K]>;
/** Sets `state[key] = value` if not content-equal and returns as new state. */
export declare const setPropertyIfNotEqual: <T extends object, K extends keyof T>(state: T, key: K, value: T[K]) => T;
/** Returns a reducer based on `setPropertyIfNotEqual`. */
export declare const redSetPropertyIfNotEqual_: <T extends object, K extends keyof T>(key: K) => ValueReducer<T, T[K]>;
/** Reducer for setting `value` as new state. */
export declare const redSet: <T extends object>(state: T, value: T) => T;
/** Reducer for merging `value` into `state` as new state. */
export declare const redMerge: <T extends object>(state: T, value: T) => T;
/** Returns a reducer which merges the `value` into the `state[key]` as new state. */
export declare const redMergeProperty_: <T extends object, K extends keyof T>(key: K) => ValueReducer<T, T[K]>;
/**
 * Returns a reducer built from a map of `Action` handlers.
 * @example
 * interface Test { a?: number, b?: string, c?: boolean };
 * ...
 * const red_test = reducers_<Test>({
 *   'IncrementValueIntoA': (state, val: number) => ({ ...state, a: val + 1 }),
 *   [act_set_b.type]: redSet,
 *   [act_set_c.type]: redSetPropertyIfNotSame_('c'),
 * });
 */
export declare const reducers_: <T>(actionTypeToHandler: Record<string, ValueReducer<T, any>>) => ActionReducer<T>;
/**
 * Creates an `Actor` with type concatenated from the `type: string[]` parameter.
 * @example
 * const STATE = 'ui';
 * const STATE_GLOBAL = 'global';
 * const set_locale = actor<string>('SET', STATE, STATE_GLOBAL, 'locale');
 * ...
 * const act_set_locale = rxState.act_(set_locale);
 * ...
 * act_set_locale('en_US');
 */
export declare const actor: <T>(...type: string[]) => Actor<T>;
/**
 * Creates a state Observable emitting new state from scanning the `action$` stream.
 * @example
 * interface Test { a?: number, b?: string, c?: boolean };
 * const action$ = new Subject<Action<any>>();
 * const state$ = toState$(action$, <Test>{ a: 0, b: '', c: false }, { 'ActMerge': redMerge });
 */
export declare const toState$: <T>(action$: ActionStream, init: T, reduce: ActionReducer<T> | Record<string, ValueReducer<T, any>>) => Observable<T>;
/**
 * Returns a creator for a state Observable emitting new state from scanning the `action$` stream.
 * @example
 * interface Test { a?: number, b?: string, c?: boolean };
 * const state$_ = toState$_(<Test>{ a: 0, b: '', c: false }, { 'ActMerge': redMerge });
 * ...
 * const state$ = state$_(action$);
 */
export declare const toState$_: <T>(init: T, reduce: ActionReducer<T> | Record<string, ValueReducer<T, any>>) => (action$: ActionStream) => Observable<T>;
/**
 * Assembles a state Observable emitting new state from combining a `base` object or Observable and `parts` values or Observables which relate to the `base` keys.
 * *WARNING: a nested state from `parts` should not be reduced in the `base` if the `base` is an Observable.*
 * @example
 * interface TestNested { a?: number, b?: string, c?: boolean };
 * interface Test { a?: TestNested, b?: string };
 * const action$ = new Subject<Action<any>>();
 * const state_nested$ = toState$(action$, <TestNested>{ a: 0, b: 'nested', c: false }, { 'ActMerge': redMerge });
 * const state_parent$ = toState$(action$, <Test>{ a: null, b: 'parent' }, { 'ActSetB': redSetPropertyIfNotSame_('b') });
 * const state$ = assemble$(state_parent$, { 'a': state_nested$ });
 */
export declare const assemble$: <T extends object>(base: T | Observable<T>, parts?: Partial<{ [K in keyof T]: T[K] | Observable<T[K]>; }>) => Observable<T>;
/**
 * Returns a creator for assembling a state Observable emitting new state from combining a `base` object or Observable and `parts` values
 * or Observables which relate to the `base` keys.
 * *WARNING: a nested state from `parts` should not be reduced in the `base` if the `base` is an Observable.*
 * @example
 * interface TestNested { a?: number, b?: string, c?: boolean };
 * interface Test { a?: TestNested, b?: string };
 * const state_nested$_ = toState$_(<TestNested>{ a: 0, b: 'nested', c: false }, { 'ActMerge': redMerge });
 * const state_parent$_ = toState$_(<Test>{ a: null, b: 'parent' }, { 'ActSetB': redSetPropertyIfNotSame_('b') });
 * const state$_ = assemble$_(state_parent$_, { 'a': state_nested$_ });
 * ...
 * const state$ = state$_(action$);
 */
export declare const assemble$_: <T extends object>(base: T | StreamToState<T>, parts?: { [K in keyof T]: T[K] | StreamToState<T[K]>; }) => (action$: ActionStream) => Observable<T>;
/**
 * Creates a state Observable (from init object, reducers and nested parts) emitting new state from scanning the `action$` stream.
 * @example
 * interface TestNested { c?: number };
 * interface Test { a?: TestNested, b?: string };
 * const action$ = new Subject<Action<any>>();
 * const state_nested$ = initReduceAssemble$(action$, <TestNested>{ c: 0 }, { 'ActSetC': redSetPropertyIfNotSame_('c') });
 * const state$ = initReduceAssemble$(action$, <Test>{ a: null, b: 'parent' }, { 'ActSetB': redSetPropertyIfNotSame_('b') }, { a: state_nested$ });
 */
export declare const initReduceAssemble$: <T extends object>(action$: ActionStream, init: T, reduce: ActionReducer<T> | Record<string, ValueReducer<T, any>>, parts?: { [K in keyof T]: T[K] | Observable<T[K]>; }) => Observable<T>;
/**
 * Returns a creator for a state Observable (from init object, reducers and nested parts) emitting new state from scanning the `action$` stream.
 * @example
 * interface TestNested { c?: number };
 * interface Test { a?: TestNested, b?: string };
 * const state_nested$_ = initReduceAssemble$_(<TestNested>{ c: 0 }, { 'ActSetC': redSetPropertyIfNotSame_('c') });
 * const state$_ = initReduceAssemble$_(<Test>{ a: null, b: 'parent' }, { 'ActSetB': redSetPropertyIfNotSame_('b') }, { a: state_nested$_ });
 * ...
 * const state$ = state$_(action$);
 */
export declare const initReduceAssemble$_: <T extends object>(init: T, reduce: ActionReducer<T> | Record<string, ValueReducer<T, any>>, parts?: { [K in keyof T]: T[K] | StreamToState<T[K]>; }) => (action$: ActionStream) => Observable<T>;
declare class StoreImpl<T> implements Store<T> {
    private readonly createState;
    constructor(createState: StreamToState<T>);
    private state;
    private readonly actionIn$;
    readonly action$: Observable<Action<any>>;
    readonly state$: Observable<T>;
    getState(): T;
    dispatch(action: Action<any>): void;
    destruct(): void;
}
/**
 * `Store` factory.
 * @example
 * const state$_ = assemble$_(...);
 * ...
 * const store = createStore(state$_);
 */
export declare const createStore: <T>(createState: StreamToState<T>) => StoreImpl<T>;
/**
 * Helper function for watching substates.
 *
 * @param selector mapper function e.g. `st => st.ui.enabled`
 *
 * @example
 * enabled$ = this.stateService.state$.pipe(watch(st => st.ui.enabled));
 */
export declare function watch<T, R>(selector: (state: T) => R): OperatorFunction<T, R>;
/**
 * Helper class for wrapping the `Store` by watching and setting the state.
 * @example
 * const set_locale = actor<string>('SET', STATE, STATE_GLOBAL, 'locale');
 * ...
 * const state$_ = assemble$_(...);
 * ...
 * const store = createStore(state$_);
 * const rxState = new RxState(store);
 * const act_set_locale = rxState.act_(set_locale);
 * ...
 * rxState.state$.pipe(select(st => st.ui.global.locale)).subscribe(locale => console.log('Locale changed to ' + locale));
 * ...
 * act_set_locale('en_US');
 */
export declare class RxState<S> {
    protected readonly store: Store<S>;
    constructor(store: Store<S>);
    private readonly done$;
    private readonly currentState$;
    /** Reactive state (use with `.pipe(select(...))` operator) */
    readonly state$: Observable<S>;
    /** Synchronized state value. */
    getState: () => S;
    destroy(): void;
    /** For debugging/testing. */
    dbgGetStore: () => Store<S>;
    /**
     * Dispatch an `Action` using an `Actor`, typesafe value and optionally a pre-`transform` function.
     * @example
     * const set_locale = actor<string>('SET', STATE, STATE_GLOBAL, 'locale');
     * ...
     * rxState.act(set_locale, newCurrentLocale, or_('en_US'));
     */
    act: <T>(act: Actor<T>, value: T, transform?: (val: T) => T) => void;
    /**
     * Create a dispatcher of an `Action` using an `Actor` optionally a pre-`transform` function.
     * @example
     * const set_locale = actor<string>('SET', STATE, STATE_GLOBAL, 'locale');
     * ...
     * const act_set_locale = rxState.act_(set_locale, or_('en_US'));
     * ...
     * act_set_locale(newCurrentLocale);
     */
    act_: <T>(act: Actor<T>, transform?: (val: T) => T) => (value: T) => void;
}
export {};