@ngxs/store 3.8.2-dev.master-09bece1 → 3.8.2-dev.master-b0e24dd

package/schematics/src/utils/normalize-options.d.ts

@@ -1,9 +0,0 @@
-interface BaseOptions {
-    name: string;
-    path?: string;
-}
-export declare function normalizeBaseOptions<T extends BaseOptions>(options: T): T & Required<BaseOptions>;
-export declare function normalizePath(path: string | undefined): string;
-/** Returns `value` if it's "true" | "false" and default value otherwise */
-export declare function normalizeOptionalBoolean(value: boolean | undefined, defaultValue: boolean): boolean;
-export {};

package/schematics/src/utils/project.d.ts

@@ -1,16 +0,0 @@
-import { TargetDefinition } from '@schematics/angular/utility/workspace';
-import { Tree } from '@angular-devkit/schematics';
-export interface WorkspaceProject {
-    name: string;
-    root: string;
-    projectType: string;
-    architect: {
-        [key: string]: TargetDefinition;
-    };
-}
-export declare function getProject(host: Tree, project?: string): WorkspaceProject | null;
-export declare function getProjectPath(host: Tree, options: {
-    project?: string | undefined;
-    path?: string | undefined;
-}): string | null;
-export declare function isLib(host: Tree, project?: string): boolean;

package/src/actions/symbols.d.ts

@@ -1,7 +0,0 @@
-export interface ActionDef<T = any, U = any> {
-    type: string;
-    new (...args: T[]): U;
-}
-export type ActionType = ActionDef | {
-    type: string;
-};

package/src/actions-stream.d.ts

@@ -1,37 +0,0 @@
-import { OnDestroy } from '@angular/core';
-import { ɵOrderedSubject } from '@ngxs/store/internals';
-import { Observable } from 'rxjs';
-import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
-import * as i0 from "@angular/core";
-/**
- * Status of a dispatched action
- */
-export declare const enum ActionStatus {
-    Dispatched = "DISPATCHED",
-    Successful = "SUCCESSFUL",
-    Canceled = "CANCELED",
-    Errored = "ERRORED"
-}
-export interface ActionContext<T = any> {
-    status: ActionStatus;
-    action: T;
-    error?: Error;
-}
-/**
- * Internal Action stream that is emitted anytime an action is dispatched.
- */
-export declare class InternalActions extends ɵOrderedSubject<ActionContext> implements OnDestroy {
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<InternalActions, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<InternalActions>;
-}
-/**
- * Action stream that is emitted anytime an action is dispatched.
- *
- * You can listen to this in services to react without stores.
- */
-export declare class Actions extends Observable<ActionContext> {
-    constructor(internalActions$: InternalActions, internalExecutionStrategy: InternalNgxsExecutionStrategy);
-    static ɵfac: i0.ɵɵFactoryDeclaration<Actions, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<Actions>;
-}

package/src/configs/messages.config.d.ts

@@ -1,13 +0,0 @@
-import { ɵPlainObject } from '@ngxs/store/internals';
-export declare function throwStateNameError(name: string): never;
-export declare function throwStateNamePropertyError(): never;
-export declare function throwStateUniqueError(current: string, newName: string, oldName: string): never;
-export declare function throwStateDecoratorError(name: string): never;
-export declare function throwActionDecoratorError(): never;
-export declare function throwSelectorDecoratorError(): never;
-export declare function getZoneWarningMessage(): string;
-export declare function getUndecoratedStateInIvyWarningMessage(name: string): string;
-export declare function getInvalidInitializationOrderMessage(addedStates?: ɵPlainObject): string;
-export declare function throwSelectFactoryNotConnectedError(): never;
-export declare function throwPatchingArrayError(): never;
-export declare function throwPatchingPrimitiveError(): never;

package/src/decorators/action.d.ts

@@ -1,6 +0,0 @@
-import { ɵActionOptions } from '@ngxs/store/internals';
-import { ActionType } from '../actions/symbols';
-/**
- * Decorates a method with a action information.
- */
-export declare function Action(actions: ActionType | ActionType[], options?: ɵActionOptions): MethodDecorator;

package/src/decorators/select/select-factory.d.ts

