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

package/internals/index.d.ts

@@ -1,10 +1,206 @@
-export * from './symbols';
-export * from './metadata';
-export { ɵmemoize } from './memoize';
-export { StateToken } from './state-token';
-export { ɵINITIAL_STATE_TOKEN, ɵInitialState } from './initial-state';
-export { ɵNgxsAppBootstrappedState } from './ngxs-app-bootstrapped-state';
-export { ɵNGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY } from './internal-tokens';
-export { ɵOrderedSubject, ɵOrderedBehaviorSubject } from './custom-rxjs-subjects';
-export { ɵwrapObserverCalls } from './custom-rxjs-operators';
-export { ɵStateStream } from './state-stream';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, Signal } from '@angular/core';
+import { ReplaySubject, Subject, BehaviorSubject, MonoTypeOperatorFunction } from 'rxjs';
+
+declare class StateToken<T = void> {
+    private readonly _name;
+    constructor(_name: ɵTokenName<T>);
+    getName(): string;
+    toString(): string;
+}
+
+interface ɵPlainObject {
+    [key: string]: any;
+}
+interface ɵPlainObjectOf<T> {
+    [key: string]: T;
+}
+type ɵStateClass<T = any> = new (...args: any[]) => T;
+declare const ɵMETA_KEY = "NGXS_META";
+declare const ɵMETA_OPTIONS_KEY = "NGXS_OPTIONS_META";
+declare const ɵSELECTOR_META_KEY = "NGXS_SELECTOR_META";
+interface ɵStateToken<T, U> {
+    new (name: ɵTokenName<T>): U;
+    getName(): string;
+    toString(): string;
+}
+type RequireGeneric<T, U> = T extends void ? 'You must provide a type parameter' : U;
+type ɵTokenName<T> = string & RequireGeneric<T, string>;
+type ɵExtractTokenType<P> = P extends StateToken<infer T> ? T : never;
+/**
+ * Options that can be provided to the store.
+ */
+interface ɵStoreOptions<T> {
+    /**
+     * Name of the state. Required.
+     */
+    name: string | StateToken<T>;
+    /**
+     * Default values for the state. If not provided, uses empty object.
+     */
+    defaults?: T;
+    /**
+     * Sub states for the given state.
+     *
+     * @deprecated
+     * Read the deprecation notice at this link: https://ngxs.io/deprecations/sub-states-deprecation.
+     */
+    children?: ɵStateClass[];
+}
+interface ɵStateClassInternal<T = any, U = any> extends ɵStateClass<T> {
+    [ɵMETA_KEY]?: ɵMetaDataModel;
+    [ɵMETA_OPTIONS_KEY]?: ɵStoreOptions<U>;
+}
+interface ɵMetaDataModel {
+    name: string | null;
+    actions: ɵPlainObjectOf<ɵActionHandlerMetaData[]>;
+    defaults: any;
+    path: string | null;
+    makeRootSelector: ɵSelectorFactory | null;
+    /** @deprecated */
+    children?: ɵStateClassInternal[];
+}
+interface ɵSelectorMetaDataModel {
+    makeRootSelector: ɵSelectorFactory | null;
+    originalFn: Function | null;
+    containerClass: any;
+    selectorName: string | null;
+    getSelectorOptions: () => ɵSharedSelectorOptions;
+}
+interface ɵSharedSelectorOptions {
+    /**
+     * @deprecated
+     * Read the deprecation notice at this link: https://ngxs.io/deprecations/inject-container-state-deprecation.md.
+     */
+    injectContainerState?: boolean;
+    suppressErrors?: boolean;
+}
+interface ɵRuntimeSelectorContext {
+    getStateGetter(key: any): (state: any) => any;
+    getSelectorOptions(localOptions?: ɵSharedSelectorOptions): ɵSharedSelectorOptions;
+}
+type ɵSelectFromRootState = (rootState: any) => any;
+type ɵSelectorFactory = (runtimeContext: ɵRuntimeSelectorContext) => ɵSelectFromRootState;
+/**
+ * Actions that can be provided in a action decorator.
+ */
+interface ɵActionOptions {
+    /**
+     * Cancel the previous uncompleted observable(s).
+     */
+    cancelUncompleted?: boolean;
+}
+interface ɵActionHandlerMetaData {
+    fn: string | symbol;
+    options: ɵActionOptions;
+    type: string;
+}
+
+/**
+ * Ensures metadata is attached to the class and returns it.
+ *
+ * @ignore
+ */
+declare function ɵensureStoreMetadata(target: ɵStateClassInternal): ɵMetaDataModel;
+/**
+ * Get the metadata attached to the state class if it exists.
+ *
+ * @ignore
+ */
+declare function ɵgetStoreMetadata(target: ɵStateClassInternal): ɵMetaDataModel;
+/**
+ * Ensures metadata is attached to the selector and returns it.
+ *
+ * @ignore
+ */
+declare function ɵensureSelectorMetadata(target: Function): ɵSelectorMetaDataModel;
+/**
+ * Get the metadata attached to the selector if it exists.
+ *
+ * @ignore
+ */
+declare function ɵgetSelectorMetadata(target: any): ɵSelectorMetaDataModel;
+
+declare function defaultEqualityCheck(a: any, b: any): boolean;
+/**
+ * Memoize a function on its last inputs only.
+ * Originally from: https://github.com/reduxjs/reselect/blob/master/src/index.js
+ *
+ * @ignore
+ */
+declare function ɵmemoize<T extends (...args: any[]) => any>(func: T, equalityCheck?: typeof defaultEqualityCheck): T;
+
+declare class ɵInitialState {
+    private static _value;
+    static set(state: ɵPlainObject): void;
+    static pop(): ɵPlainObject;
+}
+declare const ɵINITIAL_STATE_TOKEN: InjectionToken<ɵPlainObject>;
+
+declare class ɵNgxsAppBootstrappedState extends ReplaySubject<boolean> {
+    constructor();
+    bootstrap(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ɵNgxsAppBootstrappedState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ɵNgxsAppBootstrappedState>;
+}
+
+declare const ɵNGXS_STATE_FACTORY: InjectionToken<any>;
+declare const ɵNGXS_STATE_CONTEXT_FACTORY: InjectionToken<any>;
+
+/**
+ * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
+ * A standard Subject does not have this guarantee.
+ * For example, given the following code:
+ * ```typescript
+ *   const subject = new Subject<string>();
+     subject.subscribe(value => {
+       if (value === 'start') subject.next('end');
+     });
+     subject.subscribe(value => { });
+     subject.next('start');
+ * ```
+ * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
+ * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
+ */
+declare class ɵOrderedSubject<T> extends Subject<T> {
+    private _orderedNext;
+    next(value?: T): void;
+}
+/**
+ * Custom BehaviorSubject that ensures that subscribers are notified of values in the order that they arrived.
+ * A standard BehaviorSubject does not have this guarantee.
+ * For example, given the following code:
+ * ```typescript
+ *   const subject = new BehaviorSubject<string>();
+     subject.subscribe(value => {
+       if (value === 'start') subject.next('end');
+     });
+     subject.subscribe(value => { });
+     subject.next('start');
+ * ```
+ * When `subject` is a standard `BehaviorSubject<T>` the second subscriber would recieve `end` and then `start`.
+ * When `subject` is a `OrderedBehaviorSubject<T>` the second subscriber would recieve `start` and then `end`.
+ */
+declare class ɵOrderedBehaviorSubject<T> extends BehaviorSubject<T> {
+    private _orderedNext;
+    private _currentValue;
+    constructor(value: T);
+    getValue(): T;
+    next(value: T): void;
+}
+
+declare function ɵwrapObserverCalls<TValue>(invokeFn: (fn: () => void) => void): MonoTypeOperatorFunction<TValue>;
+
+/**
+ * BehaviorSubject of the entire state.
+ * @ignore
+ */
+declare class ɵStateStream extends ɵOrderedBehaviorSubject<ɵPlainObject> implements OnDestroy {
+    readonly state: Signal<ɵPlainObject>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ɵStateStream, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ɵStateStream>;
+}
+
+export { StateToken, type ɵActionHandlerMetaData, type ɵActionOptions, type ɵExtractTokenType, ɵINITIAL_STATE_TOKEN, ɵInitialState, ɵMETA_KEY, ɵMETA_OPTIONS_KEY, type ɵMetaDataModel, ɵNGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY, ɵNgxsAppBootstrappedState, ɵOrderedBehaviorSubject, ɵOrderedSubject, type ɵPlainObject, type ɵPlainObjectOf, type ɵRuntimeSelectorContext, ɵSELECTOR_META_KEY, type ɵSelectFromRootState, type ɵSelectorFactory, type ɵSelectorMetaDataModel, type ɵSharedSelectorOptions, type ɵStateClass, type ɵStateClassInternal, ɵStateStream, type ɵStateToken, type ɵStoreOptions, type ɵTokenName, ɵensureSelectorMetadata, ɵensureStoreMetadata, ɵgetSelectorMetadata, ɵgetStoreMetadata, ɵmemoize, ɵwrapObserverCalls };

package/internals/testing/index.d.ts

@@ -1,4 +1,31 @@
-export { freshPlatform } from './fresh-platform';
-export { NgxsTestBed } from './ngxs.setup';
-export { skipConsoleLogging, ConsoleRecord, ConsoleRecorder, loggedError } from './skip-console-logging';
-export { NgxsTesting } from './symbol';
+import { Store, NgxsModuleOptions } from '@ngxs/store';
+import { ModuleWithProviders } from '@angular/core';
+import { TestBedStatic } from '@angular/core/testing';
+import { ɵStateClass as _StateClass } from '@ngxs/store/internals';
+
+declare function freshPlatform(fn: (done?: VoidFunction) => Promise<void>): () => Promise<void>;
+
+interface NgxsOptionsTesting {
+    states?: _StateClass[];
+    ngxsOptions?: NgxsModuleOptions;
+    imports?: ModuleWithProviders<any>[];
+    before?: () => void;
+}
+interface NgxsTesting {
+    store: Store;
+    getTestBed: TestBedStatic;
+}
+
+declare class NgxsTestBed {
+    static configureTestingStates(options: NgxsOptionsTesting): NgxsTesting;
+    private static ngxsBootstrap;
+    private static resetTestBed;
+    private static createRootNode;
+}
+
+type ConsoleRecord = [string, any[]];
+type ConsoleRecorder = ConsoleRecord[];
+declare function loggedError(message: string): ConsoleRecord;
+declare function skipConsoleLogging<T extends (...args: any[]) => any>(fn: T, consoleRecorder?: ConsoleRecorder): ReturnType<T>;
+
+export { type ConsoleRecord, type ConsoleRecorder, NgxsTestBed, type NgxsTesting, freshPlatform, loggedError, skipConsoleLogging };

package/operators/index.d.ts

@@ -1,14 +1,102 @@
+type _NoInfer<T> = T extends infer S ? S : never;
 /**
- * @module
- * @description
- * Entry point for all public APIs of this package.
- */
-export { append } from './append';
-export { compose } from './compose';
-export { iif } from './iif';
-export { insertItem } from './insert-item';
-export { patch, ɵPatchSpec } from './patch';
-export { isStateOperator, isPredicate, Predicate } from './utils';
-export { updateItem } from './update-item';
-export { removeItem } from './remove-item';
-export { ExistingState, NoInfer, StateOperator } from './types';
+ * Blocks the ability of the typescript inferrence engine to be able to use the provided type as part of
+ * inferring any type parameters from this usage.
+ * @example
+ * Primarily used to wrap parameters of functions in order to prevent the TypeScript inferrence engine
+ * from inferring a type parameter of the function from the value provided to this parameter.
+ * This essentially blocks the Contravariance of the function (through its parameters) so that the
+ * function type parameter is purely determined by the Covariant requirements of the function's return type.
+ * This is key to creating `StateOperator`s that are typed based on their contextual usage and not on the arguments
+ * provided to them. This is critical for type safety and intellisense for State Operators.
+ * Here is an example of how this benefits a state operator:
+ * ```ts
+ * declare function append<T>(items: NoInfer<T[]>): StateOperator<T[]>;
+ * declare function appendBad<T>(items: T[]): StateOperator<T[]>;
+ *
+ * interface AAA {
+ *   foo?: boolean;
+ *   bar?: boolean;
+ * }
+ *
+ * // Works
+ * // (T in append is correctly inferred as AAA)
+ * patch<{ test: AAA[] }>({ test: append([{ foo: true }]) });
+ *
+ * // Incorrectly throws: Type 'AAA' is not assignable to type '{ foo: true; }'.ts(2322)
+ * // (T in appendBad is incorrectly inferred as { foo: true; })
+ * patch<{ test: AAA[] }>({ test: appendBad([{ foo: true }]) });
+ * ```
+ *
+ */
+type NoInfer<T> = T extends (infer O)[] ? _NoInfer<O>[] : _NoInfer<T>;
+/**
+ * IMPORTANT NOTE: This should not be used externally to the library, rather
+ * the exported type `ExistingState<T>` should be used instead.
+ *
+ * Used to convert a type to its readonly form. This can be given any type, from
+ * primitives to objects or arrays that could already be readonly or not.
+ * This does not apply the readonly construct to nested objects, but only to the top level type.
+ */
+type ɵAsReadonly<T> = T extends Readonly<infer O> ? (O extends T ? Readonly<T> : T) : T;
+/**
+ * Represents the existing state that is passed into a `StateOperator` which should
+ * not be modified but will be used to build the new state returned by the `StateOperator`.
+ */
+type ExistingState<T> = T extends any ? ɵAsReadonly<T> : never;
+/**
+ * This is a monotype unary function that is used to create a new state from an existing state.
+ * A state operator is usually created by a function that is given some data
+ * to integrate with the state and returns a state operator which integrates this data or instruction.
+ *
+ * In state management terminology this creator function is commonly referred to as a state operator
+ * because it represents the operation to be performed. ie. `patch`, `append`, `insertItem`, `compose`, `iif`, etc.
+ */
+type StateOperator<T> = (existing: ExistingState<T>) => T;
+
+/**
+ * @param items - Specific items to append to the end of an array
+ */
+declare function append<T>(items: NoInfer<T[]>): StateOperator<T[]>;
+
+declare function compose<T>(...operators: NoInfer<StateOperator<T>[]>): StateOperator<T>;
+
+type Predicate<T = any> = (value: T | Readonly<T>) => boolean;
+declare function isStateOperator<T>(value: T | StateOperator<T>): value is StateOperator<T>;
+declare function isPredicate<T>(value: Predicate<T> | boolean | number): value is Predicate<T>;
+
+/**
+ * @param condition - Condition can be a plain boolean value or a function,
+ * that returns boolean, also this function can take a value as an argument
+ * to which this state operator applies
+ * @param trueOperatorOrValue - Any value or a state operator
+ * @param elseOperatorOrValue - Any value or a state operator
+ */
+declare function iif<T>(condition: NoInfer<Predicate<T>> | boolean, trueOperatorOrValue: NoInfer<StateOperator<T> | T>, elseOperatorOrValue?: NoInfer<StateOperator<T> | T>): StateOperator<T>;
+
+/**
+ * @param value - Value to insert
+ * @param [beforePosition] -  Specified index to insert value before, optional
+ */
+declare function insertItem<T>(value: NoInfer<T>, beforePosition?: number): StateOperator<T[]>;
+
+type NotUndefined<T> = T extends undefined ? never : T;
+type ɵPatchSpec<T> = {
+    [P in keyof T]?: T[P] | StateOperator<NotUndefined<T[P]>>;
+};
+declare function patch<T extends Record<string, any>>(patchObject: NoInfer<ɵPatchSpec<T>>): StateOperator<T>;
+
+/**
+ * @param selector - Index of item in the array or a predicate function
+ * that can be provided in `Array.prototype.findIndex`
+ * @param operatorOrValue - New value under the `selector` index or a
+ * function that can be applied to an existing value
+ */
+declare function updateItem<T>(selector: number | NoInfer<Predicate<T>>, operatorOrValue: NoInfer<T> | NoInfer<StateOperator<T>>): StateOperator<T[]>;
+
+/**
+ * @param selector - index or predicate to remove an item from an array by
+ */
+declare function removeItem<T>(selector: number | NoInfer<Predicate<T>>): StateOperator<T[]>;
+
+export { type ExistingState, type NoInfer, type Predicate, type StateOperator, append, compose, iif, insertItem, isPredicate, isStateOperator, patch, removeItem, updateItem, type ɵPatchSpec };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngxs/store",
-  "version": "18.1.2-dev.master-cbc269d",
+  "version": "18.1.2-dev.master-eaf3f9d",
   "license": "MIT",
   "sideEffects": false,
   "peerDependencies": {

package/plugins/index.d.ts

@@ -1,3 +1,62 @@
-export { InitState, UpdateState } from './actions';
-export { NGXS_PLUGINS, NgxsPlugin, NgxsPluginFn, NgxsNextPluginFn } from './symbols';
-export { getActionTypeFromInstance, actionMatcher, setValue, getValue } from './utils';
+import { ɵPlainObject as _PlainObject } from '@ngxs/store/internals';
+import { InjectionToken } from '@angular/core';
+
+/**
+ * Init action
+ */
+declare class InitState {
+    static readonly type = "@@INIT";
+}
+/**
+ * Update action
+ */
+declare class UpdateState {
+    readonly addedStates?: _PlainObject | undefined;
+    static readonly type = "@@UPDATE_STATE";
+    constructor(addedStates?: _PlainObject | undefined);
+}
+
+declare const NGXS_PLUGINS: InjectionToken<unknown>;
+type NgxsPluginFn = (state: any, mutation: any, next: NgxsNextPluginFn) => any;
+type NgxsNextPluginFn = (state: any, mutation: any) => any;
+/**
+ * Plugin interface
+ */
+interface NgxsPlugin {
+    /**
+     * Handle the state/action before its submitted to the state handlers.
+     */
+    handle(state: any, action: any, next: NgxsNextPluginFn): any;
+}
+
+/**
+ * Returns the type from an action instance/class.
+ * @ignore
+ */
+declare function getActionTypeFromInstance(action: any): string | undefined;
+/**
+ * Matches a action
+ * @ignore
+ */
+declare function actionMatcher(action1: any): (action2: any) => boolean;
+/**
+ * Set a deeply nested value. Example:
+ *
+ *   setValue({ foo: { bar: { eat: false } } },
+ *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }
+ *
+ * While it traverses it also creates new objects from top down.
+ *
+ * @ignore
+ */
+declare const setValue: (obj: any, prop: string, val: any) => any;
+/**
+ * Get a deeply nested value. Example:
+ *
+ *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
+ *
+ * @ignore
+ */
+declare const getValue: (obj: any, prop: string) => any;
+
+export { InitState, NGXS_PLUGINS, type NgxsNextPluginFn, type NgxsPlugin, type NgxsPluginFn, UpdateState, actionMatcher, getActionTypeFromInstance, getValue, setValue };

package/experimental/pending-tasks.d.ts

@@ -1,8 +0,0 @@
-/**
- * This is an experimental feature that contributes to app stability,
- * which is required during server-side rendering. With asynchronous
- * actions being dispatched and handled, Angular is unaware of them in
- * zoneless mode and doesn't know whether the app is still unstable.
- * This may prematurely serialize the final HTML that is sent to the client.
- */
-export declare function withExperimentalNgxsPendingTasks(): import("@angular/core").EnvironmentProviders;

package/internals/custom-rxjs-operators.d.ts

@@ -1,2 +0,0 @@
-import { MonoTypeOperatorFunction } from 'rxjs';
-export declare function ɵwrapObserverCalls<TValue>(invokeFn: (fn: () => void) => void): MonoTypeOperatorFunction<TValue>;

package/internals/custom-rxjs-subjects.d.ts

@@ -1,42 +0,0 @@
-import { BehaviorSubject, Subject } from 'rxjs';
-/**
- * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard Subject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new Subject<string>();
-     subject.subscribe(value => {
-       if (value === 'start') subject.next('end');
-     });
-     subject.subscribe(value => { });
-     subject.next('start');
- * ```
- * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- */
-export declare class ɵOrderedSubject<T> extends Subject<T> {
-    private _orderedNext;
-    next(value?: T): void;
-}
-/**
- * Custom BehaviorSubject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard BehaviorSubject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new BehaviorSubject<string>();
-     subject.subscribe(value => {
-       if (value === 'start') subject.next('end');
-     });
-     subject.subscribe(value => { });
-     subject.next('start');
- * ```
- * When `subject` is a standard `BehaviorSubject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedBehaviorSubject<T>` the second subscriber would recieve `start` and then `end`.
- */
-export declare class ɵOrderedBehaviorSubject<T> extends BehaviorSubject<T> {
-    private _orderedNext;
-    private _currentValue;
-    constructor(value: T);
-    getValue(): T;
-    next(value: T): void;
-}

package/internals/initial-state.d.ts

@@ -1,8 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { ɵPlainObject } from './symbols';
-export declare class ɵInitialState {
-    private static _value;
-    static set(state: ɵPlainObject): void;
-    static pop(): ɵPlainObject;
-}
-export declare const ɵINITIAL_STATE_TOKEN: InjectionToken<ɵPlainObject>;

package/internals/internal-tokens.d.ts

@@ -1,3 +0,0 @@
-import { InjectionToken } from '@angular/core';
-export declare const ɵNGXS_STATE_FACTORY: InjectionToken<any>;
-export declare const ɵNGXS_STATE_CONTEXT_FACTORY: InjectionToken<any>;

package/internals/memoize.d.ts

@@ -1,9 +0,0 @@
-declare function defaultEqualityCheck(a: any, b: any): boolean;
-/**
- * Memoize a function on its last inputs only.
- * Originally from: https://github.com/reduxjs/reselect/blob/master/src/index.js
- *
- * @ignore
- */
-export declare function ɵmemoize<T extends (...args: any[]) => any>(func: T, equalityCheck?: typeof defaultEqualityCheck): T;
-export {};

package/internals/metadata.d.ts

@@ -1,25 +0,0 @@
-import { ɵMetaDataModel, ɵStateClassInternal, ɵSelectorMetaDataModel } from './symbols';
-/**
- * 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;

package/internals/ngxs-app-bootstrapped-state.d.ts

@@ -1,8 +0,0 @@
-import { ReplaySubject } from 'rxjs';
-import * as i0 from "@angular/core";
-export declare class ɵNgxsAppBootstrappedState extends ReplaySubject<boolean> {
-    constructor();
-    bootstrap(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ɵNgxsAppBootstrappedState, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ɵNgxsAppBootstrappedState>;
-}

package/internals/state-stream.d.ts

@@ -1,15 +0,0 @@
-import { OnDestroy, Signal } from '@angular/core';
-import { ɵOrderedBehaviorSubject } from './custom-rxjs-subjects';
-import { ɵPlainObject } from './symbols';
-import * as i0 from "@angular/core";
-/**
- * BehaviorSubject of the entire state.
- * @ignore
- */
-export declare class ɵStateStream extends ɵOrderedBehaviorSubject<ɵPlainObject> implements OnDestroy {
-    readonly state: Signal<ɵPlainObject>;
-    constructor();
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ɵStateStream, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ɵStateStream>;
-}

package/internals/state-token.d.ts

@@ -1,7 +0,0 @@
-import type { ɵTokenName } from './symbols';
-export declare class StateToken<T = void> {
-    private readonly _name;
-    constructor(_name: ɵTokenName<T>);
-    getName(): string;
-    toString(): string;
-}