ngrx-run/src/effect.d.ts

Return side-effects as data from your NgRx reducers

import { unsubscribeBrand } from './unsubscribe';
import { Observable, Subscription } from 'rxjs';
import { Action } from '@ngrx/store';
import { InjectionToken, Type } from '@angular/core';
import { EffectConfig } from './effect-config';
export declare type Inject = <T>(token: Type<T> | InjectionToken<T>) => T;
export declare type Operand<T> = Observable<T> | Promise<T> | UnsubscribeOperation | void;
export declare type Dependencies = Dependency[];
export declare type Dependency = any;
export declare type Instance<T> = T extends new (...args: any[]) => InstanceType<any> ? InstanceType<T> : T extends InjectionToken<infer U> ? U : T;
export declare type Instances<T> = {
    [P in keyof T]: Instance<T[P]>;
};
export declare function hasDependencies(effectLike: any): effectLike is Required<HasDependencies<any>>;
export declare type IsEffect = {
    __isEffect: true;
    type?: string;
};
declare type HasDependencies<TDeps extends Dependencies> = {
    using?: readonly [...TDeps];
};
export declare type SubscriptionToken = number & {
    __brand: 'SubscriptionToken';
};
export declare type ObservableEffectDefinition<TDeps extends Dependencies, TResult> = IsEffect & HasDependencies<TDeps> & {
    call: (...deps: Instances<TDeps>) => Observable<TResult>;
};
export declare type ObservableEffectHandler<TResult> = {
    next: (value: TResult) => Action;
    error?: (err: any) => Action;
    complete?: () => Action;
    subscribed?: (token: SubscriptionToken) => Action;
};
export declare type ObservableEffect<TDeps extends Dependencies, TResult> = ObservableEffectDefinition<TDeps, TResult> & ObservableEffectHandler<TResult>;
export declare function isObservableEffect<TDeps extends Dependencies, TResult>(effect: EffectConfig<TDeps, TResult>, operand: Operand<TResult>): effect is ObservableEffect<TDeps, TResult>;
export declare function isObservableOperand<TResult>(operand: Operand<TResult>): operand is Observable<TResult>;
export declare type PromiseEffectDefinition<TDeps extends Dependencies, TResult> = IsEffect & HasDependencies<TDeps> & {
    call: (...deps: Instances<TDeps>) => Promise<TResult>;
};
export declare type PromiseEffectHandler<TResult> = {
    error?: (err: any) => Action;
    complete?: (value: TResult) => Action;
};
export declare type PromiseEffect<TDeps extends Dependencies, TResult> = PromiseEffectDefinition<TDeps, TResult> & PromiseEffectHandler<TResult>;
export declare function isPromiseEffect<TDeps extends Dependencies, TResult>(effect: EffectConfig<TDeps, TResult>, operand: Operand<TResult>): effect is PromiseEffect<TDeps, TResult>;
export declare function isPromiseOperand<TResult>(operand: Operand<TResult>): operand is Promise<TResult>;
export declare type ImmediateEffectDefinition<TDeps extends Dependencies> = IsEffect & HasDependencies<TDeps> & {
    call: (...deps: Instances<TDeps>) => void;
};
export declare type ImmediateEffectHandler = {
    error?: (err: any) => Action;
    complete?: () => Action;
};
export declare type ImmediateEffect<TDeps extends Dependencies> = ImmediateEffectDefinition<TDeps> & ImmediateEffectHandler;
export declare type Cancellable<T> = Subscription | AbortController;
export declare type UnsubscribeOperation = {
    __brand: typeof unsubscribeBrand;
    subscriptionToken: SubscriptionToken;
};
export declare function isUnsubscriptionEffect(effect: EffectConfig<any, any>, operand: Operand<any>): effect is ImmediateEffect<any>;
export {};