import { Subscribable, Observable, Subscription, Subject, BehaviorSubject, SchedulerLike, MonoTypeOperatorFunction, OperatorFunction, UnaryFunction } from 'rxjs';

type AccumulationFn = <T>(st: T, sl: Partial<T>) => T;
interface Accumulator<T> extends Subscribable<T> {
    state: T;
    state$: Observable<T>;
    signal$: Observable<T>;
    subscribe: () => Subscription;
    nextSlice: (stateSlice: Partial<T>) => void;
    nextSliceObservable: (state$: Observable<Partial<T>>) => void;
    nextAccumulator: (fn: AccumulationFn) => void;
}

declare const defaultAccumulator: AccumulationFn;
declare function createAccumulationObservable<T extends object>(stateObservables?: Subject<Observable<Partial<T>>>, stateSlices?: Subject<Partial<T>>, accumulatorObservable?: BehaviorSubject<AccumulationFn>, scheduler?: SchedulerLike | null): Accumulator<T>;

/**
 * @description
 * The function which is used by `KeyCompareMap` to determine if changes are distinct or not.
 * Should return true if values are equal.
 *
 * @param {T} oldVal
 * @param {T} newVal
 *
 * @return boolean
 *
 * @docsPage interfaces
 * @docsCategory operators
 */
type CompareFn<T> = (oldVal: T, newVal: T) => boolean;

/**
 * @description
 * The `KeyCompareMap` is used to configure custom comparison for defined keys.
 *
 * @example
 * const keyCompareMap = {
 *    myKey: (o, n) => customCompare(o, n)
 *  };
 *  const o$ = of({
 *    myKey: 5,
 *    myOtherKey: 'bar'
 *  }).pipe(distinctUntilSomeChanged(['myKey', 'myOtherKey'], keyCompareMap));
 *
 *  //or
 *
 *  const o$ = of({
 *    myKey: 5,
 *    myOtherKey: 'bar'
 *  }).pipe(selectSlice(['myKey', 'myOtherKey'], keyCompareMap));
 *
 * @docsPage interfaces
 * @docsCategory operators
 */
type KeyCompareMap<T extends object> = {
    [K in keyof Partial<T>]: CompareFn<T[K]>;
};

type NonUndefined<T> = T extends undefined ? never : T;

type PickSlice<T extends object, K extends keyof T> = Pick<T, {
    [I in K]: I;
}[K]>;

/**
 * @description
 *
 * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from
 * the previous item. Comparison will be done for each set key in the `keys` array.
 *
 * You can fine grain your distinct checks by providing a `KeyCompareMap` with those keys you want to compute
 * explicitly different
 *
 * The name `distinctUntilSomeChanged` was picked since it internally iterates over the `keys` and utilizes the
 * [some](https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Array/some) method in order to
 * compute if values are distinct or not.
 *
 * @example
 *
 * import { of } from 'rxjs';
 * import { distinctUntilSomeChanged } from 'rx-angular/state';
 *
 * interface Person {
 *    age: number;
 *    name: string;
 * }
 *
 * of(
 *   { age: 4, name: 'Hans'},
 *   { age: 7, name: 'Sophie'},
 *   { age: 5, name: 'Han Solo'},
 *   { age: 5, name: 'HanSophie'},
 * ).pipe(
 *   distinctUntilSomeChanged(['age', 'name']),
 * )
 * .subscribe(x => console.log(x));
 *
 * // displays:
 * // { age: 4, name: 'Hans'}
 * // { age: 7, name: 'Sophie'}
 * // { age: 5, name: 'Han Solo'}
 * // { age: 5, name: 'HanSophie'}
 *
 * @example
 * // An example with `KeyCompareMap`
 * import { of } from 'rxjs';
 * import { distinctUntilSomeChanged } from 'rxjs/operators';
 *
 * interface Person {
 *     age: number;
 *     name: string;
 *  }
 * const customComparison: KeyCompareMap<Person> = {
 *   name: (oldName, newName) => oldName.substring(0, 2) === newName.substring(0, 2)
 * };
 *
 * of(
 *     { age: 4, name: 'Hans'},
 *     { age: 7, name: 'Sophie'},
 *     { age: 5, name: 'Han Solo'},
 *     { age: 5, name: 'HanSophie'},
 *   ).pipe(
 *     distinctUntilSomeChanged(['age', 'name'], customComparison),
 *   )
 *   .subscribe(x => console.log(x));
 *
 * // displays:
 * // { age: 4, name: 'Hans' }
 * // { age: 7, name: 'Sophie' }
 * // { age: 5, name: 'Han Solo' }
 *
 * @param {K[]} keys String key for object property lookup on each item.
 * @param {KeyCompareMap<T>} [keyCompareMap] Optional KeyCompareMap to explicitly define comparisons for some of the keys
 * @docsPage distinctUntilSomeChanged
 * @docsCategory operators
 */