@@ -1,16 +0,0 @@
-import { OnDestroy } from '@angular/core';
-import { Store } from '../../store';
-import { NgxsConfig } from '../../symbols';
-import * as i0 from "@angular/core";
-/**
- * Allows the select decorator to get access to the DI store, this is used internally
- * in `@Select` decorator.
- */
-export declare class SelectFactory implements OnDestroy {
-    static store: Store | null;
-    static config: NgxsConfig | null;
-    constructor(store: Store, config: NgxsConfig);
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SelectFactory, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SelectFactory>;
-}

package/src/decorators/select/select.d.ts

@@ -1,4 +0,0 @@
-/**
- * Decorator for selecting a slice of state from the store.
- */
-export declare function Select<T>(rawSelector?: T, ...paths: string[]): PropertyDecorator;

package/src/decorators/select/symbols.d.ts

@@ -1,9 +0,0 @@
-import { Observable } from 'rxjs';
-import { ɵExtractTokenType, StateToken } from '@ngxs/store/internals';
-export declare function createSelectObservable<T = any>(selector: any): Observable<T>;
-export declare function createSelectorFn(name: string, rawSelector?: any, paths?: string[]): any;
-/**
- * @example If `foo$` => make it just `foo`
- */
-export declare function removeDollarAtTheEnd(name: string): string;
-export type PropertyType<T> = T extends StateToken<any> ? Observable<ɵExtractTokenType<T>> : T extends (...args: any[]) => any ? Observable<ReturnType<T>> : any;

package/src/decorators/selector/selector.d.ts

@@ -1,10 +0,0 @@
-import { SelectorDef } from '../../selectors';
-import { SelectorType } from './symbols';
-/**
- * Decorator for creating a state selector for the current state.
- */
-export declare function Selector(): SelectorType<unknown>;
-/**
- * Decorator for creating a state selector from the provided selectors (and optionally the container State, depending on the applicable Selector Options).
- */
-export declare function Selector<T extends SelectorDef<any>>(selectors: T[]): SelectorType<T>;

package/src/decorators/selector/symbols.d.ts

@@ -1,3 +0,0 @@
-import { StateToken, ɵExtractTokenType } from '@ngxs/store/internals';
-export type SelectorSpec<T, U> = [T] extends [never] ? (...states: any[]) => any : T extends StateToken<any> ? (state: ɵExtractTokenType<T>) => U : (...states: any[]) => any;
-export type SelectorType<T> = <U>(target: any, key: string | symbol, descriptor: TypedPropertyDescriptor<SelectorSpec<T, U>>) => TypedPropertyDescriptor<SelectorSpec<T, U>> | void;

package/src/decorators/selector-options.d.ts

@@ -1,5 +0,0 @@
-import { ɵSharedSelectorOptions } from '@ngxs/store/internals';
-/**
- * Decorator for setting selector options at a method or class level.
- */
-export declare function SelectorOptions(options: ɵSharedSelectorOptions): ClassDecorator & MethodDecorator;

package/src/decorators/state.d.ts

@@ -1,5 +0,0 @@
-import { ɵStateClass, ɵStoreOptions } from '@ngxs/store/internals';
-/**
- * Decorates a class with ngxs state information.
- */
-export declare function State<T>(options: ɵStoreOptions<T>): (target: ɵStateClass) => void;

package/src/dev-features/ngxs-development.module.d.ts

@@ -1,10 +0,0 @@
-import { ModuleWithProviders } from '@angular/core';
-import { NgxsDevelopmentOptions } from './symbols';
-import * as i0 from "@angular/core";
-export declare class NgxsDevelopmentModule {
-    static forRoot(options: NgxsDevelopmentOptions): ModuleWithProviders<NgxsDevelopmentModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsDevelopmentModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsDevelopmentModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsDevelopmentModule>;
-}
-export declare function provideNgxsDevelopmentOptions(options: NgxsDevelopmentOptions): import("@angular/core").EnvironmentProviders;

package/src/dev-features/ngxs-unhandled-actions-logger.d.ts

@@ -1,17 +0,0 @@
-import { ActionType } from '../actions/symbols';
-import { NgxsDevelopmentOptions } from './symbols';
-import * as i0 from "@angular/core";
-export declare class NgxsUnhandledActionsLogger {
-    /**
-     * These actions should be ignored by default; the user can increase this
-     * list in the future via the `ignoreActions` method.
-     */
-    private _ignoredActions;
-    constructor(options: NgxsDevelopmentOptions);
-    /**
-     * Adds actions to the internal list of actions that should be ignored.
-     */
-    ignoreActions(...actions: ActionType[]): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsUnhandledActionsLogger, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NgxsUnhandledActionsLogger>;
-}

