@ngxs/store 3.8.2-dev.master-25397f3 → 3.8.2-dev.master-397e451

package/schematics/src/utils/ng-utils/standalone/util.d.ts

@@ -0,0 +1,28 @@
+import { Tree } from '@angular-devkit/schematics';
+import * as ts from '@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript';
+import { Change } from '@schematics/angular/utility/change';
+/**
+ * Finds the main file of a project.
+ * @param tree File tree for the project.
+ * @param projectName Name of the project in which to search.
+ */
+export declare function getMainFilePath(tree: Tree, projectName: string): Promise<string>;
+/**
+ * Gets a TypeScript source file at a specific path.
+ * @param tree File tree of a project.
+ * @param path Path to the file.
+ */
+export declare function getSourceFile(tree: Tree, path: string): ts.SourceFile;
+/** Finds the call to `bootstrapApplication` within a file. */
+export declare function findBootstrapApplicationCall(tree: Tree, mainFilePath: string): ts.CallExpression;
+/**
+ * Applies a set of changes to a file.
+ * @param tree File tree of the project.
+ * @param path Path to the file that is being changed.
+ * @param changes Changes that should be applied to the file.
+ */
+export declare function applyChangesToFile(tree: Tree, path: string, changes: Change[]): void;
+/** Checks whether a node is a call to `mergeApplicationConfig`. */
+export declare function isMergeAppConfigCall(node: ts.Node): node is ts.CallExpression;
+/** Finds the `providers` array literal within an application config. */
+export declare function findProvidersLiteral(config: ts.ObjectLiteralExpression): ts.ArrayLiteralExpression | null;

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