declare function distinctUntilSomeChanged<T extends object, K extends keyof T>(keys: K[], keyCompareMap?: KeyCompareMap<T>): MonoTypeOperatorFunction<T>;

/**
 * @description
 * Returns the state as shared, replayed and distinct `Observable<T>`. This way you don't have to think about late
 * subscribers, multiple subscribers or multiple emissions of the same value.
 *
 * @example
 * const state$ = state.pipe(select());
 * state$.subscribe(state => doStuff(state));
 *
 * @returns Observable<T>
 */
declare function select<T>(): MonoTypeOperatorFunction<T>;
/**
 * @description
 * Returns the state as cached and distinct `Observable<A>`. Accepts arbitrary
 * [rxjs operators](https://rxjs-dev.firebaseapp.com/guide/operators) to enrich the selection with reactive composition.
 *
 * @example
 * const profilePicture$ = state.pipe(
 *   select(
 *    map(state => state.profilePicture),
 *    switchMap(profilePicture => mapImageAsync(profilePicture))
 *   )
 * );
 * @param  { OperatorFunction<T, A> } op
 * @returns Observable<A>
 *
 * @docsPage select
 * @docsCategory operators
 */
declare function select<T, A>(op: OperatorFunction<T, A>): OperatorFunction<T, A>;
/**
 * @internal
 */
declare function select<T, A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): OperatorFunction<T, B>;
/**
 * @internal
 */
declare function select<T, A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): OperatorFunction<T, C>;
/**
 * @internal
 */
declare function select<T, A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): OperatorFunction<T, D>;
/**
 * @internal
 */
declare function select<T, A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): OperatorFunction<T, E>;
/**
 * @description
 * Transform a slice of the state by providing keys and map function.
 * Returns result of applying function to state slice as cached and distinct `Observable<R>`.
 *
 * @example
 * // Project state slice
 * const text$ = state$.pipe(
 *   select(
 *     ['query', 'results'],
 *     ({ query, results }) => `${results.length} results found for "${query}"`
 *   )
 * );
 *
 * @return Observable<R>
 */
declare function select<T extends object, K extends keyof T, R>(keys: K[], fn?: (slice: PickSlice<T, K>) => R, keyCompareMap?: KeyCompareMap<Pick<T, K>>): OperatorFunction<T, R>;
/**
 * @description
 * Transform a single property of the state by providing a key and map function.
 * Returns result of applying function to state property as cached and distinct `Observable<T[R]>`.
 *
 * @example
 * // Project state based on single property
 * const foo$ = state$.pipe(select('bar', bar => `bar equals ${bar}`));
 *
 * @return Observable<R>
 */
declare function select<T, K extends keyof T, R>(k: K, fn: (val: T[K]) => R): OperatorFunction<T, R>;
/**
 * @description
 * Access a single property of the state by providing keys.
 * Returns a single property of the state as cached and distinct `Observable<T[K1]>`.
 *
 * @example
 * // Access a single property
 * const bar$ = state$.pipe(select('bar'));
 *
 * // Access a nested property
 * const foo$ = state$.pipe(select('bar', 'foo'));
 *
 * @return Observable<T[K1]>
 */
declare function select<T, K1 extends keyof T>(k1: K1): OperatorFunction<T, T[K1]>;
/**
 * @internal
 */
declare function select<T, K1 extends keyof T, K2 extends keyof T[K1]>(k1: K1, k2: K2): OperatorFunction<T, T[K1][K2]>;
/**
 * @internal
 */
declare function select<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(k1: K1, k2: K2, k3: K3): OperatorFunction<T, T[K1][K2][K3]>;
/**
 * @internal
 */
