@ngxs/store 18.1.2-dev.master-cbc269d → 18.1.2-dev.master-eaf3f9d

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

@@ -1,56 +0,0 @@
-import { OperatorFunction } from 'rxjs';
-import { ActionType } from '../actions/symbols';
-import { ActionContext } from '../actions-stream';
-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).
- */
-type Constructed<T> = T extends new (...args: any[]) => infer U ? U : T;
-export interface ActionCompletion<T = any, E = Error> {
-    action: T;
-    result: {
-        successful: boolean;
-        canceled: boolean;
-        error?: E;
-    };
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will grab actions that have just been dispatched as well as actions that have completed
- */
-export declare function ofAction<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been dispatched
- */
-export declare function ofActionDispatched<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been successfully completed
- */
-export declare function ofActionSuccessful<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been canceled
- */
-export declare function ofActionCanceled<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been completed
- */
-export declare function ofActionCompleted<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, ActionCompletion<Constructed<T[TupleKeys<T>]>>>;
-/**
- * RxJS operator for selecting out specific actions.
- *
- * 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>]>>, ActionCompletion<Constructed<T[TupleKeys<T>]>>>;
-export {};

package/src/plugin-manager.d.ts

@@ -1,13 +0,0 @@
-import { NgxsPluginFn } from '@ngxs/store/plugins';
-import * as i0 from "@angular/core";
-export declare class PluginManager {
-    readonly plugins: NgxsPluginFn[];
-    private readonly _parentManager;
-    private readonly _pluginHandlers;
-    constructor();
-    private get _rootPlugins();
-    private registerHandlers;
-    private getPluginHandlers;
-    static ɵfac: i0.ɵɵFactoryDeclaration<PluginManager, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<PluginManager>;
-}

package/src/plugin_api.d.ts

@@ -1 +0,0 @@
-export { InitState, UpdateState, getActionTypeFromInstance, setValue, getValue, NGXS_PLUGINS, NgxsPlugin, NgxsPluginFn, NgxsNextPluginFn } from '@ngxs/store/plugins';

package/src/private_api.d.ts

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

@@ -1,23 +0,0 @@
-export { NgxsModule } from './module';
-export { Action } from './decorators/action';
-export { Store } from './store';
-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 { 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 { NgxsExecutionStrategy } from './execution/symbols';
-export { ActionType, ActionDef } from './actions/symbols';
-export { NoopNgxsExecutionStrategy } from './execution/noop-ngxs-execution-strategy';
-export { NgxsUnhandledErrorHandler, NgxsUnhandledErrorContext } from './ngxs-unhandled-error-handler';
-export { NgxsDevelopmentOptions } from './dev-features/symbols';
-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 * 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

@@ -1,10 +0,0 @@
-import { TypedSelector } from './selector-types.util';
-interface SelectorMap {
-    [key: string]: TypedSelector<any>;
-}
-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>;
-export {};

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

@@ -1,6 +0,0 @@
-import { TypedSelector } from './selector-types.util';
-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]>;
-export {};

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

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

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

@@ -1,19 +0,0 @@
-import { CreationMetadata } from './selector-models';
-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<T extends (...args: any[]) => any>(selectors: SelectorArg[] | undefined, projector: T, creationMetadata?: Partial<CreationMetadata>): T;
-export {};

package/src/selectors/index.d.ts

@@ -1,5 +0,0 @@
-export * from './create-model-selector';
-export * from './create-pick-selector';
-export * from './create-property-selectors';
-export * from './create-selector';
-export * from './selector-types.util';

package/src/selectors/private_api.d.ts

@@ -1,7 +0,0 @@
-/**
- * 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,9 +0,0 @@
-import { ɵSelectorDef } from './selector-types.util';
-export declare function ensureValidSelector(selector: ɵSelectorDef<any>, context?: {
-    prefix?: string;
-    noun?: string;
-}): void;
-export declare function ensureValueProvided(value: any, context?: {
-    prefix?: string;
-    noun?: string;
-}): void;

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

@@ -1,7 +0,0 @@
-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;
-};
-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 +0,0 @@
-import { ɵSharedSelectorOptions, ɵSelectFromRootState } from '@ngxs/store/internals';
-export interface CreationMetadata {
-    containerClass: any;
-    selectorName: string;
-    getSelectorOptions?: () => ɵSharedSelectorOptions;
-}
-export interface RuntimeSelectorInfo {
-    selectorOptions: ɵSharedSelectorOptions;
-    argumentSelectorFunctions: ɵSelectFromRootState[];
-}

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

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

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

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

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

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

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

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

@@ -1,26 +0,0 @@
-import { InjectionToken } from '@angular/core';
-/**
- * InjectionToken that registers preboot functions (called before the root initializer).
- */
-export declare const NGXS_PREBOOT_FNS: InjectionToken<VoidFunction[]>;
-/**
- * This function registers a preboot function which will be called before the root
- * store initializer is run, but after all of the NGXS features are provided and
- * available for injection. This is useful for registering action stream listeners
- * before any action is dispatched.
- *
- * ```ts
- * bootstrapApplication(AppComponent, {
- *   providers: [
- *     provideStore(
- *       [CountriesState],
- *       withNgxsPreboot(() => {
- *         const actions$ = inject(Actions);
- *         actions$.subscribe(ctx => console.log(ctx));
- *       })
- *     )
- *   ]
- * });
- * ```
- */
-export declare function withNgxsPreboot(prebootFn: VoidFunction): import("@angular/core").EnvironmentProviders;

package/src/standalone-features/provide-states.d.ts

@@ -1,18 +0,0 @@
-import { EnvironmentProviders } from '@angular/core';
-import { ɵStateClass } from '@ngxs/store/internals';
-/**
- * This version serves as a standalone alternative to `NgxsModule.forFeature`.
- * It can be used in a similar manner to register feature states, but at the
- * `Route` providers level:
- *
- * ```ts
- * const routes: Routes = [
- *   {
- *     path: 'products',
- *     loadComponent: async () => {...},
- *     providers: [provideStates([ProductsState])]
- *   }
- * ];
- * ```
- */
-export declare function provideStates(states: ɵStateClass[], ...features: EnvironmentProviders[]): EnvironmentProviders;

package/src/standalone-features/provide-store.d.ts

@@ -1,22 +0,0 @@
-import { EnvironmentProviders } from '@angular/core';
-import { ɵStateClass } from '@ngxs/store/internals';
-import { NgxsModuleOptions } from '../symbols';
-/**
- * This function provides global store providers and initializes the store.
- *
- * ```ts
- * bootstrapApplication(AppComponent, {
- *   providers: [provideStore([CountriesState])]
- * });
- * ```
- *
- * The `provideStore` may be optionally called with a config before the list of features:
- *
- * ```ts
- * provideStore([CountriesState], {
- *   developmentMode: !environment.production
- * });
- * ```
- */
-export declare function provideStore(states?: ɵStateClass[], ...features: EnvironmentProviders[]): EnvironmentProviders;
-export declare function provideStore(states?: ɵStateClass[], options?: NgxsModuleOptions, ...features: EnvironmentProviders[]): EnvironmentProviders;

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

@@ -1,8 +0,0 @@
-import { Provider } from '@angular/core';
-import { ɵStateClass } from '@ngxs/store/internals';
-import { NgxsModuleOptions } from '../symbols';
-/**
- * This function provides the required providers when invoking `NgxsModule.forRoot`
- * or `provideStore`. It is shared between the NgModule and standalone APIs.
- */
-export declare function getRootProviders(states: ɵStateClass[], options: NgxsModuleOptions): Provider[];

package/src/store.d.ts

@@ -1,60 +0,0 @@
-import { Signal } from '@angular/core';
-import { Observable, Subscription } from 'rxjs';
-import { ɵStateStream } from '@ngxs/store/internals';
-import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
-import { InternalStateOperations } from './internal/state-operations';
-import { NgxsConfig } from './symbols';
-import { StateFactory } from './internal/state-factory';
-import { TypedSelector } from './selectors';
-import * as i0 from "@angular/core";
-export declare class Store {
-    private _stateStream;
-    private _internalStateOperations;
-    private _config;
-    private _internalExecutionStrategy;
-    private _stateFactory;
-    /**
-     * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
-     * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
-     * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
-     */
-    private _selectableStateStream;
-    constructor(_stateStream: ɵStateStream, _internalStateOperations: InternalStateOperations, _config: NgxsConfig, _internalExecutionStrategy: InternalNgxsExecutionStrategy, _stateFactory: StateFactory, initialStateValue: any);
-    /**
-     * Dispatches event(s).
-     */
-    dispatch(actionOrActions: any | any[]): Observable<void>;
-    /**
-     * Selects a slice of data from the store.
-     */
-    select<T>(selector: TypedSelector<T>): Observable<T>;
-    /**
-     * Select one slice of data from the store.
-     */
-    selectOnce<T>(selector: TypedSelector<T>): Observable<T>;
-    /**
-     * Select a snapshot from the state.
-     */
-    selectSnapshot<T>(selector: TypedSelector<T>): T;
-    /**
-     * Select a signal from the state.
-     */
-    selectSignal<T>(selector: TypedSelector<T>): Signal<T>;
-    /**
-     * Allow the user to subscribe to the root of the state
-     */
-    subscribe(fn?: (value: any) => void): Subscription;
-    /**
-     * Return the raw value of the state.
-     */
-    snapshot(): any;
-    /**
-     * Reset the state to a specific point in time. This method is useful
-     * for plugin's who need to modify the state directly or unit testing.
-     */
-    reset(state: any): void;
-    private getStoreBoundSelectorFn;
-    private initStateStream;
-    static ɵfac: i0.ɵɵFactoryDeclaration<Store, [null, null, null, null, null, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<Store>;
-}

package/src/symbols.d.ts

@@ -1,102 +0,0 @@
-import { InjectionToken, Type } from '@angular/core';
-import { Observable } from 'rxjs';
-import { StateOperator } from '@ngxs/store/operators';
-import { ɵSharedSelectorOptions, ɵStateClass } from '@ngxs/store/internals';
-import { NgxsExecutionStrategy } from './execution/symbols';
-import * as i0 from "@angular/core";
-export declare const ROOT_STATE_TOKEN: InjectionToken<ɵStateClass[]>;
-export declare const FEATURE_STATE_TOKEN: InjectionToken<ɵStateClass[][]>;
-export declare const NGXS_OPTIONS: InjectionToken<Partial<NgxsConfig>>;
-export type NgxsLifeCycle = Partial<NgxsOnChanges> & Partial<NgxsOnInit> & Partial<NgxsAfterBootstrap>;
-/**
- * The NGXS config settings.
- */
-export declare class NgxsConfig {
-    /**
-     * Run in development mode. This will add additional debugging features:
-     * - Object.freeze on the state and actions to guarantee immutability
-     * (default: false)
-     *
-     * Note: this property will be accounted only in development mode.
-     * It makes sense to use it only during development to ensure there're no state mutations.
-     * When building for production, the `Object.freeze` will be tree-shaken away.
-     */
-    developmentMode: boolean;
-    compatibility: {
-        /**
-         * Support a strict Content Security Policy.
-         * This will circumvent some optimisations that violate a strict CSP through the use of `new Function(...)`.
-         * (default: false)
-         */
-        strictContentSecurityPolicy: boolean;
-    };
-    /**
-     * Determines the execution context to perform async operations inside. An implementation can be
-     * provided to override the default behaviour where the async operations are run
-     * outside Angular's zone but all observable behaviours of NGXS are run back inside Angular's zone.
-     * These observable behaviours are from:
-     *   `store.selectSignal(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`
-     * Every `zone.run` causes Angular to run change detection on the whole tree (`app.tick()`) so of your
-     * application doesn't rely on zone.js running change detection then you can switch to the
-     * `NoopNgxsExecutionStrategy` that doesn't interact with zones.
-     * (default: null)
-     */
-    executionStrategy: Type<NgxsExecutionStrategy>;
-    /**
-     * Defining shared selector options
-     */
-    selectorOptions: ɵSharedSelectorOptions;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsConfig, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NgxsConfig>;
-}
-export { StateOperator };
-/**
- * State context provided to the actions in the state.
- */
-export interface StateContext<T> {
-    /**
-     * Get the current state.
-     */
-    getState(): T;
-    /**
-     * Reset the state to a new value.
-     */
-    setState(val: T | StateOperator<T>): void;
-    /**
-     * Patch the existing state with the provided value.
-     */
-    patchState(val: Partial<T>): void;
-    /**
-     * Dispatch a new action and return the dispatched observable.
-     */
-    dispatch(actions: any | any[]): Observable<void>;
-}
-/**
- * Represents a basic change from a previous to a new value for a single state instance.
- * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.
- */
-export declare class NgxsSimpleChange<T = any> {
-    readonly previousValue: T;
-    readonly currentValue: T;
-    readonly firstChange: boolean;
-    constructor(previousValue: T, currentValue: T, firstChange: boolean);
-}
-/**
- * On init interface
- */
-export interface NgxsOnInit {
-    ngxsOnInit(ctx: StateContext<any>): void;
-}
-/**
- * On change interface
- */
-export interface NgxsOnChanges {
-    ngxsOnChanges(change: NgxsSimpleChange): void;
-}
-/**
- * After bootstrap interface
- */
-export interface NgxsAfterBootstrap {
-    ngxsAfterBootstrap(ctx: StateContext<any>): void;
-}
-export type NgxsModuleOptions = Partial<NgxsConfig>;

package/src/utils/compose.d.ts

@@ -1,23 +0,0 @@
-export type StateFn = (...args: any[]) => any;
-/**
- * Composes a array of functions from left to right. Example:
- *
- *      compose([fn, final])(state, action);
- *
- * then the funcs have a signature like:
- *
- *      function fn (state, action, next) {
- *          console.log('here', state, action, next);
- *          return next(state, action);
- *      }
- *
- *      function final (state, action) {
- *          console.log('here', state, action);
- *          return state;
- *      }
- *
- * the last function should not call `next`.
- *
- * @ignore
- */
-export declare const compose: (funcs: StateFn[]) => (...args: any[]) => any;

package/src/utils/create-dispatch-map.d.ts

@@ -1,4 +0,0 @@
-import { Observable } from 'rxjs';
-import { ActionDef } from '../actions/symbols';
-export type ActionMap = Record<string, ActionDef<any>>;
-export declare function createDispatchMap<T extends ActionMap>(actionMap: T): { readonly [K in keyof T]: (...args: ConstructorParameters<T[K]>) => Observable<void>; };

package/src/utils/create-select-map.d.ts

@@ -1,4 +0,0 @@
-import { Signal } from '@angular/core';
-import { TypedSelector, ɵSelectorReturnType } from '../selectors';
-export type SelectorMap = Record<string, TypedSelector<unknown>>;
-export declare function createSelectMap<T extends SelectorMap>(selectorMap: T): { readonly [K in keyof T]: Signal<ɵSelectorReturnType<T[K]>>; };

package/src/utils/dispatch.d.ts

@@ -1,2 +0,0 @@
-import { ActionDef } from '../actions/symbols';
-export declare function dispatch<TArgs extends any[]>(ActionType: ActionDef<TArgs>): (...args: TArgs) => import("rxjs").Observable<void>;

package/src/utils/freeze.d.ts

@@ -1,5 +0,0 @@
-/**
- * Object freeze code
- * https://github.com/jsdf/deep-freeze
- */
-export declare const deepFreeze: (o: any) => any;

package/src/utils/public_api.d.ts

@@ -1,4 +0,0 @@
-export { select } from './select';
-export { dispatch } from './dispatch';
-export { SelectorMap, createSelectMap } from './create-select-map';
-export { ActionMap, createDispatchMap } from './create-dispatch-map';

package/src/utils/select.d.ts

@@ -1,16 +0,0 @@
-import { Signal } from '@angular/core';
-import { TypedSelector } from '../selectors';
-/**
- * This function serves as a utility and has multiple purposes.
- * Firstly, it allows you to select properties from the state class
- * without having to inject the store class and use `this.store.selectSignal`,
- * resulting in a more concise implementation. Secondly, it can be used with
- * other solutions such as NgRx signal store with its `signalStoreFeature` or
- * `withComputed` functionalities.
- *
- * Please note that it's named `select` instead of `selectSignal` because
- * signals are evolving into first-class primitives in Angular, displacing other
- * primitives such as observables. Observables represent a stream of events,
- * whereas signals represent a single value changing over time.
- */
-export declare function select<T>(selector: TypedSelector<T>): Signal<T>;

package/src/utils/store-validators.d.ts

@@ -1,5 +0,0 @@
-import { ɵStateClassInternal } from '@ngxs/store/internals';
-import { StatesByName } from '../internal/internals';
-export declare function ensureStateNameIsValid(name: string | null): void | never;
-export declare function ensureStateNameIsUnique(stateName: string, state: ɵStateClassInternal, statesByName: StatesByName): void | never;
-export declare function ensureStatesAreDecorated(stateClasses: ɵStateClassInternal[]): void | never;