@ngxs/store 3.8.2 → 18.0.0-dev.master-f4c2c19

package/src/internal/internals.d.ts

@@ -1,47 +1,18 @@
-import { PlainObjectOf, StateClass } from '@ngxs/store/internals';
+import { InjectionToken } from '@angular/core';
 import { Observable } from 'rxjs';
-import { META_KEY, META_OPTIONS_KEY, NgxsConfig, StoreOptions } from '../symbols';
-import { ActionHandlerMetaData } from '../actions/symbols';
-export interface StateClassInternal<T = any, U = any> extends StateClass<T> {
-    [META_KEY]?: MetaDataModel;
-    [META_OPTIONS_KEY]?: StoreOptions<U>;
-}
-export declare type StateKeyGraph = PlainObjectOf<string[]>;
-export declare type StatesByName = PlainObjectOf<StateClassInternal>;
+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): T;
+    setState(val: T): void;
     dispatch(actionOrActions: any | any[]): Observable<void>;
 }
-export interface MetaDataModel {
-    name: string | null;
-    actions: PlainObjectOf<ActionHandlerMetaData[]>;
-    defaults: any;
-    path: string | null;
-    makeRootSelector: SelectorFactory | null;
-    children?: StateClassInternal[];
-}
-export interface RuntimeSelectorContext {
-    getStateGetter(key: any): (state: any) => any;
-    getSelectorOptions(localOptions?: SharedSelectorOptions): SharedSelectorOptions;
-}
-export declare type SelectFromRootState = (rootState: any) => any;
-export declare type SelectorFactory = (runtimeContext: RuntimeSelectorContext) => SelectFromRootState;
-export interface SharedSelectorOptions {
-    injectContainerState?: boolean;
-    suppressErrors?: boolean;
-}
-export interface SelectorMetaDataModel {
-    makeRootSelector: SelectorFactory | null;
-    originalFn: Function | null;
-    containerClass: any;
-    selectorName: string | null;
-    getSelectorOptions: () => SharedSelectorOptions;
-}
 export interface MappedStore {
     name: string;
     isInitialised: boolean;
-    actions: PlainObjectOf<ActionHandlerMetaData[]>;
+    actions: ɵPlainObjectOf<ɵActionHandlerMetaData[]>;
     defaults: any;
     instance: any;
     path: string;
@@ -50,38 +21,17 @@ export interface StatesAndDefaults {
     defaults: any;
     states: MappedStore[];
 }
-/**
- * Ensures metadata is attached to the class and returns it.
- *
- * @ignore
- */
-export declare function ensureStoreMetadata(target: StateClassInternal): MetaDataModel;
-/**
- * Get the metadata attached to the state class if it exists.
- *
- * @ignore
- */
-export declare function getStoreMetadata(target: StateClassInternal): MetaDataModel;
-/**
- * Ensures metadata is attached to the selector and returns it.
- *
- * @ignore
- */
-export declare function ensureSelectorMetadata(target: Function): SelectorMetaDataModel;
-/**
- * Get the metadata attached to the selector if it exists.
- *
- * @ignore
- */
-export declare function getSelectorMetadata(target: any): SelectorMetaDataModel;
 /**
  * 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 = [
@@ -100,7 +50,7 @@ export declare function propGetter(paths: string[], config: NgxsConfig): (x: any
  *
  * @ignore
  */
-export declare function buildGraph(stateClasses: StateClassInternal[]): StateKeyGraph;
+export declare function buildGraph(stateClasses: ɵStateClassInternal[]): StateKeyGraph;
 /**
  * Given a states array, returns object graph
  * returning the name and state metadata. Example:
@@ -111,7 +61,7 @@ export declare function buildGraph(stateClasses: StateClassInternal[]): StateKey
  *
  * @ignore
  */
-export declare function nameToState(states: StateClassInternal[]): PlainObjectOf<StateClassInternal>;
+export declare function nameToState(states: ɵStateClassInternal[]): ɵPlainObjectOf<ɵStateClassInternal>;
 /**
  * Given a object relationship graph will return the full path
  * for the child items. Example:
@@ -132,7 +82,7 @@ export declare function nameToState(states: StateClassInternal[]): PlainObjectOf
  *
  * @ignore
  */
-export declare function findFullParentPath(obj: StateKeyGraph, newObj?: PlainObjectOf<string>): PlainObjectOf<string>;
+export declare function findFullParentPath(obj: StateKeyGraph, newObj?: ɵPlainObjectOf<string>): ɵPlainObjectOf<string>;
 /**
  * Given a object graph, it will return the items topologically sorted Example:
  *
@@ -153,9 +103,3 @@ export declare function findFullParentPath(obj: StateKeyGraph, newObj?: PlainObj
  * @ignore
  */
 export declare function topologicalSort(graph: StateKeyGraph): string[];
-/**
- * Returns if the parameter is a object or not.
- *
- * @ignore
- */
-export declare function isObject(obj: any): boolean;

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

@@ -1,21 +1,21 @@
 import { OnDestroy } from '@angular/core';
-import { NgxsBootstrapper } from '@ngxs/store/internals';
+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 _bootstrapper;
+    private _appBootstrappedState;
     private readonly _destroy$;
-    constructor(_store: Store, _internalErrorReporter: InternalErrorReporter, _internalStateOperations: InternalStateOperations, _stateContextFactory: StateContextFactory, _bootstrapper: NgxsBootstrapper);
+    private _initStateHasBeenDispatched?;
+    constructor(_store: Store, _internalStateOperations: InternalStateOperations, _stateContextFactory: StateContextFactory, _appBootstrappedState: ɵNgxsAppBootstrappedState);
     ngOnDestroy(): void;
-    ngxsBootstrap<T>(action: T, results: StatesAndDefaults | undefined): void;
+    ngxsBootstrap(action: InitState | UpdateState, results: StatesAndDefaults | undefined): void;
     private _invokeInitOnStates;
     private _invokeBootstrapOnStates;
     private _getStateContext;

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

@@ -1,7 +1,8 @@
 import { Injector, OnDestroy } from '@angular/core';
+import { ɵStateClassInternal, ɵRuntimeSelectorContext } from '@ngxs/store/internals';
 import { Observable } from 'rxjs';
 import { NgxsConfig } from '../symbols';
-import { MappedStore, StateClassInternal, StatesAndDefaults, StatesByName, RuntimeSelectorContext } from './internals';
+import { MappedStore, StatesAndDefaults, StatesByName } from './internals';
 import { ActionContext, InternalActions } from '../actions-stream';
 import { InternalDispatchedActionResults } from '../internal/dispatcher';
 import { StateContextFactory } from '../internal/state-context-factory';
@@ -28,6 +29,8 @@ export declare class StateFactory implements OnDestroy {
     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[];
@@ -35,22 +38,21 @@ export declare class StateFactory implements OnDestroy {
     get statesByName(): StatesByName;
     private _statePaths;
     private get statePaths();
-    getRuntimeSelectorContext: () => RuntimeSelectorContext;
-    private static _cloneDefaults;
+    getRuntimeSelectorContext: () => ɵRuntimeSelectorContext;
     ngOnDestroy(): void;
     /**
      * Add a new state to the global defs.
      */
-    add(stateClasses: StateClassInternal[]): MappedStore[];
+    add(stateClasses: ɵStateClassInternal[]): MappedStore[];
     /**
      * Add a set of states to the store and return the defaults
      */
-    addAndReturnDefaults(stateClasses: StateClassInternal[]): StatesAndDefaults;
+    addAndReturnDefaults(stateClasses: ɵStateClassInternal[]): StatesAndDefaults;
     connectActionHandlers(): void;
     /**
      * Invoke actions on the states.
      */
-    invokeActions(dispatched$: Observable<ActionContext>, action: any): Observable<unknown[]>;
+    invokeActions(dispatched$: Observable<ActionContext>, action: any): Observable<[any]>;
     private addToStatesMap;
     private addRuntimeInfoToMeta;
     private hasBeenMountedAndBootstrapped;

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

@@ -1,6 +1,6 @@
+import { ɵStateStream } from '@ngxs/store/internals';
 import { StateOperations, StatesAndDefaults } from '../internal/internals';
 import { InternalDispatcher } from '../internal/dispatcher';
-import { StateStream } from './state-stream';
 import { NgxsConfig } from '../symbols';
 import * as i0 from "@angular/core";
 /**
@@ -10,7 +10,7 @@ export declare class InternalStateOperations {
     private _stateStream;
     private _dispatcher;
     private _config;
-    constructor(_stateStream: StateStream, _dispatcher: InternalDispatcher, _config: NgxsConfig);
+    constructor(_stateStream: ɵStateStream, _dispatcher: InternalDispatcher, _config: NgxsConfig);
     /**
      * Returns the root state operators.
      */

package/src/internal/unhandled-rxjs-error-callback.d.ts

@@ -0,0 +1,2 @@
+export declare function executeUnhandledCallback(error: any): boolean;
+export declare function assignUnhandledCallback(error: any, callback: VoidFunction): any;

package/src/module.d.ts

@@ -1,23 +1,12 @@
 import { ModuleWithProviders } from '@angular/core';
-import { StateClass } from '@ngxs/store/internals';
+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";
-/**
- * Ngxs Module
- */
 export declare class NgxsModule {
-    /**
-     * Root module factory
-     */
-    static forRoot(states?: StateClass[], options?: NgxsModuleOptions): ModuleWithProviders<NgxsRootModule>;
-    /**
-     * Feature module factory
-     */
-    static forFeature(states?: StateClass[]): ModuleWithProviders<NgxsFeatureModule>;
-    private static ngxsTokenProviders;
-    private static appBootstrapListenerFactory;
+    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,17 +1,10 @@
-import { Store } from '../store';
-import { InternalStateOperations } from '../internal/state-operations';
-import { StateFactory } from '../internal/state-factory';
-import { LifecycleStateManager } from '../internal/lifecycle-state-manager';
-import { StateClassInternal } from '../internal/internals';
 import * as i0 from "@angular/core";
 /**
- * Feature module
  * @ignore
  */
 export declare class NgxsFeatureModule {
-    constructor(_store: Store, internalStateOperations: InternalStateOperations, factory: StateFactory, states: StateClassInternal<any, any>[][] | undefined, lifecycleStateManager: LifecycleStateManager);
-    private static flattenStates;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsFeatureModule, [null, null, null, { optional: true; }, null]>;
+    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,17 +1,10 @@
-import { StateFactory } from '../internal/state-factory';
-import { InternalStateOperations } from '../internal/state-operations';
-import { Store } from '../store';
-import { SelectFactory } from '../decorators/select/select-factory';
-import { StateClassInternal } from '../internal/internals';
-import { LifecycleStateManager } from '../internal/lifecycle-state-manager';
 import * as i0 from "@angular/core";
 /**
- * Root module
  * @ignore
  */
 export declare class NgxsRootModule {
-    constructor(factory: StateFactory, internalStateOperations: InternalStateOperations, _store: Store, _select: SelectFactory, states: StateClassInternal<any, any>[] | undefined, lifecycleStateManager: LifecycleStateManager);
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsRootModule, [null, null, null, null, { optional: true; }, null]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsRootModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsRootModule, never, never, never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<NgxsRootModule>;
 }

package/src/ngxs-unhandled-error-handler.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+export interface NgxsUnhandledErrorContext {
+    action: any;
+}
+export declare class NgxsUnhandledErrorHandler {
+    private _ngZone;
+    private _errorHandler;
+    /**
+     * The `_unhandledErrorContext` is left unused internally since we do not
+     * require it for internal operations. However, developers who wish to provide
+     * their own custom error handler may utilize this context information.
+     */
+    handleError(error: any, _unhandledErrorContext: NgxsUnhandledErrorContext): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsUnhandledErrorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxsUnhandledErrorHandler>;
+}

package/src/operators/of-action.d.ts

@@ -1,14 +1,14 @@
 import { OperatorFunction } from 'rxjs';
 import { ActionType } from '../actions/symbols';
 import { ActionContext } from '../actions-stream';
-declare type TupleKeys<T extends any[]> = Exclude<keyof T, keyof []>;
+type TupleKeys<T extends any[]> = Exclude<keyof T, keyof []>;
 /**
  * Given a POJO, returns the POJO type, given a class constructor object, returns the type of the class.
  *
  * This utility type exists due to the complexity of ActionType being either an ActionDef class or the plain
  * `{ type: string }` type (or similar compatible POJO types).
  */
-declare type Constructed<T> = T extends new (...args: any[]) => infer U ? U : T;
+type Constructed<T> = T extends new (...args: any[]) => infer U ? U : T;
 export interface ActionCompletion<T = any, E = Error> {
     action: T;
     result: {
@@ -52,5 +52,5 @@ export declare function ofActionCompleted<T extends ActionType[]>(...allowedType
  *
  * This will ONLY grab actions that have just thrown an error
  */
-export declare function ofActionErrored<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
+export declare function ofActionErrored<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, ActionCompletion<Constructed<T[TupleKeys<T>]>>>;
 export {};

package/src/plugin-manager.d.ts

@@ -1,4 +1,4 @@
-import { NgxsPlugin, NgxsPluginFn } from './symbols';
+import { NgxsPlugin, NgxsPluginFn } from '@ngxs/store/plugins';
 import * as i0 from "@angular/core";
 export declare class PluginManager {
     private _parentManager;

package/src/plugin_api.d.ts

@@ -1,5 +1 @@
-export { NgxsModule } from './module';
-export { NGXS_PLUGINS, NgxsPlugin, NgxsPluginFn, NgxsNextPluginFn } from './symbols';
-export { StateStream } from './internal/state-stream';
-export { getActionTypeFromInstance, setValue, getValue } from './utils/utils';
-export { InitState, UpdateState } from './actions/actions';
+export { InitState, UpdateState, getActionTypeFromInstance, setValue, getValue, NGXS_PLUGINS, NgxsPlugin, NgxsPluginFn, NgxsNextPluginFn } from '@ngxs/store/plugins';

package/src/private_api.d.ts

@@ -1,2 +1,3 @@
 export { NgxsRootModule as ɵNgxsRootModule } from './modules/ngxs-root.module';
 export { NgxsFeatureModule as ɵNgxsFeatureModule } from './modules/ngxs-feature.module';
+export * from './selectors/private_api';

package/src/public_api.d.ts

@@ -5,16 +5,19 @@ export { State } from './decorators/state';
 export { Select } from './decorators/select/select';
 export { SelectorOptions } from './decorators/selector-options';
 export { Actions, ActionContext, ActionStatus } from './actions-stream';
-export { getSelectorMetadata, getStoreMetadata, ensureStoreMetadata, ensureSelectorMetadata, } from './public_to_deprecate';
-export { ofAction, ofActionDispatched, ofActionSuccessful, ofActionCanceled, ofActionErrored, ofActionCompleted, ActionCompletion, } from './operators/of-action';
-export { StateContext, StateOperator, NgxsOnInit, NgxsAfterBootstrap, NgxsOnChanges, NgxsModuleOptions, NgxsSimpleChange, } from './symbols';
+export { ofAction, ofActionDispatched, ofActionSuccessful, ofActionCanceled, ofActionErrored, ofActionCompleted, ActionCompletion } from './operators/of-action';
+export { NgxsConfig, StateContext, StateOperator, NgxsOnInit, NgxsAfterBootstrap, NgxsOnChanges, NgxsModuleOptions, NgxsSimpleChange } from './symbols';
 export { Selector } from './decorators/selector/selector';
-export { getActionTypeFromInstance, actionMatcher } from './utils/utils';
 export { NgxsExecutionStrategy } from './execution/symbols';
-export { ActionType, ActionOptions } from './actions/symbols';
+export { ActionType, ActionDef } from './actions/symbols';
 export { NoopNgxsExecutionStrategy } from './execution/noop-ngxs-execution-strategy';
-export { StateToken } from './state-token/state-token';
+export { NgxsUnhandledErrorHandler, NgxsUnhandledErrorContext } from './ngxs-unhandled-error-handler';
 export { NgxsDevelopmentOptions } from './dev-features/symbols';
-export { NgxsDevelopmentModule } from './dev-features/ngxs-development.module';
+export { NgxsDevelopmentModule, withNgxsDevelopmentOptions } from './dev-features/ngxs-development.module';
 export { NgxsUnhandledActionsLogger } from './dev-features/ngxs-unhandled-actions-logger';
-export { createModelSelector, createPickSelector, createPropertySelectors, createSelector, PropertySelectors, TypedSelector, } from './selectors';
+export { createModelSelector, createPickSelector, createPropertySelectors, createSelector, PropertySelectors, TypedSelector } from './selectors';
+export * from './standalone-features';
+export * from './utils/public_api';
+export { StateToken } from '@ngxs/store/internals';
+export { ɵActionOptions as ActionOptions } from '@ngxs/store/internals';
+export { getActionTypeFromInstance, actionMatcher } from '@ngxs/store/plugins';

package/src/selectors/create-model-selector.d.ts

@@ -2,8 +2,8 @@ import { TypedSelector } from './selector-types.util';
 interface SelectorMap {
     [key: string]: TypedSelector<any>;
 }
-declare type ModelSelector<T extends SelectorMap> = (...args: any[]) => MappedResult<T>;
-declare type MappedResult<TSelectorMap> = {
+type ModelSelector<T extends SelectorMap> = (...args: any[]) => MappedResult<T>;
+type MappedResult<TSelectorMap> = {
     [P in keyof TSelectorMap]: TSelectorMap[P] extends TypedSelector<infer R> ? R : never;
 };
 export declare function createModelSelector<T extends SelectorMap>(selectorMap: T): ModelSelector<T>;

package/src/selectors/create-pick-selector.d.ts

@@ -1,5 +1,5 @@
 import { TypedSelector } from './selector-types.util';
-declare type KeysToValues<T, Keys extends (keyof T)[]> = {
+type KeysToValues<T, Keys extends (keyof T)[]> = {
     [Index in keyof Keys]: Keys[Index] extends keyof T ? T[Keys[Index]] : never;
 };
 export declare function createPickSelector<TModel, Keys extends (keyof TModel)[]>(selector: TypedSelector<TModel>, keys: [...Keys]): (...props: KeysToValues<TModel, Keys>) => Pick<TModel, Keys[number]>;

package/src/selectors/create-property-selectors.d.ts

@@ -1,5 +1,5 @@
-import { SelectorDef } from './selector-types.util';
-export declare type PropertySelectors<TModel> = {
+import { ɵSelectorDef } from './selector-types.util';
+export type PropertySelectors<TModel> = {
     [P in keyof NonNullable<TModel>]-?: (model: TModel) => TModel extends null | undefined ? undefined : NonNullable<TModel>[P];
 };
-export declare function createPropertySelectors<TModel>(parentSelector: SelectorDef<TModel>): PropertySelectors<TModel>;
+export declare function createPropertySelectors<TModel>(parentSelector: ɵSelectorDef<TModel>): PropertySelectors<TModel>;

package/src/selectors/create-selector.d.ts

@@ -1,19 +1,19 @@
 import { CreationMetadata } from './selector-models';
-import { SelectorDef, SelectorReturnType } from './selector-types.util';
-declare type SelectorArg = SelectorDef<any>;
+import { ɵSelectorDef, ɵSelectorReturnType } from './selector-types.util';
+type SelectorArg = ɵSelectorDef<any>;
 /**
  * Function for creating a selector
  * @param selectors The selectors to use to create the arguments of this function
  * @param originalFn The original function being made into a selector
  * @param creationMetadata
  */
-export declare function createSelector<S1 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>) => any>(selectors: [S1], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
-export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>) => any>(selectors: [S1, S2], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
-export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>) => any>(selectors: [S1, S2, S3], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
-export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>, s4: SelectorReturnType<S4>) => any>(selectors: [S1, S2, S3, S4], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
-export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>, s4: SelectorReturnType<S4>, s5: SelectorReturnType<S5>) => any>(selectors: [S1, S2, S3, S4, S5], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
-export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, S6 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>, s4: SelectorReturnType<S4>, s5: SelectorReturnType<S5>, s6: SelectorReturnType<S6>) => any>(selectors: [S1, S2, S3, S4, S5, S6], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
-export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, S6 extends SelectorArg, S7 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>, s4: SelectorReturnType<S4>, s5: SelectorReturnType<S5>, s6: SelectorReturnType<S6>, s7: SelectorReturnType<S7>) => any>(selectors: [S1, S2, S3, S4, S5, S6, S7], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
-export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, S6 extends SelectorArg, S7 extends SelectorArg, S8 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>, s4: SelectorReturnType<S4>, s5: SelectorReturnType<S5>, s6: SelectorReturnType<S6>, s7: SelectorReturnType<S7>, s8: SelectorReturnType<S8>) => any>(selectors: [S1, S2, S3, S4, S5, S6, S7, S8], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+export declare function createSelector<S1 extends SelectorArg, TProjector extends (s1: ɵSelectorReturnType<S1>) => any>(selectors: [S1], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, TProjector extends (s1: ɵSelectorReturnType<S1>, s2: ɵSelectorReturnType<S2>) => any>(selectors: [S1, S2], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, TProjector extends (s1: ɵSelectorReturnType<S1>, s2: ɵSelectorReturnType<S2>, s3: ɵSelectorReturnType<S3>) => any>(selectors: [S1, S2, S3], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, TProjector extends (s1: ɵSelectorReturnType<S1>, s2: ɵSelectorReturnType<S2>, s3: ɵSelectorReturnType<S3>, s4: ɵSelectorReturnType<S4>) => any>(selectors: [S1, S2, S3, S4], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, TProjector extends (s1: ɵSelectorReturnType<S1>, s2: ɵSelectorReturnType<S2>, s3: ɵSelectorReturnType<S3>, s4: ɵSelectorReturnType<S4>, s5: ɵSelectorReturnType<S5>) => any>(selectors: [S1, S2, S3, S4, S5], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, S6 extends SelectorArg, TProjector extends (s1: ɵSelectorReturnType<S1>, s2: ɵSelectorReturnType<S2>, s3: ɵSelectorReturnType<S3>, s4: ɵSelectorReturnType<S4>, s5: ɵSelectorReturnType<S5>, s6: ɵSelectorReturnType<S6>) => any>(selectors: [S1, S2, S3, S4, S5, S6], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, S6 extends SelectorArg, S7 extends SelectorArg, TProjector extends (s1: ɵSelectorReturnType<S1>, s2: ɵSelectorReturnType<S2>, s3: ɵSelectorReturnType<S3>, s4: ɵSelectorReturnType<S4>, s5: ɵSelectorReturnType<S5>, s6: ɵSelectorReturnType<S6>, s7: ɵSelectorReturnType<S7>) => any>(selectors: [S1, S2, S3, S4, S5, S6, S7], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+export declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, S6 extends SelectorArg, S7 extends SelectorArg, S8 extends SelectorArg, TProjector extends (s1: ɵSelectorReturnType<S1>, s2: ɵSelectorReturnType<S2>, s3: ɵSelectorReturnType<S3>, s4: ɵSelectorReturnType<S4>, s5: ɵSelectorReturnType<S5>, s6: ɵSelectorReturnType<S6>, s7: ɵSelectorReturnType<S7>, s8: ɵSelectorReturnType<S8>) => any>(selectors: [S1, S2, S3, S4, S5, S6, S7, S8], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
 export declare function createSelector<T extends (...args: any[]) => any>(selectors: SelectorArg[] | undefined, projector: T, creationMetadata?: Partial<CreationMetadata>): T;
 export {};

package/src/selectors/private_api.d.ts

@@ -0,0 +1,7 @@
+/**
+ * These types are exported privately for developers who work on advanced
+ * utilities and may need to use these types externally. For instance,
+ * they may have a function that accepts selector functions and returns
+ * signals with the type corresponding to the return type of those selectors.
+ */
+export { ɵSelectorFunc, ɵStateSelector, ɵSelectorDef, ɵSelectorReturnType } from './selector-types.util';

package/src/selectors/selector-checks.util.d.ts

@@ -1,5 +1,5 @@
-import { SelectorDef } from './selector-types.util';
-export declare function ensureValidSelector(selector: SelectorDef<any>, context?: {
+import { ɵSelectorDef } from './selector-types.util';
+export declare function ensureValidSelector(selector: ɵSelectorDef<any>, context?: {
     prefix?: string;
     noun?: string;
 }): void;

package/src/selectors/selector-metadata.d.ts

@@ -1,7 +1,7 @@
-import { SelectorMetaDataModel, SharedSelectorOptions } from '../internal/internals';
+import { ɵSelectorMetaDataModel, ɵSharedSelectorOptions } from '@ngxs/store/internals';
 import { CreationMetadata } from './selector-models';
 export declare const selectorOptionsMetaAccessor: {
-    getOptions: (target: any) => SharedSelectorOptions;
-    defineOptions: (target: any, options: SharedSelectorOptions) => void;
+    getOptions: (target: any) => ɵSharedSelectorOptions;
+    defineOptions: (target: any, options: ɵSharedSelectorOptions) => void;
 };
-export declare function setupSelectorMetadata<T extends (...args: any[]) => any>(originalFn: T, creationMetadata: Partial<CreationMetadata> | undefined): SelectorMetaDataModel;
+export declare function setupSelectorMetadata<T extends (...args: any[]) => any>(originalFn: T, creationMetadata: Partial<CreationMetadata> | undefined): ɵSelectorMetaDataModel;

package/src/selectors/selector-models.d.ts

@@ -1,10 +1,10 @@
-import { SharedSelectorOptions, SelectFromRootState } from '../internal/internals';
+import { ɵSharedSelectorOptions, ɵSelectFromRootState } from '@ngxs/store/internals';
 export interface CreationMetadata {
     containerClass: any;
     selectorName: string;
-    getSelectorOptions?: () => SharedSelectorOptions;
+    getSelectorOptions?: () => ɵSharedSelectorOptions;
 }
 export interface RuntimeSelectorInfo {
-    selectorOptions: SharedSelectorOptions;
-    argumentSelectorFunctions: SelectFromRootState[];
+    selectorOptions: ɵSharedSelectorOptions;
+    argumentSelectorFunctions: ɵSelectFromRootState[];
 }

package/src/selectors/selector-types.util.d.ts

@@ -1,7 +1,6 @@
-import { StateClass } from '@ngxs/store/internals';
-import { StateToken } from '../state-token/state-token';
-export declare type SelectorFunc<TModel> = (...arg: any[]) => TModel;
-export declare type TypedSelector<TModel> = StateToken<TModel> | SelectorFunc<TModel>;
-export declare type StateSelector = StateClass<any>;
-export declare type SelectorDef<TModel> = StateSelector | TypedSelector<TModel>;
-export declare type SelectorReturnType<T extends SelectorDef<any>> = T extends StateToken<infer R1> ? R1 : T extends SelectorFunc<infer R2> ? R2 : T extends StateClass<any> ? any : never;
+import { ɵStateClass, StateToken } from '@ngxs/store/internals';
+export type ɵSelectorFunc<TModel> = (...arg: any[]) => TModel;
+export type TypedSelector<TModel> = StateToken<TModel> | ɵSelectorFunc<TModel>;
+export type ɵStateSelector = ɵStateClass<any>;
+export type ɵSelectorDef<TModel> = ɵStateSelector | TypedSelector<TModel>;
+export type ɵSelectorReturnType<T extends ɵSelectorDef<any>> = T extends StateToken<infer R1> ? R1 : T extends ɵSelectorFunc<infer R2> ? R2 : T extends ɵStateClass<any> ? any : never;

package/src/selectors/selector-utils.d.ts

@@ -1,9 +1,9 @@
-import { SelectorMetaDataModel, SelectorFactory } from '../internal/internals';
+import { ɵSelectorFactory, ɵSelectorMetaDataModel } from '@ngxs/store/internals';
 import { CreationMetadata } from './selector-models';
-export declare function createRootSelectorFactory<T extends (...args: any[]) => any>(selectorMetaData: SelectorMetaDataModel, selectors: any[] | undefined, memoizedSelectorFn: T): SelectorFactory;
+export declare function createRootSelectorFactory<T extends (...args: any[]) => any>(selectorMetaData: ɵSelectorMetaDataModel, selectors: any[] | undefined, memoizedSelectorFn: T): ɵSelectorFactory;
 export declare function createMemoizedSelectorFn<T extends (...args: any[]) => any>(originalFn: T, creationMetadata: Partial<CreationMetadata> | undefined): T;
 /**
  * This function gets the factory function to create the selector to get the selected slice from the app state
  * @ignore
  */
-export declare function getRootSelectorFactory(selector: any): SelectorFactory;
+export declare function getRootSelectorFactory(selector: any): ɵSelectorFactory;

package/src/standalone-features/feature-providers.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from '@angular/core';
+import { ɵStateClass } from '@ngxs/store/internals';
+/**
+ * This function provides the required providers when calling `NgxsModule.forFeature`
+ * or `provideStates`. It is shared between the NgModule and standalone APIs.
+ */
+export declare function getFeatureProviders(states: ɵStateClass[]): Provider[];

package/src/standalone-features/index.d.ts

@@ -0,0 +1,4 @@
+export { provideStore } from './provide-store';
+export { provideStates } from './provide-states';
+export { withNgxsPlugin } from './plugin';
+export { withNgxsPreboot } from './preboot';

package/src/standalone-features/initializers.d.ts

@@ -0,0 +1,29 @@
+import { InjectionToken, Provider } from '@angular/core';
+/**
+ * This function is shared by both NgModule and standalone features.
+ * When using `NgxsModule.forRoot` and `provideStore`, we can depend on the
+ * same initialization functionality.
+ */
+export declare function rootStoreInitializer(): void;
+/**
+ * This function is utilized by both NgModule and standalone features.
+ * When using `NgxsModule.forFeature` and `provideStates`, we can depend on
+ * the same initialization functionality.
+ */
+export declare function featureStatesInitializer(): void;
+/**
+ * InjectionToken that registers the global Store.
+ */
+export declare const NGXS_ROOT_STORE_INITIALIZER: InjectionToken<void>;
+/**
+ * InjectionToken that registers feature states.
+ */
+export declare const NGXS_FEATURE_STORE_INITIALIZER: InjectionToken<void>;
+export declare const NGXS_ROOT_ENVIRONMENT_INITIALIZER: Provider[];
+/**
+ * The `NGXS_FEATURE_ENVIRONMENT_INITIALIZER` functions as an environment initializer
+ * at the `Route` level. Angular Router creates an environment route injector for each
+ * matched route where navigation occurs. The injector is created once, ensuring that
+ * the feature states initialization only happens once as well.
+ */
+export declare const NGXS_FEATURE_ENVIRONMENT_INITIALIZER: Provider[];

package/src/standalone-features/plugin.d.ts

@@ -0,0 +1,17 @@
+import { EnvironmentProviders, Type } from '@angular/core';
+import { NgxsPlugin } from '@ngxs/store/plugins';
+/**
+ * This function registers a custom global plugin for the state.
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideStore(
+ *       [CountriesState],
+ *       withNgxsPlugin(LogoutPlugin)
+ *     )
+ *   ]
+ * });
+ * ```
+ */
+export declare function withNgxsPlugin(plugin: Type<NgxsPlugin>): EnvironmentProviders;