declare function select<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(k1: K1, k2: K2, k3: K3, k4: K4): OperatorFunction<T, T[K1][K2][K3][K4]>;
/**
 * @internal
 */
declare function select<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4]>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5): OperatorFunction<T, T[K1][K2][K3][K4][K5]>;
/**
 * @internal
 */
declare function select<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4], K6 extends keyof T[K1][K2][K3][K4][K5]>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): OperatorFunction<T, T[K1][K2][K3][K4][K5][K6]>;

/**
 * @description
 *
 * Returns an Observable that emits only the provided `keys` emitted by the source Observable. Each key will get
 * filtered to only emit _defined_ values as well as checked for distinct emissions.
 * Comparison will be done for each set key in the `keys` array.
 *
 * `selectSlice` will only emit _valid_ selections. A selection is _valid_ if every
 * selected key exists and is defined in the source Observable. This ensures that the `selectSlice`
 * operator will always return a complete slice with all values defined.
 *
 * You can fine grain your distinct checks by providing a `KeyCompareMap` with those keys you want to compute
 * explicitly different
 *
 * @example
 *
 * // An example with a custom comparison applied to each key
 * import { of } from 'rxjs';
 * import { selectSlice } from 'rx-angular/state';
 *
 *
 * const state$: Observable<MyState> = of(
 *  { title: 'myTitle', panelOpen: true},
 *  { title: 'myTitle2', panelOpen: true},
 *  { title: 'newTitle', panelOpen: true},
 *  { title: 'newTitle', panelOpen: false}
 * )
 * .pipe(
 *     selectSlice(['title', 'panelOpen']),
 *   )
 *   .subscribe(x => console.log(x));
 *
 * // displays:
 * //  { title: 'myTitle', panelOpen: true },
 * //  { title: 'myTitle2', panelOpen: true },
 * //  { title: 'newTitle', panelOpen: true },
 * //  { title: 'newTitle', panelOpen: false }
 *
 * @example
 *
 * import { of, Observable } from 'rxjs';
 * import { tap } from 'rxjs/operators';
 * import { selectSlice } from 'rx-angular/state';
 *
 * interface MyState {
 *    title: string;
 *    items: string[];
 *    panelOpen: boolean;
 * }
 * // Select items and title.
 * // apply custom compare logic for the items array
 * const customComparison: KeyCompareMap<MyState> = {
 *   items: (oldItems, newItems) => compareItems(oldItems, newItems)
 * };
 * const state$: Observable<MyState> = of(
 * { title: 'myTitle', items: ['foo', 'bar'], panelOpen: true },
 * { title: 'myTitle', items: ['foo', 'bar'], panelOpen: false },
 * { title: 'nextTitle', items: ['foo', 'baR'], panelOpen: true },
 * { title: 'nextTitle', items: ['fooRz', 'boo'], panelOpen: false },
 * );
 * const slice$ = state$.pipe(selectSlice(['title', 'items'], customComparison), tap(console.log)).subscribe();
 *
 * // displays:
 * // { title: 'myTitle', items: ['foo', 'bar'] }
 * // { title: 'nextTitle', items: ['foo', 'baR'] }
 * // { title: 'nextTitle', items: ['fooRz', 'boo'] }
 *
 * @param {(K)[]} keys - the array of keys which should be selected
 * @param {KeyCompareMap<{ [P in K]: T[P] }>} [keyCompareMap] Optional KeyCompareMap to provide custom compare logic
 * for some the keys
 * @docsPage selectSlice
 * @docsCategory operators
 */
declare function selectSlice<T extends object, K extends keyof T>(keys: K[], keyCompareMap?: KeyCompareMap<{
    [P in K]: T[P];
}>): OperatorFunction<T, PickSlice<T, K>>;