@@ -0,0 +1,11 @@
+import { Tree } from '@angular-devkit/schematics';
+interface BaseOptions {
+    name: string;
+    path?: string;
+    project?: string;
+}
+export declare function normalizeBaseOptions<T extends BaseOptions>(host: Tree, 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

@@ -0,0 +1,19 @@
+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 getProjectData(host: Tree, options: {
+    project?: string | undefined;
+    path?: string | undefined;
+}): {
+    project: string;
+    path: string;
+} | null;
+export declare function isLib(host: Tree, project?: string): boolean;

package/src/actions/symbols.d.ts

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

package/src/actions-stream.d.ts

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,13 @@
+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 getUndecoratedStateWithInjectableWarningMessage(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

@@ -0,0 +1,30 @@
+import { ɵActionOptions } from '@ngxs/store/internals';
+import { ActionDef, ActionType } from '../actions/symbols';
+import { StateContext } from '../symbols';
+/**
+ * Given an action class, returns its payload.
+ */
+type ActionToPayload<Action extends ActionType> = Action extends ActionDef<any, infer ActionPayload> ? ActionPayload : never;
+/**
+ * Given a list of action classes, returns the union of their payloads.
+ */
+type ActionsToPayload<Actions extends readonly ActionType[]> = {
+    [K in keyof Actions]: ActionToPayload<Actions[K]>;
+}[number];
+/**
+ * Given an action class or a list of action classes, returns the union of their payloads.
+ */
+type ActionOrActionsToPayload<ActionOrActions> = ActionOrActions extends ActionType ? ActionToPayload<ActionOrActions> : ActionOrActions extends ActionType[] ? ActionsToPayload<ActionOrActions> : never;
+/**
+ * Describes what methods can be decorated with an `@Action` decorator that has been passed the given action(s).
+ */
+type HandlerTypedPropertyDescriptor<ActionOrActions> = TypedPropertyDescriptor<() => any> | TypedPropertyDescriptor<(stateContext: StateContext<any>) => any> | TypedPropertyDescriptor<(stateContext: StateContext<any>, action: ActionOrActionsToPayload<ActionOrActions>) => any>;
+/**
+ * The result of a call to the `@Action()` decorator with the given action(s) as its first argument.
+ */
+type ActionDecorator<ActionOrActions extends ActionType | ActionType[]> = (target: any, name: string | symbol, _descriptor: HandlerTypedPropertyDescriptor<ActionOrActions>) => void;
+/**
+ * Decorates a method with action information.
+ */
+export declare function Action<ActionOrActions extends ActionType | ActionType[]>(actions: ActionOrActions, options?: ɵActionOptions): ActionDecorator<ActionOrActions>;
+export {};

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,7 @@
+/**
+ * Decorator for selecting a slice of state from the store.
+ *
+ * @deprecated
+ * Read the deprecation notice at this link: https://ngxs.io/deprecations/select-decorator-deprecation.
+ */
+export declare function Select<T>(rawSelector?: T, ...paths: string[]): PropertyDecorator;

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+import { SelectorDefTuple, 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 SelectorDefTuple>(selectors: T): SelectorType<T>;

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

@@ -0,0 +1,73 @@
+import { ɵSelectorDef, ɵSelectorReturnType } from '../../selectors';
+/**
+ * Defines a tuple of selector functions, state tokens, and state classes that a selector decorated
+ * by `@Selector()` can depend on.
+ */
+export type SelectorDefTuple = ɵSelectorDef<any>[] | [ɵSelectorDef<any>];
+type UnknownToAny<T> = unknown extends T ? any : T;
+type EnsureArray<T> = T extends any[] ? T : never;
+/**
+ * Given a tuple of selector functions, state tokens, state classes, etc., returns a tuple of what
+ * a dependent selector would expect to receive for that parent as an argument when called.
+ *
+ * For example, if the first element in `ParentsTuple` is a selector function that returns a
+ * `number`, then the first element of the result tuple will be `number`. If the second element
+ * in `ParentsTuple` is a state class with model `{ name: string }`, then the second element of
+ * the result tuple will be `{ name: string }`.
+ */
+type SelectorReturnTypeList<ParentsTuple extends SelectorDefTuple> = EnsureArray<{
+    [ParentsTupleIndex in keyof ParentsTuple]: ParentsTuple[ParentsTupleIndex] extends ɵSelectorDef<any> ? UnknownToAny<ɵSelectorReturnType<ParentsTuple[ParentsTupleIndex]>> : never;
+}>;
+/**
+ * Defines a selector function matching a given argument list of parent selectors/states/tokens
+ * and a given return type.
+ */
+export type SelectorSpec<ParentsTuple, Return> = ParentsTuple extends [] ? () => any : ParentsTuple extends SelectorDefTuple ? (...states: SelectorReturnTypeList<ParentsTuple>) => Return : () => any;
+/**
+ * Defines a selector function matching `SelectorSpec<ParentsTuple, Return>` but with the assumption that the
+ * container state has been injected as the first argument.
+ */
+type SelectorSpecWithInjectedState<ParentsTuple, Return> = SelectorSpec<ParentsTuple extends SelectorDefTuple ? [any, ...ParentsTuple] : [any], ParentsTuple extends SelectorDefTuple ? Return : any>;
+/**
+ * Defines a property descriptor for the `@Selector` decorator that decorates a function with
+ * parent selectors/states/tokens `ParentsTuple` and return type `Return`.
+ */
+type DescriptorWithNoInjectedState<ParentsTuple, Return> = TypedPropertyDescriptor<SelectorSpec<ParentsTuple, Return>>;
+/**
+ * Same as `DescriptorWithNoInjectedState` but with state injected as the first argument.
+ */
+type DescriptorWithInjectedState<ParentsTuple, Return> = TypedPropertyDescriptor<SelectorSpecWithInjectedState<ParentsTuple, Return>>;
+type DecoratorArgs<Descriptor> = [target: any, key: string | symbol, descriptor?: Descriptor];
+/**
+ * Defines the return type of a call to `@Selector` when there is no argument given
+ * (e.g. `@Selector()` counts, but `@Selector([])` does not)
+ *
+ * This result is a decorator that can only be used to decorate a function with no arguments or a
+ * single argument that is the container state.
+ */
+type SelectorTypeNoDecoratorArgs = {
+    <Return>(...args: DecoratorArgs<DescriptorWithNoInjectedState<unknown, Return>>): void | DescriptorWithNoInjectedState<unknown, Return>;
+    <Return>(...args: DecoratorArgs<DescriptorWithInjectedState<unknown, Return>>): void | DescriptorWithInjectedState<unknown, Return>;
+};
+/**
+ * Defines the return type of a call to `@Selector` when there is an argument given.
+ * (e.g. `@Selector([])` counts, but `@Selector()` does not)
+ *
+ * This result is a decorator that can only be used to decorate a function with an argument list
+ * matching the results of the tuple of parents `ParentsTuple`.
+ */
+type SelectorTypeWithDecoratorArgs<ParentsTuple> = {
+    <Return>(...args: DecoratorArgs<DescriptorWithNoInjectedState<ParentsTuple, Return>>): void | DescriptorWithNoInjectedState<ParentsTuple, Return>;
+    /**
+     * @deprecated
+     * Read the deprecation notice at this link: https://ngxs.io/deprecations/inject-container-state-deprecation.md.
+     */
+    <Return>(...args: DecoratorArgs<DescriptorWithInjectedState<ParentsTuple, Return>>): void | DescriptorWithInjectedState<ParentsTuple, Return>;
+};
+/**
+ * Defines the return type of a call to `@Selector`. This result is a decorator that can only be
+ * used to decorate a function with an argument list matching `ParentsTuple`, the results of the
+ * tuple of parent selectors/state tokens/state classes.
+ */
+export type SelectorType<ParentsTuple> = unknown extends ParentsTuple ? SelectorTypeNoDecoratorArgs : SelectorTypeWithDecoratorArgs<ParentsTuple>;
+export {};

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,10 @@
+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 withNgxsDevelopmentOptions(options: NgxsDevelopmentOptions): import("@angular/core").EnvironmentProviders;

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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,36 @@
+import { NgZone } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { ɵStateStream } from '@ngxs/store/internals';
+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 _ngZone;
+    private _actions;
+    private _actionResults;
+    private _pluginManager;
+    private _stateStream;
+    private _ngxsExecutionStrategy;
+    constructor(_ngZone: NgZone, _actions: InternalActions, _actionResults: InternalDispatchedActionResults, _pluginManager: PluginManager, _stateStream: ɵStateStream, _ngxsExecutionStrategy: InternalNgxsExecutionStrategy);
+    /**
+     * 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/fallback-subscriber.d.ts

@@ -0,0 +1,3 @@
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+export declare function fallbackSubscriber<T>(ngZone: NgZone): (source: Observable<T>) => Observable<T>;

package/src/internal/internals.d.ts

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,24 @@
+import { OnDestroy } from '@angular/core';
+import { ɵNgxsAppBootstrappedState } from '@ngxs/store/internals';
+import { InitState, UpdateState } from '@ngxs/store/plugins';
+import { Store } from '../store';
+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 _internalStateOperations;
+    private _stateContextFactory;
+    private _appBootstrappedState;
+    private readonly _destroy$;
+    private _initStateHasBeenDispatched?;
+    constructor(_store: Store, _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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,61 @@
+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;
+    private _ngxsUnhandledErrorHandler;
+    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<[any]>;
+    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>;
+}