@angular-architects/ngrx-toolkit 19.2.0 → 20.0.0

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@angular-architects/ngrx-toolkit",
-  "version": "19.2.0",
+  "version": "20.0.0",
   "license": "MIT",
   "repository": {
     "type": "GitHub",
     "url": "https://github.com/angular-architects/ngrx-toolkit"
   },
   "peerDependencies": {
-    "@angular/core": "^19.0.0",
-    "@angular/common": "^19.0.0",
-    "@ngrx/signals": "19.2.1",
-    "@ngrx/store": "^19.2.1",
+    "@angular/core": "^20.0.0",
+    "@angular/common": "^20.0.0",
+    "@ngrx/signals": "^20.0.0",
+    "@ngrx/store": "^20.0.0",
     "rxjs": "^7.0.0"
   },
   "peerDependenciesMeta": {

package/redux-connector/index.d.ts

@@ -1,2 +1,59 @@
-export { createReduxState, mapAction, withActionMappers, } from './src/lib/create-redux';
-export { reduxMethod } from './src/lib/rxjs-interop/redux-method';
+import { ActionCreator, ActionType, Prettify, Action } from '@ngrx/store/src/models';
+import { Type, EnvironmentProviders, Signal, Injector } from '@angular/core';
+import { DeepSignal } from '@ngrx/signals/src/deep-signal';
+import { StateSignals, SignalStoreFeatureResult } from '@ngrx/signals/src/signal-store-models';
+import { Observable, Unsubscribable } from 'rxjs';
+
+type IncludePropType<T, V, WithNevers = {
+    [K in keyof T]: Exclude<T[K], undefined> extends V ? T[K] extends Record<string, unknown> ? IncludePropType<T[K], V> : T[K] : never;
+}> = Prettify<Pick<WithNevers, {
+    [K in keyof WithNevers]: WithNevers[K] extends never ? never : K extends string ? K : never;
+}[keyof WithNevers]>>;
+type Store = Type<Record<string, unknown> & StateSignals<SignalStoreFeatureResult['state']>>;
+type CreateReduxState<StoreName extends string, STORE extends Store> = {
+    [K in StoreName as `provide${Capitalize<K>}Store`]: (connectReduxDevtools?: boolean) => EnvironmentProviders;
+} & {
+    [K in StoreName as `inject${Capitalize<K>}Store`]: () => InjectableReduxSlice<STORE>;
+};
+type Selectors<STORE extends Store> = IncludePropType<InstanceType<STORE>, Signal<unknown> | DeepSignal<unknown>>;
+type Dispatch = {
+    dispatch: (input: Action | Observable<Action> | Signal<Action>) => Unsubscribable;
+};
+type InjectableReduxSlice<STORE extends Store> = Selectors<STORE> & Dispatch;
+type ExtractActionTypes<Creators extends readonly ActionCreator[]> = {
+    [Key in keyof Creators]: Creators[Key] extends ActionCreator<infer T> ? T : never;
+};
+interface StoreMethod<Creators extends readonly ActionCreator[], ResultState = unknown> {
+    (action: ActionType<Creators[number]>): ResultState;
+}
+interface MapperTypes<Creators extends readonly ActionCreator[]> {
+    types: ExtractActionTypes<Creators>;
+    storeMethod: StoreMethod<Creators>;
+    resultMethod?: (...args: unknown[]) => unknown;
+}
+
+declare function mapAction<Creators extends readonly ActionCreator[]>(...args: [
+    ...creators: Creators,
+    storeMethod: (action: ActionType<Creators[number]>) => unknown
+]): MapperTypes<Creators>;
+declare function mapAction<Creators extends readonly ActionCreator[], T>(...args: [
+    ...creators: Creators,
+    storeMethod: (action: ActionType<Creators[number]>, resultMethod: (input: T) => unknown) => unknown,
+    resultMethod: (input: T) => unknown
+]): MapperTypes<Creators>;
+declare function withActionMappers(...mappers: MapperTypes<ActionCreator[]>[]): MapperTypes<ActionCreator[]>[];
+declare function createReduxState<StoreName extends string, STORE extends Store>(storeName: StoreName, signalStore: STORE, withActionMappers: (store: InstanceType<STORE>) => MapperTypes<ActionCreator[]>[]): CreateReduxState<StoreName, STORE>;
+
+type RxMethodInput<Input> = Input | Observable<Input> | Signal<Input>;
+type RxMethodRef = {
+    destroy: () => void;
+};
+type RxMethod<Input, MethodInput = Input, MethodResult = unknown> = ((input: RxMethodInput<Input>, resultMethod: (input: MethodInput) => MethodResult) => RxMethodRef) & RxMethodRef;
+declare function reduxMethod<Input, MethodInput = Input>(generator: (source$: Observable<Input>) => Observable<MethodInput>, config?: {
+    injector?: Injector;
+}): RxMethod<Input, MethodInput>;
+declare function reduxMethod<Input, MethodInput = Input, MethodResult = unknown>(generator: (source$: Observable<Input>) => Observable<MethodInput>, resultMethod: (input: MethodInput) => MethodResult, config?: {
+    injector?: Injector;
+}): RxMethod<Input, MethodInput, MethodResult>;
+
+export { createReduxState, mapAction, reduxMethod, withActionMappers };

package/lib/assertions/assertions.d.ts

@@ -1,2 +0,0 @@
-import { ActionsFnSpecs } from '../with-redux';
-export declare function assertActionFnSpecs(obj: unknown): asserts obj is ActionsFnSpecs;

package/lib/devtools/features/with-disabled-name-indicies.d.ts

@@ -1,27 +0,0 @@
-/**
- * If multiple instances of the same SignalStore class
- * exist, their devtool names are indexed.
- *
- * For example:
- *
- * ```typescript
- * const Store = signalStore(
- *   withDevtools('flights')
- * )
- *
- * const store1 = new Store(); // will show up as 'flights'
- * const store2 = new Store(); // will show up as 'flights-1'
- * ```
- *
- * With adding `withDisabledNameIndices` to the store:
- * ```typescript
- * const Store = signalStore(
- *   withDevtools('flights', withDisabledNameIndices())
- * )
- *
- * const store1 = new Store(); // will show up as 'flights'
- * const store2 = new Store(); //💥 throws an error
- * ```
- *
- */
-export declare function withDisabledNameIndices(): import("../internal/devtools-feature").DevtoolsFeature;

package/lib/devtools/features/with-glitch-tracking.d.ts

@@ -1,30 +0,0 @@
-/**
- * It tracks all state changes of the State, including intermediary updates
- * that are typically suppressed by Angular's glitch-free mechanism.
- *
- * This feature is especially useful for debugging.
- *
- * Example:
- *
- * ```typescript
- * const Store = signalStore(
- *   { providedIn: 'root' },
- *   withState({ count: 0 }),
- *   withDevtools('counter', withGlitchTracking()),
- *   withMethods((store) => ({
- *     increase: () =>
- *       patchState(store, (value) => ({ count: value.count + 1 })),
- *   }))
- * );
- *
- * // would show up in the DevTools with value 0
- * const store = inject(Store);
- *
- * store.increase(); // would show up in the DevTools with value 1
- * store.increase(); // would show up in the DevTools with value 2
- * store.increase(); // would show up in the DevTools with value 3
- * ```
- *
- * Without `withGlitchTracking`, the DevTools would only show the final value of 3.
- */
-export declare function withGlitchTracking(): import("../internal/devtools-feature").DevtoolsFeature;

package/lib/devtools/features/with-mapper.d.ts

@@ -1,28 +0,0 @@
-/**
- * Allows you to define a function to map the state.
- *
- * It is needed for huge states, that slows down the Devtools and where
- * you don't need to see the whole state or other reasons.
- *
- * Example:
- *
- * ```typescript
- * const initialState = {
- *   id: 1,
- *   email: 'john.list@host.com',
- *   name: 'John List',
- *   enteredPassword: ''
- * }
- *
- * const Store = signalStore(
- *   withState(initialState),
- *   withDevtools(
- *     'user',
- *     withMapper(state => ({...state, enteredPassword: '***' }))
- *   )
- * )
- * ```
- *
- * @param map function which maps the state
- */
-export declare function withMapper<State extends object>(map: (state: State) => Record<string, unknown>): import("../internal/devtools-feature").DevtoolsFeature;

package/lib/devtools/internal/current-action-names.d.ts

@@ -1 +0,0 @@
-export declare const currentActionNames: Set<string>;

package/lib/devtools/internal/default-tracker.d.ts

@@ -1,13 +0,0 @@
-import { StateSource } from '@ngrx/signals';
-import { Tracker, TrackerStores } from './models';
-import * as i0 from "@angular/core";
-export declare class DefaultTracker implements Tracker {
-    #private;
-    get stores(): TrackerStores;
-    track(id: string, store: StateSource<object>): void;
-    onChange(callback: (changedState: Record<string, object>) => void): void;
-    removeStore(id: string): void;
-    notifyRenamedStore(id: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultTracker, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultTracker>;
-}

package/lib/devtools/internal/devtools-feature.d.ts

@@ -1,24 +0,0 @@
-import { Tracker } from './models';
-export declare const DEVTOOLS_FEATURE: unique symbol;
-export type Mapper = (state: object) => object;
-export type DevtoolsOptions = {
-    indexNames?: boolean;
-    map?: Mapper;
-    tracker?: new () => Tracker;
-};
-export type DevtoolsInnerOptions = {
-    indexNames: boolean;
-    map: Mapper;
-    tracker: Tracker;
-};
-/**
- * A DevtoolsFeature adds or modifies the behavior of the
- * devtools extension.
- *
- * We use them (function calls) instead of a config object,
- * because of tree-shaking.
- */
-export type DevtoolsFeature = {
-    [DEVTOOLS_FEATURE]: true;
-} & Partial<DevtoolsOptions>;
-export declare function createDevtoolsFeature(options: DevtoolsOptions): DevtoolsFeature;

package/lib/devtools/internal/devtools-syncer.service.d.ts

@@ -1,35 +0,0 @@
-import { OnDestroy } from '@angular/core';
-import { StateSource } from '@ngrx/signals';
-import { DevtoolsInnerOptions } from './devtools-feature';
-import * as i0 from "@angular/core";
-/**
- * A service provided by the root injector is
- * required because the synchronization runs
- * globally.
- *
- * The SignalStore could be provided in a component.
- * If the effect starts in the injection
- * context of the SignalStore, the complete sync
- * process would shut down once the component gets
- * destroyed.
- */
-export declare class DevtoolsSyncer implements OnDestroy {
-    #private;
-    constructor();
-    ngOnDestroy(): void;
-    syncToDevTools(changedStatePerId: Record<string, object>): void;
-    getNextId(): string;
-    /**
-     * Consumer provides the id. That is because we can only start
-     * tracking the store in the init hook.
-     * Unfortunately, methods for renaming having the final id
-     * need to be defined already before.
-     * That's why `withDevtools` requests first the id and
-     * then registers itself later.
-     */
-    addStore(id: string, name: string, store: StateSource<object>, options: DevtoolsInnerOptions): void;
-    removeStore(id: string): void;
-    renameStore(oldName: string, newName: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DevtoolsSyncer, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DevtoolsSyncer>;
-}

package/lib/devtools/internal/glitch-tracker.service.d.ts

@@ -1,18 +0,0 @@
-import { StateSource } from '@ngrx/signals';
-import { Tracker, TrackerStores } from './models';
-import * as i0 from "@angular/core";
-/**
- * Internal Service used by {@link withGlitchTracking}. It does not rely
- * on `effect` as {@link DefaultTracker} does but uses the NgRx function
- * `watchState` to track all state changes.
- */
-export declare class GlitchTrackerService implements Tracker {
-    #private;
-    get stores(): TrackerStores;
-    onChange(callback: (changedState: Record<string, object>) => void): void;
-    removeStore(id: string): void;
-    track(id: string, store: StateSource<object>): void;
-    notifyRenamedStore(id: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GlitchTrackerService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<GlitchTrackerService>;
-}

package/lib/devtools/internal/models.d.ts

@@ -1,24 +0,0 @@
-import { StateSource } from '@ngrx/signals';
-import { ReduxDevtoolsConfig } from '../provide-devtools-config';
-import { DevtoolsInnerOptions } from './devtools-feature';
-export type Action = {
-    type: string;
-};
-export type Connection = {
-    send: (action: Action, state: Record<string, unknown>) => void;
-};
-export type ReduxDevtoolsExtension = {
-    connect: (options: ReduxDevtoolsConfig) => Connection;
-};
-export type StoreRegistry = Record<string, {
-    options: DevtoolsInnerOptions;
-    name: string;
-}>;
-export type Tracker = {
-    track(id: string, store: StateSource<object>): void;
-    onChange(callback: (changedState: Record<string, object>) => void): void;
-    notifyRenamedStore(id: string): void;
-    removeStore(id: string): void;
-    get stores(): TrackerStores;
-};
-export type TrackerStores = Record<string, StateSource<object>>;

package/lib/devtools/provide-devtools-config.d.ts

@@ -1,20 +0,0 @@
-import { InjectionToken, ValueProvider } from '@angular/core';
-/**
- * Provides the configuration options for connecting to the Redux DevTools Extension.
- */
-export declare function provideDevtoolsConfig(config: ReduxDevtoolsConfig): ValueProvider;
-/**
- * Injection token for the configuration options for connecting to the Redux DevTools Extension.
- */
-export declare const REDUX_DEVTOOLS_CONFIG: InjectionToken<ReduxDevtoolsConfig>;
-/**
- * Options for connecting to the Redux DevTools Extension.
- * @example
- * const devToolsOptions: ReduxDevtoolsConfig = {
- *   name: 'My App',
- * };
- */
-export type ReduxDevtoolsConfig = {
-    /** Optional name for the devtools instance. If empty, "NgRx SignalStore" will be used. */
-    name?: string;
-};

package/lib/devtools/rename-devtools-name.d.ts

@@ -1,7 +0,0 @@
-import { StateSource } from '@ngrx/signals';
-/**
- * Renames the name of a store how it appears in the Devtools.
- * @param store instance of the SignalStore
- * @param newName new name for the Devtools
- */
-export declare function renameDevtoolsName<State extends object>(store: StateSource<State>, newName: string): void;

package/lib/devtools/update-state.d.ts

@@ -1,16 +0,0 @@
-import { patchState as originalPatchState, PartialStateUpdater, WritableStateSource } from '@ngrx/signals';
-import { Prettify } from '../shared/prettify';
-type PatchFn = typeof originalPatchState extends (arg1: infer First, ...args: infer Rest) => infer Returner ? (state: First, action: string, ...rest: Rest) => Returner : never;
-/**
- * @deprecated Has been renamed to `updateState`
- */
-export declare const patchState: PatchFn;
-/**
- * Wrapper of `patchState` for DevTools integration. Next to updating the state,
- * it also sends the action to the DevTools.
- * @param stateSource state of Signal Store
- * @param action name of action how it will show in DevTools
- * @param updaters updater functions or objects
- */
-export declare function updateState<State extends object>(stateSource: WritableStateSource<State>, action: string, ...updaters: Array<Partial<Prettify<State>> | PartialStateUpdater<Prettify<State>>>): void;
-export {};

package/lib/devtools/with-dev-tools-stub.d.ts

@@ -1,5 +0,0 @@
-import { withDevtools } from './with-devtools';
-/**
- * Stub for DevTools integration. Can be used to disable DevTools in production.
- */
-export declare const withDevToolsStub: typeof withDevtools;

package/lib/devtools/with-devtools.d.ts

@@ -1,24 +0,0 @@
-import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
-import { DevtoolsFeature } from './internal/devtools-feature';
-import { ReduxDevtoolsExtension } from './internal/models';
-declare global {
-    interface Window {
-        __REDUX_DEVTOOLS_EXTENSION__: ReduxDevtoolsExtension | undefined;
-    }
-}
-export declare const renameDevtoolsMethodName = "___renameDevtoolsName";
-export declare const uniqueDevtoolsId = "___uniqueDevtoolsId";
-/**
- * Adds this store as a feature state to the Redux DevTools.
- *
- * By default, the action name is 'Store Update'. You can
- * change that via the {@link updateState} method, which has as second
- * parameter the action name.
- *
- * The standalone function {@link renameDevtoolsName} can rename
- * the store name.
- *
- * @param name name of the store as it should appear in the DevTools
- * @param features features to extend or modify the behavior of the Devtools
- */
-export declare function withDevtools(name: string, ...features: DevtoolsFeature[]): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult>;

package/lib/immutable-state/deep-freeze.d.ts

@@ -1,11 +0,0 @@
-/**
- * Deep freezes a state object along its properties with primitive values
- * on the first level.
- *
- * The reason for this is that the final state is a merge of all
- * root properties of all states, i.e. `withState`,....
- *
- * Since the root object will not be part of the state (shadow clone),
- * we are not freezing it.
- */
-export declare function deepFreeze<T extends Record<string | symbol, unknown>>(target: T, propertyNamesToBeFrozen: (string | symbol)[], isRoot?: boolean): void;

package/lib/immutable-state/is-dev-mode.d.ts

@@ -1 +0,0 @@
-export declare function isDevMode(): boolean;

package/lib/immutable-state/with-immutable-state.d.ts

@@ -1,60 +0,0 @@
-import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult } from '@ngrx/signals';
-/**
- * The implementation of this feature is a little bit tricky.
- *
- * `signalStore` does a shallow clone in the initial phase, in order to
- * merge all different states together.
- *
- * Shallow cloning also happens in `patchState`.
- *
- * With shallow cloning, the root state object is replaced, which means,
- * the freezing only stays for its nested properties but not for
- * the primitive and immediate properties.
- *
- * For example:
- *
- * ```ts
- * const state = {
- *   id: 1,
- *   address: {
- *     street: 'Main St',
- *     city: 'Springfield',
- *   }
- * }
- * ```
- *
- * Running `Object.freeze` on `state` will freeze the `address` object, and
- * the `id`. But since `state` is shallow cloned, the "frozing" state of the
- * `id` is lost. `address`, being an object, is still frozen.
- *
- * To overcome that, we run `watchState` and run `deepFreeze`
- * on every change.
- */
-/**
- * Prevents mutation of the state.
- *
- * This is done by deeply applying `Object.freeze`. Any mutable change within
- * or outside the `SignalStore` will throw an error.
- *
- * @param state the state object
- * @param options enable protection in production (default: false)
- */
-export declare function withImmutableState<State extends object>(state: State, options?: {
-    enableInProduction?: boolean;
-}): SignalStoreFeature<SignalStoreFeatureResult, EmptyFeatureResult & {
-    state: State;
-}>;
-/**
- * Prevents mutation of the state.
- *
- * This is done by deeply applying `Object.freeze`. Any mutable change within
- * or outside the `SignalStore` will throw an error.
- *
- * @param stateFactory a function returning the state object
- * @param options enable protection in production (default: false)
- */
-export declare function withImmutableState<State extends object>(stateFactory: () => State, options?: {
-    enableInProduction?: boolean;
-}): SignalStoreFeature<SignalStoreFeatureResult, EmptyFeatureResult & {
-    state: State;
-}>;

package/lib/shared/prettify.d.ts

@@ -1,3 +0,0 @@
-export type Prettify<Type extends object> = {
-    [Key in keyof Type]: Type[Key];
-};

package/lib/shared/signal-store-models.d.ts

@@ -1,26 +0,0 @@
-/**
- * This file contains copies of types of the Signal Store which are not public.
- *
- * Since certain features depend on them, if we don't want to break
- * the encapsulation of @ngrx/signals, we decided to copy them.
- *
- * Since TypeScript is based on structural typing, we can get away with it.
- *
- * If @ngrx/signals changes its internal types, we catch them via integration
- * tests.
- *
- * Because of the "tight coupling", the toolkit doesn't have version range
- * to @ngrx/signal, but is very precise.
- */
-import { Signal } from '@angular/core';
-import { EntityId } from '@ngrx/signals/entities';
-export type EntityState<Entity> = {
-    entityMap: Record<EntityId, Entity>;
-    ids: EntityId[];
-};
-export type EntityComputed<Entity> = {
-    entities: Signal<Entity[]>;
-};
-export type NamedEntityComputed<Entity, Collection extends string> = {
-    [K in keyof EntityComputed<Entity> as `${Collection}${Capitalize<K>}`]: EntityComputed<Entity>[K];
-};

package/lib/shared/throw-if-null.d.ts

@@ -1 +0,0 @@
-export declare function throwIfNull<T>(obj: T): NonNullable<T>;

package/lib/storage-sync/features/with-indexed-db.d.ts

@@ -1,2 +0,0 @@
-import { AsyncStorageStrategy } from '../internal/models';
-export declare function withIndexedDB<State extends object>(): AsyncStorageStrategy<State>;

package/lib/storage-sync/features/with-local-storage.d.ts

@@ -1,3 +0,0 @@
-import { SyncStorageStrategy } from '../internal/models';
-export declare function withLocalStorage<State extends object>(): SyncStorageStrategy<State>;
-export declare function withSessionStorage<State extends object>(): SyncStorageStrategy<State>;

package/lib/storage-sync/internal/indexeddb.service.d.ts

@@ -1,29 +0,0 @@
-import * as i0 from "@angular/core";
-export declare const keyPath = "ngrxToolkitKeyPath";
-export declare const dbName = "ngrxToolkitDb";
-export declare const storeName = "ngrxToolkitStore";
-export declare const VERSION: number;
-export declare class IndexedDBService {
-    /**
-     * write to indexedDB
-     * @param key
-     * @param data
-     */
-    setItem(key: string, data: string): Promise<void>;
-    /**
-     * read from indexedDB
-     * @param key
-     */
-    getItem(key: string): Promise<string | null>;
-    /**
-     * delete indexedDB
-     * @param key
-     */
-    clear(key: string): Promise<void>;
-    /**
-     * open indexedDB
-     */
-    private openDB;
-    static ɵfac: i0.ɵɵFactoryDeclaration<IndexedDBService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<IndexedDBService>;
-}

package/lib/storage-sync/internal/local-storage.service.d.ts

@@ -1,8 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class LocalStorageService {
-    getItem(key: string): string | null;
-    setItem(key: string, data: string): void;
-    clear(key: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageService>;
-}

package/lib/storage-sync/internal/models.d.ts

@@ -1,34 +0,0 @@
-import { Signal, WritableSignal } from '@angular/core';
-import { EmptyFeatureResult, WritableStateSource } from '@ngrx/signals';
-import { SyncConfig } from '../with-storage-sync';
-export type SyncMethods = {
-    clearStorage(): void;
-    readFromStorage(): void;
-    writeToStorage(): void;
-};
-export type SyncFeatureResult = EmptyFeatureResult & {
-    methods: SyncMethods;
-};
-export type SyncStoreForFactory<State extends object> = WritableStateSource<State>;
-export type SyncStorageStrategy<State extends object> = ((config: Required<SyncConfig<State>>, store: SyncStoreForFactory<State>, useStubs: boolean) => SyncMethods) & {
-    type: 'sync';
-};
-export type AsyncMethods = {
-    clearStorage(): Promise<void>;
-    readFromStorage(): Promise<void>;
-    writeToStorage(): Promise<void>;
-};
-export declare const SYNC_STATUS: unique symbol;
-export type SyncStatus = 'idle' | 'syncing' | 'synced';
-export type AsyncFeatureResult = EmptyFeatureResult & {
-    methods: AsyncMethods;
-    props: {
-        isSynced: Signal<boolean>;
-        whenSynced: () => Promise<void>;
-        [SYNC_STATUS]: WritableSignal<SyncStatus>;
-    };
-};
-export type AsyncStoreForFactory<State extends object> = WritableStateSource<State> & AsyncFeatureResult['props'];
-export type AsyncStorageStrategy<State extends object> = ((config: Required<SyncConfig<State>>, store: AsyncStoreForFactory<State>, useStubs: boolean) => AsyncMethods) & {
-    type: 'async';
-};

package/lib/storage-sync/internal/session-storage.service.d.ts

@@ -1,8 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class SessionStorageService {
-    getItem(key: string): string | null;
-    setItem(key: string, data: string): void;
-    clear(key: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SessionStorageService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SessionStorageService>;
-}

package/lib/storage-sync/with-storage-sync.d.ts

@@ -1,45 +0,0 @@
-import { SignalStoreFeature, SignalStoreFeatureResult } from '@ngrx/signals';
-import { AsyncFeatureResult, AsyncStorageStrategy, SyncFeatureResult, SyncStorageStrategy } from './internal/models';
-export type SyncConfig<State> = {
-    /**
-     * The key which is used to access the storage.
-     */
-    key: string;
-    /**
-     * Flag indicating if the store should read from storage on init and write to storage on every state change.
-     *
-     * `true` by default
-     */
-    autoSync?: boolean;
-    /**
-     * Function to select that portion of the state which should be stored.
-     *
-     * Returns the whole state object by default
-     */
-    select?: (state: State) => unknown;
-    /**
-     * Function used to parse the state coming from storage.
-     *
-     * `JSON.parse()` by default
-     */
-    parse?: (stateString: string) => State;
-    /**
-     * Function used to transform the state into a string representation.
-     *
-     * `JSON.stringify()` by default
-     */
-    stringify?: (state: State) => string;
-    /**
-     * @deprecated Use {@link withSessionStorage} instead.
-     * Factory function used to switch to sessionStorage.
-     *
-     * `localStorage` by default
-     */
-    storage?: () => Storage;
-};
-export declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string): SignalStoreFeature<Input, SyncFeatureResult>;
-export declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string, storageStrategy: AsyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, AsyncFeatureResult>;
-export declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string, storageStrategy: SyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;
-export declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;
-export declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>, storageStrategy: AsyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, AsyncFeatureResult>;
-export declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>, storageStrategy: SyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;