/**
 * @description
 *
 * As the name `stateful` implies this operator is useful when you process an Observable which maintains state.
 *
 * Maintaining state as an `Observable` source comes with a handful of repetitive as well as use case specific tasks.
 *
 * It acts like the Observables `pipe` method.
 * It accepts RxJS operators and composes them like `Observable#pipe` and the standalone `pipe` method.
 *
 * Furthermore, it takes care of the above mentioned repetitive tasks as listed below.
 *
 * You will always (aka repetitive) want to ensure that:
 * - only distinct state changes are emitted
 * - only defined values are emitted (filter out undefined, which ensures lazy state)
 * - share and replay custom operations for multiple subscribers (saves performance)
 *
 * You will sometimes (aka situational) need:
 * - a subset of the state (derivations)
 * - compose the state with other Observables or change the Observables behaviour
 *
 *
 * @example
 * import { Observable } from 'rxjs';
 * import { map } from 'rxjs/operators';
 * import { stateful } from 'rx-angular/state';
 *
 * const state$: Observable<{ name: string; items: string[] }>;
 * const derivation$ = state$.pipe(
 *   stateful(
 *     map(state => state.list.length),
 *     filter(length => length > 3)
 *   )
 * );
 *
 * @return OperatorFunction<T, NonUndefined<A>>
 *
 * @docsPage stateful
 * @docsCategory operators
 */
declare function stateful<T>(): OperatorFunction<T, NonUndefined<T>>;
/**
 * @internal
 */
declare function stateful<T, A>(op: OperatorFunction<T, A>): OperatorFunction<T, NonUndefined<A>>;
/**
 * @internal
 */
declare function stateful<T, A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): OperatorFunction<T, NonUndefined<B>>;
/**
 * @internal
 */
declare function stateful<T, A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): OperatorFunction<T, NonUndefined<C>>;
/**
 * @internal
 */
declare function stateful<T, A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): OperatorFunction<T, NonUndefined<D>>;
/**
 * @internal
 */
declare function stateful<T, A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): OperatorFunction<T, NonUndefined<E>>;

declare function createSideEffectObservable<T>(stateObservables?: Subject<Observable<T>>, scheduler?: SchedulerLike | null): {
    effects$: Observable<T>;
    nextEffectObservable: (effect$: Observable<T>) => void;
    subscribe: () => Subscription;
} & Subscribable<T>;

declare function isOperateFnArrayGuard<T, R = T>(op: any[]): op is OperatorFunction<T, R>[];
declare function isStringArrayGuard(op: any[]): op is string[];
declare function isKeyOf<O>(k: unknown): k is keyof O;
declare function isObjectGuard(obj: unknown): obj is object;
declare function isDefined(val: unknown): val is NonNullable<any>;
declare function isStringAndFunctionTupleGuard<R>(op: unknown[]): op is [string, (val: any) => R];
declare function isStringArrayFunctionAndOptionalObjectTupleGuard<R>(op: unknown[]): op is [strs: string[], fn: (val: any) => R, obj?: object];

declare function pipeFromArray<T, R>(fns: Array<UnaryFunction<T, R>>): UnaryFunction<T, R>;

declare function safePluck<T extends object, K1 extends keyof T>(stateObject: T, keys: K1 | [K1]): T[K1];
declare function safePluck<T extends object, K1 extends keyof T, K2 extends keyof T[K1]>(stateObject: T, keys: [K1, K2]): T[K1][K2];
declare function safePluck<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(stateObject: T, keys: [K1, K2, K3]): T[K1][K2][K3];
declare function safePluck<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(stateObject: T, keys: [K1, K2, K3, K4]): T[K1][K2][K3][K4];
declare function safePluck<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4]>(stateObject: T, keys: [K1, K2, K3, K4, K5]): T[K1][K2][K3][K4][K5];
declare function safePluck<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4], K6 extends keyof T[K1][K2][K3][K4][K5]>(stateObject: T, keys: [K1] | [K1, K2] | [K1, K2, K3] | [K1, K2, K3, K4] | [K1, K2, K3, K4, K5] | [K1, K2, K3, K4, K5, K6]): T[K1][K2][K3][K4][K5][K6];

export { createAccumulationObservable, createSideEffectObservable, defaultAccumulator, distinctUntilSomeChanged, isDefined, isKeyOf, isObjectGuard, isOperateFnArrayGuard, isStringAndFunctionTupleGuard, isStringArrayFunctionAndOptionalObjectTupleGuard, isStringArrayGuard, pipeFromArray, safePluck, select, selectSlice, stateful };
export type { AccumulationFn, Accumulator, CompareFn, KeyCompareMap, PickSlice };
//# sourceMappingURL=state-selections.d.ts.map