import { OnDestroy } from '@angular/core';
import type { MonoTypeOperatorFunction } from 'rxjs';
import { Observable, OperatorFunction, Subscription } from 'rxjs';
import * as i0 from "@angular/core";
export declare type SelectorResults<TSelectors extends Observable<unknown>[]> = {
    [Key in keyof TSelectors]: TSelectors[Key] extends Observable<infer TResult> ? TResult : never;
};
export declare type Projector<Selectors extends Observable<unknown>[], TResult> = (...args: SelectorResults<Selectors>) => TResult;
/**
 * Implementation from ngrx/component-store with slight modification
 */
export declare abstract class NgtComponentStore<TState extends object = any> implements OnDestroy {
    private readonly destroySubject$;
    readonly destroy$: Observable<void>;
    private readonly stateSubject$;
    /** Completes all relevant Observable streams. */
    ngOnDestroy(): void;
    get(): TState;
    get<TResult>(projector: (s: TState) => TResult): TResult;
    /**
     * Patches the state with provided partial state.
     *
     * @param partialStateOrUpdaterFn a partial state or a partial updater
     * function that accepts the state and returns the partial state.
     */
    set(partialStateOrUpdaterFn: Partial<TState> | Observable<Partial<TState>> | ((state: TState) => Partial<TState> | Observable<Partial<TState>>)): void;
    /**
     * Creates a selector.
     *
     * @param projector A pure projection function that takes the current state and
     *   returns some new slice/projection of that state.
     * @return An observable of the projector results.
     */
    select(): Observable<TState>;
    select<TResult>(projector: (s: TState) => TResult): Observable<TResult>;
    select<TSelectors extends Observable<unknown>[], TResult>(...args: [...selectors: TSelectors, projector: Projector<TSelectors, TResult>]): Observable<TResult>;
    select<TSelectors extends Observable<unknown>[]>(...args: [...selectors: TSelectors]): Observable<{}>;
    /**
     * Creates an effect.
     *
     * This effect is subscribed to throughout the lifecycle of the ComponentStore.
     * @param generator A function that takes an origin Observable input and
     *     returns an Observable. The Observable that is returned will be
     *     subscribed to for the life of the component.
     * @return A function that, when called, will trigger the origin Observable.
     */
    effect<TProvidedType = void, TOriginType extends Observable<TProvidedType> | unknown = Observable<TProvidedType>, TObservableType = TOriginType extends Observable<infer A> ? A : never, TReturnType = TProvidedType | TObservableType extends void ? () => void : (observableOrValue: TObservableType | Observable<TObservableType>) => Subscription>(generator: (origin$: TOriginType) => Observable<unknown>): TReturnType;
    private updateState;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgtComponentStore<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtComponentStore<any>, never, never, {}, {}, never, never, false>;
}
/**
 * An extended `tap` operator that accepts an `effectFn` which:
 * - runs on every `next` notification from `source$`
 * - can optionally return a `cleanUp` function that
 * invokes from the 2nd `next` notification onward and on `unsubscribe` (destroyed)
 *
 *
 * @example
 * ```typescript
 * source$.pipe(
 *  tapEffect((sourceValue) = {
 *    const cb = () => {
 *      doStuff(sourceValue);
 *    };
 *    addListener('event', cb);
 *
 *    return () => {
 *      removeListener('event', cb);
 *    }
 *  })
 * )
 * ```
 */
export declare function tapEffect<TValue>(effectFn: (value: TValue) => ((cleanUpParams: {
    prev: TValue | undefined;
    complete: boolean;
    error: boolean;
}) => void) | void | undefined): MonoTypeOperatorFunction<TValue>;
export declare function skipUndefined<TValue>(): MonoTypeOperatorFunction<TValue>;
export declare function startWithUndefined<TValue>(): OperatorFunction<TValue, TValue>;