package/src/dev-features/symbols.d.ts

@@ -1,8 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { ActionType } from '../actions/symbols';
-export interface NgxsDevelopmentOptions {
-    warnOnUnhandledActions: true | {
-        ignore: ActionType[];
-    };
-}
-export declare const NGXS_DEVELOPMENT_OPTIONS: InjectionToken<NgxsDevelopmentOptions>;

package/src/execution/dispatch-outside-zone-ngxs-execution-strategy.d.ts

@@ -1,14 +0,0 @@
-import { NgZone } from '@angular/core';
-import { NgxsExecutionStrategy } from './symbols';
-import * as i0 from "@angular/core";
-export declare class DispatchOutsideZoneNgxsExecutionStrategy implements NgxsExecutionStrategy {
-    private _ngZone;
-    private _platformId;
-    constructor(_ngZone: NgZone, _platformId: string);
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-    private runInsideAngular;
-    private runOutsideAngular;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DispatchOutsideZoneNgxsExecutionStrategy, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DispatchOutsideZoneNgxsExecutionStrategy>;
-}

package/src/execution/internal-ngxs-execution-strategy.d.ts

@@ -1,10 +0,0 @@
-import { NgxsExecutionStrategy } from './symbols';
-import * as i0 from "@angular/core";
-export declare class InternalNgxsExecutionStrategy implements NgxsExecutionStrategy {
-    private _executionStrategy;
-    constructor(_executionStrategy: NgxsExecutionStrategy);
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-    static ɵfac: i0.ɵɵFactoryDeclaration<InternalNgxsExecutionStrategy, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<InternalNgxsExecutionStrategy>;
-}

package/src/execution/noop-ngxs-execution-strategy.d.ts

@@ -1,8 +0,0 @@
-import { NgxsExecutionStrategy } from './symbols';
-import * as i0 from "@angular/core";
-export declare class NoopNgxsExecutionStrategy implements NgxsExecutionStrategy {
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NoopNgxsExecutionStrategy, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NoopNgxsExecutionStrategy>;
-}

package/src/execution/symbols.d.ts

@@ -1,16 +0,0 @@
-import { InjectionToken, Type } from '@angular/core';
-/**
- * Consumers have the option to utilize the execution strategy provided by
- * `NgxsModule.forRoot({executionStrategy})` or `provideStore([], {executionStrategy})`.
- */
-export declare const CUSTOM_NGXS_EXECUTION_STRATEGY: InjectionToken<Type<NgxsExecutionStrategy> | undefined>;
-/**
- * The injection token is used internally to resolve an instance of the execution
- * strategy. It checks whether consumers have provided their own `executionStrategy`
- * and also verifies if we are operating in a zone-aware environment.
- */
-export declare const NGXS_EXECUTION_STRATEGY: InjectionToken<NgxsExecutionStrategy>;
-export interface NgxsExecutionStrategy {
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-}

package/src/internal/dispatcher.d.ts

@@ -1,36 +0,0 @@
-import { Observable, Subject } from 'rxjs';
-import { ɵStateStream } from '@ngxs/store/internals';
-import { InternalErrorReporter } from './error-handler';
-import { ActionContext, InternalActions } from '../actions-stream';
-import { PluginManager } from '../plugin-manager';
-import { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';
-import * as i0 from "@angular/core";
-/**
- * Internal Action result stream that is emitted when an action is completed.
- * This is used as a method of returning the action result to the dispatcher
- * for the observable returned by the dispatch(...) call.
- * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.
- */
-export declare class InternalDispatchedActionResults extends Subject<ActionContext> {
-    static ɵfac: i0.ɵɵFactoryDeclaration<InternalDispatchedActionResults, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<InternalDispatchedActionResults>;
-}
-export declare class InternalDispatcher {
-    private _actions;
-    private _actionResults;
-    private _pluginManager;
-    private _stateStream;
-    private _ngxsExecutionStrategy;
-    private _internalErrorReporter;
-    constructor(_actions: InternalActions, _actionResults: InternalDispatchedActionResults, _pluginManager: PluginManager, _stateStream: ɵStateStream, _ngxsExecutionStrategy: InternalNgxsExecutionStrategy, _internalErrorReporter: InternalErrorReporter);
-    /**
-     * Dispatches event(s).
-     */
-    dispatch(actionOrActions: any | any[]): Observable<void>;
-    private dispatchByEvents;
-    private dispatchSingle;
-    private getActionResultStream;
-    private createDispatchObservable;
-    static ɵfac: i0.ɵɵFactoryDeclaration<InternalDispatcher, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<InternalDispatcher>;
-}

package/src/internal/error-handler.d.ts

@@ -1,26 +0,0 @@
-import { Injector } from '@angular/core';
-import { Observable } from 'rxjs';
-import { NgxsExecutionStrategy } from '../execution/symbols';
-import * as i0 from "@angular/core";
-/**
- * This operator is used for piping the observable result
- * from the `dispatch()`. It has a "smart" error handling
- * strategy that allows us to decide whether we propagate
- * errors to Angular's `ErrorHandler` or enable users to
- * handle them manually. We consider following cases:
- * 1) `store.dispatch()` (no subscribe) -> call `handleError()`
- * 2) `store.dispatch().subscribe()` (no error callback) -> call `handleError()`
- * 3) `store.dispatch().subscribe({ error: ... })` -> don't call `handleError()`
- * 4) `toPromise()` without `catch` -> do `handleError()`
- * 5) `toPromise()` with `catch` -> don't `handleError()`
- */
-export declare function ngxsErrorHandler(internalErrorReporter: InternalErrorReporter, ngxsExecutionStrategy: NgxsExecutionStrategy): (source: Observable<void>) => Observable<void>;
-export declare class InternalErrorReporter {
-    private _injector;
-    /** Will be set lazily to be backward compatible. */
-    private _errorHandler;
-    constructor(_injector: Injector);
-    reportErrorSafely(error: any): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<InternalErrorReporter, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<InternalErrorReporter>;
-}

package/src/internal/internals.d.ts

@@ -1,105 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { Observable } from 'rxjs';
-import { ɵPlainObjectOf, ɵStateClassInternal, ɵActionHandlerMetaData } from '@ngxs/store/internals';
-import { NgxsConfig } from '../symbols';
-export type StateKeyGraph = ɵPlainObjectOf<string[]>;
-export type StatesByName = ɵPlainObjectOf<ɵStateClassInternal>;
-export interface StateOperations<T> {
-    getState(): T;
-    setState(val: T): void;
-    dispatch(actionOrActions: any | any[]): Observable<void>;
-}
-export interface MappedStore {
-    name: string;
-    isInitialised: boolean;
-    actions: ɵPlainObjectOf<ɵActionHandlerMetaData[]>;
-    defaults: any;
-    instance: any;
-    path: string;
-}
-export interface StatesAndDefaults {
-    defaults: any;
-    states: MappedStore[];
-}
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
- *
- * Marked for removal. It's only used within `createSelectorFn`.
- */
-export declare function propGetter(paths: string[], config: NgxsConfig): (x: any) => any;
-export declare const ɵPROP_GETTER: InjectionToken<(paths: string[]) => (x: any) => any>;
-/**
- * Given an array of states, it will return a object graph. Example:
- *    const states = [
- *      Cart,
- *      CartSaved,
- *      CartSavedItems
- *    ]
- *
- * would return:
- *
- *  const graph = {
- *    cart: ['saved'],
- *    saved: ['items'],
- *    items: []
- *  };
- *
- * @ignore
- */
-export declare function buildGraph(stateClasses: ɵStateClassInternal[]): StateKeyGraph;
-/**
- * Given a states array, returns object graph
- * returning the name and state metadata. Example:
- *
- *  const graph = {
- *    cart: { metadata }
- *  };
- *
- * @ignore
- */
-export declare function nameToState(states: ɵStateClassInternal[]): ɵPlainObjectOf<ɵStateClassInternal>;
-/**
- * Given a object relationship graph will return the full path
- * for the child items. Example:
- *
- *  const graph = {
- *    cart: ['saved'],
- *    saved: ['items'],
- *    items: []
- *  };
- *
- * would return:
- *
- *  const r = {
- *    cart: 'cart',
- *    saved: 'cart.saved',
- *    items: 'cart.saved.items'
- *  };
- *
- * @ignore
- */
-export declare function findFullParentPath(obj: StateKeyGraph, newObj?: ɵPlainObjectOf<string>): ɵPlainObjectOf<string>;
-/**
- * Given a object graph, it will return the items topologically sorted Example:
- *
- *  const graph = {
- *    cart: ['saved'],
- *    saved: ['items'],
- *    items: []
- *  };
- *
- * would return:
- *
- *  const results = [
- *    'items',
- *    'saved',
- *    'cart'
- *  ];
- *
- * @ignore
- */
-export declare function topologicalSort(graph: StateKeyGraph): string[];

package/src/internal/lifecycle-state-manager.d.ts

@@ -1,26 +0,0 @@
-import { OnDestroy } from '@angular/core';
-import { ɵNgxsAppBootstrappedState } from '@ngxs/store/internals';
-import { InitState, UpdateState } from '@ngxs/store/plugins';
-import { Store } from '../store';
-import { InternalErrorReporter } from './error-handler';
-import { StateContextFactory } from './state-context-factory';
-import { InternalStateOperations } from './state-operations';
-import { StatesAndDefaults } from './internals';
-import * as i0 from "@angular/core";
-export declare class LifecycleStateManager implements OnDestroy {
-    private _store;
-    private _internalErrorReporter;
-    private _internalStateOperations;
-    private _stateContextFactory;
-    private _appBootstrappedState;
-    private readonly _destroy$;
-    private _initStateHasBeenDispatched?;
-    constructor(_store: Store, _internalErrorReporter: InternalErrorReporter, _internalStateOperations: InternalStateOperations, _stateContextFactory: StateContextFactory, _appBootstrappedState: ɵNgxsAppBootstrappedState);
-    ngOnDestroy(): void;
-    ngxsBootstrap(action: InitState | UpdateState, results: StatesAndDefaults | undefined): void;
-    private _invokeInitOnStates;
-    private _invokeBootstrapOnStates;
-    private _getStateContext;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LifecycleStateManager, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LifecycleStateManager>;
-}

package/src/internal/state-context-factory.d.ts

@@ -1,18 +0,0 @@
-import { StateContext } from '../symbols';
-import { MappedStore } from '../internal/internals';
-import { InternalStateOperations } from '../internal/state-operations';
-import * as i0 from "@angular/core";
-/**
- * State Context factory class
- * @ignore
- */
-export declare class StateContextFactory {
-    private _internalStateOperations;
-    constructor(_internalStateOperations: InternalStateOperations);
-    /**
-     * Create the state context
-     */
-    createStateContext<T>(mappedStore: MappedStore): StateContext<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StateContextFactory, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<StateContextFactory>;
-}

package/src/internal/state-factory.d.ts

@@ -1,60 +0,0 @@
-import { Injector, OnDestroy } from '@angular/core';
-import { ɵStateClassInternal, ɵRuntimeSelectorContext } from '@ngxs/store/internals';
-import { Observable } from 'rxjs';
-import { NgxsConfig } from '../symbols';
-import { MappedStore, StatesAndDefaults, StatesByName } from './internals';
-import { ActionContext, InternalActions } from '../actions-stream';
-import { InternalDispatchedActionResults } from '../internal/dispatcher';
-import { StateContextFactory } from '../internal/state-context-factory';
-import * as i0 from "@angular/core";
-/**
- * The `StateFactory` class adds root and feature states to the graph.
- * This extracts state names from state classes, checks if they already
- * exist in the global graph, throws errors if their names are invalid, etc.
- * See its constructor, state factories inject state factories that are
- * parent-level providers. This is required to get feature states from the
- * injector on the same level.
- *
- * The `NgxsModule.forFeature(...)` returns `providers: [StateFactory, ...states]`.
- * The `StateFactory` is initialized on the feature level and goes through `...states`
- * to get them from the injector through `injector.get(state)`.
- * @ignore
- */
-export declare class StateFactory implements OnDestroy {
-    private _injector;
-    private _config;
-    private _parentFactory;
-    private _actions;
-    private _actionResults;
-    private _stateContextFactory;
-    private _initialState;
-    private _actionsSubscription;
-    private _propGetter;
-    constructor(_injector: Injector, _config: NgxsConfig, _parentFactory: StateFactory, _actions: InternalActions, _actionResults: InternalDispatchedActionResults, _stateContextFactory: StateContextFactory, _initialState: any);
-    private _states;
-    get states(): MappedStore[];
-    private _statesByName;
-    get statesByName(): StatesByName;
-    private _statePaths;
-    private get statePaths();
-    getRuntimeSelectorContext: () => ɵRuntimeSelectorContext;
-    ngOnDestroy(): void;
-    /**
-     * Add a new state to the global defs.
-     */
-    add(stateClasses: ɵStateClassInternal[]): MappedStore[];
-    /**
-     * Add a set of states to the store and return the defaults
-     */
-    addAndReturnDefaults(stateClasses: ɵStateClassInternal[]): StatesAndDefaults;
-    connectActionHandlers(): void;
-    /**
-     * Invoke actions on the states.
-     */
-    invokeActions(dispatched$: Observable<ActionContext>, action: any): Observable<unknown[]>;
-    private addToStatesMap;
-    private addRuntimeInfoToMeta;
-    private hasBeenMountedAndBootstrapped;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StateFactory, [null, null, { optional: true; skipSelf: true; }, null, null, null, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<StateFactory>;
-}

package/src/internal/state-operations.d.ts

@@ -1,21 +0,0 @@
-import { ɵStateStream } from '@ngxs/store/internals';
-import { StateOperations, StatesAndDefaults } from '../internal/internals';
-import { InternalDispatcher } from '../internal/dispatcher';
-import { NgxsConfig } from '../symbols';
-import * as i0 from "@angular/core";
-/**
- * @ignore
- */
-export declare class InternalStateOperations {
-    private _stateStream;
-    private _dispatcher;
-    private _config;
-    constructor(_stateStream: ɵStateStream, _dispatcher: InternalDispatcher, _config: NgxsConfig);
-    /**
-     * Returns the root state operators.
-     */
-    getRootStateOperations(): StateOperations<any>;
-    setStateToTheCurrentWithNew(results: StatesAndDefaults): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<InternalStateOperations, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<InternalStateOperations>;
-}

package/src/internal/state-operators.d.ts

@@ -1,2 +0,0 @@
-import { StateOperator } from '@ngxs/store/operators';
-export declare function simplePatch<T>(value: Partial<T>): StateOperator<T>;

package/src/ivy/ivy-enabled-in-dev-mode.d.ts

@@ -1,6 +0,0 @@
-/**
- * All provided or injected tokens must have `@Injectable` decorator
- * (previously, injected tokens without `@Injectable` were allowed
- * if another decorator was used, e.g. pipes).
- */
-export declare function ensureStateClassIsInjectable(stateClass: any): void;

package/src/module.d.ts

@@ -1,13 +0,0 @@
-import { ModuleWithProviders } from '@angular/core';
-import { ɵStateClass } from '@ngxs/store/internals';
-import { NgxsModuleOptions } from './symbols';
-import { NgxsRootModule } from './modules/ngxs-root.module';
-import { NgxsFeatureModule } from './modules/ngxs-feature.module';
-import * as i0 from "@angular/core";
-export declare class NgxsModule {
-    static forRoot(states?: ɵStateClass[], options?: NgxsModuleOptions): ModuleWithProviders<NgxsRootModule>;
-    static forFeature(states?: ɵStateClass[]): ModuleWithProviders<NgxsFeatureModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsModule>;
-}

package/src/modules/ngxs-feature.module.d.ts

@@ -1,10 +0,0 @@
-import * as i0 from "@angular/core";
-/**
- * @ignore
- */
-export declare class NgxsFeatureModule {
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsFeatureModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsFeatureModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsFeatureModule>;
-}

package/src/modules/ngxs-root.module.d.ts

@@ -1,10 +0,0 @@
-import * as i0 from "@angular/core";
-/**
- * @ignore
- */
-export declare class NgxsRootModule {
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsRootModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsRootModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsRootModule>;
-}

package/src/operators/leave-ngxs.d.ts

@@ -1,7 +0,0 @@
-import { MonoTypeOperatorFunction } from 'rxjs';
-import { NgxsExecutionStrategy } from '../execution/symbols';
-/**
- * Returns operator that will run
- * `subscribe` outside of the ngxs execution context
- */
-export declare function leaveNgxs<T>(ngxsExecutionStrategy: NgxsExecutionStrategy): MonoTypeOperatorFunction<T>;