@angular-architects/ngrx-toolkit 19.2.3 → 19.4.0

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,45 +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>;
-};
-/**
- * AsyncFeatureResult is used as the public interface that users interact with
- * when calling `withIndexedDB`. It intentionally omits the internal SYNC_STATUS
- * property to avoid TypeScript error TS4058 (return type of public method
- * includes private type).
- *
- * For internal implementation, we use AsyncStoreForFactory which includes
- * the SYNC_STATUS property needed for state management.
- */
-export declare const SYNC_STATUS: unique symbol;
-export type SyncStatus = 'idle' | 'syncing' | 'synced';
-export type InternalAsyncProps = AsyncFeatureResult['props'] & {
-    [SYNC_STATUS]: WritableSignal<SyncStatus>;
-};
-export type AsyncFeatureResult = EmptyFeatureResult & {
-    methods: AsyncMethods;
-    props: {
-        isSynced: Signal<boolean>;
-        whenSynced: () => Promise<void>;
-    };
-};
-export type AsyncStoreForFactory<State extends object> = WritableStateSource<State> & InternalAsyncProps;
-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>;

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

@@ -1,58 +0,0 @@
-import { Signal } from '@angular/core';
-import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
-export type CallState = 'init' | 'loading' | 'loaded' | {
-    error: string;
-};
-export type CallStateSlice = {
-    callState: CallState;
-};
-export type NamedCallStateSlice<Collection extends string> = {
-    [K in keyof CallStateSlice as Collection extends '' ? `${Collection}${K}` : `${Collection}${Capitalize<K>}`]: CallStateSlice[K];
-};
-export type CallStateSignals = {
-    loading: Signal<boolean>;
-    loaded: Signal<boolean>;
-    error: Signal<string | null>;
-};
-export type NamedCallStateSignals<Prop extends string> = {
-    [K in keyof CallStateSignals as Prop extends '' ? `${Prop}${K}` : `${Prop}${Capitalize<K>}`]: CallStateSignals[K];
-};
-export type SetCallState<Prop extends string | undefined> = Prop extends string ? NamedCallStateSlice<Prop> : CallStateSlice;
-export declare function deriveCallStateKeys<Collection extends string>(collection?: Collection): {
-    callStateKey: string;
-    loadingKey: string;
-    loadedKey: string;
-    errorKey: string;
-};
-export declare function getCallStateKeys(config?: {
-    collection?: string;
-}): {
-    callStateKey: string;
-    loadingKey: string;
-    loadedKey: string;
-    errorKey: string;
-};
-export declare function getCollectionArray(config: {
-    collection?: string;
-} | {
-    collections?: string[];
-}): string[] | undefined;
-export declare function withCallState<Collection extends string>(config: {
-    collections: Collection[];
-}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
-    state: NamedCallStateSlice<Collection>;
-    props: NamedCallStateSignals<Collection>;
-}>;
-export declare function withCallState<Collection extends string>(config: {
-    collection: Collection;
-}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
-    state: NamedCallStateSlice<Collection>;
-    props: NamedCallStateSignals<Collection>;
-}>;
-export declare function withCallState(): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
-    state: CallStateSlice;
-    props: CallStateSignals;
-}>;
-export declare function setLoading<Prop extends string | undefined = undefined>(prop?: Prop): SetCallState<Prop>;
-export declare function setLoaded<Prop extends string | undefined = undefined>(prop?: Prop): SetCallState<Prop>;
-export declare function setError<Prop extends string | undefined = undefined>(error: unknown, prop?: Prop): SetCallState<Prop>;

package/lib/with-data-service.d.ts

@@ -1,109 +0,0 @@
-import { ProviderToken, Signal } from '@angular/core';
-import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
-import { EntityId, NamedEntityState } from '@ngrx/signals/entities';
-import { EntityState } from './shared/signal-store-models';
-import { CallState, NamedCallStateSlice } from './with-call-state';
-export type Filter = Record<string, unknown>;
-export type Entity = {
-    id: EntityId;
-};
-export interface DataService<E extends Entity, F extends Filter> {
-    load(filter: F): Promise<E[]>;
-    loadById(id: EntityId): Promise<E>;
-    create(entity: E): Promise<E>;
-    update(entity: E): Promise<E>;
-    updateAll(entity: E[]): Promise<E[]>;
-    delete(entity: E): Promise<void>;
-}
-export declare function capitalize(str: string): string;
-export declare function getDataServiceKeys(options: {
-    collection?: string;
-}): {
-    filterKey: string;
-    selectedIdsKey: string;
-    selectedEntitiesKey: string;
-    updateFilterKey: string;
-    updateSelectedKey: string;
-    loadKey: string;
-    entitiesKey: string;
-    entityMapKey: string;
-    idsKey: string;
-    currentKey: string;
-    loadByIdKey: string;
-    setCurrentKey: string;
-    createKey: string;
-    updateKey: string;
-    updateAllKey: string;
-    deleteKey: string;
-};
-export type NamedDataServiceState<E extends Entity, F extends Filter, Collection extends string> = {
-    [K in Collection as `${K}Filter`]: F;
-} & {
-    [K in Collection as `selected${Capitalize<K>}Ids`]: Record<EntityId, boolean>;
-} & {
-    [K in Collection as `current${Capitalize<K>}`]: E;
-};
-export type DataServiceState<E extends Entity, F extends Filter> = {
-    filter: F;
-    selectedIds: Record<EntityId, boolean>;
-    current: E;
-};
-export type DataServiceComputed<E extends Entity> = {
-    selectedEntities: Signal<E[]>;
-};
-export type NamedDataServiceComputed<E extends Entity, Collection extends string> = {
-    [K in Collection as `selected${Capitalize<K>}Entities`]: Signal<E[]>;
-};
-export type NamedDataServiceMethods<E extends Entity, F extends Filter, Collection extends string> = {
-    [K in Collection as `update${Capitalize<K>}Filter`]: (filter: F) => void;
-} & {
-    [K in Collection as `updateSelected${Capitalize<K>}Entities`]: (id: EntityId, selected: boolean) => void;
-} & {
-    [K in Collection as `load${Capitalize<K>}Entities`]: () => Promise<void>;
-} & {
-    [K in Collection as `setCurrent${Capitalize<K>}`]: (entity: E) => void;
-} & {
-    [K in Collection as `load${Capitalize<K>}ById`]: (id: EntityId) => Promise<void>;
-} & {
-    [K in Collection as `create${Capitalize<K>}`]: (entity: E) => Promise<void>;
-} & {
-    [K in Collection as `update${Capitalize<K>}`]: (entity: E) => Promise<void>;
-} & {
-    [K in Collection as `updateAll${Capitalize<K>}`]: (entity: E[]) => Promise<void>;
-} & {
-    [K in Collection as `delete${Capitalize<K>}`]: (entity: E) => Promise<void>;
-};
-export type DataServiceMethods<E extends Entity, F extends Filter> = {
-    updateFilter: (filter: F) => void;
-    updateSelected: (id: EntityId, selected: boolean) => void;
-    load: () => Promise<void>;
-    setCurrent(entity: E): void;
-    loadById(id: EntityId): Promise<void>;
-    create(entity: E): Promise<void>;
-    update(entity: E): Promise<void>;
-    updateAll(entities: E[]): Promise<void>;
-    delete(entity: E): Promise<void>;
-};
-export declare function withDataService<E extends Entity, F extends Filter, Collection extends string>(options: {
-    dataServiceType: ProviderToken<DataService<E, F>>;
-    filter: F;
-    collection: Collection;
-}): SignalStoreFeature<EmptyFeatureResult & {
-    state: NamedCallStateSlice<Collection> & NamedEntityState<E, Collection>;
-}, {
-    state: NamedDataServiceState<E, F, Collection>;
-    props: NamedDataServiceComputed<E, Collection>;
-    methods: NamedDataServiceMethods<E, F, Collection>;
-}>;
-export declare function withDataService<E extends Entity, F extends Filter>(options: {
-    dataServiceType: ProviderToken<DataService<E, F>>;
-    filter: F;
-}): SignalStoreFeature<EmptyFeatureResult & {
-    state: {
-        callState: CallState;
-    } & EntityState<E>;
-}, {
-    state: DataServiceState<E, F>;
-    props: DataServiceComputed<E>;
-    methods: DataServiceMethods<E, F>;
-}>;

package/lib/with-pagination.d.ts

@@ -1,98 +0,0 @@
-/** With pagination comes in two flavors the first one is local pagination or in memory pagination. For example we have 2000 items which we want
- * to display in a table and the response payload is small enough to be stored in the memory. But we can not display all 2000 items at once
- * so we need to paginate the data. The second flavor is server side pagination where the response payload is too large to be stored in the memory
- * and we need to fetch the data from the server in chunks. In the second case we 'could' also cache the data in the memory but that could lead to
- * other problems like memory leaks and stale data. So we will not cache the data in the memory in the second case.
- * This feature implements the local pagination.
- */
-import { Signal } from '@angular/core';
-import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
-export type Page = {
-    label: string | number;
-    value: number;
-};
-export type NamedPaginationServiceState<E, Collection extends string> = {
-    [K in Collection as `selectedPage${Capitalize<K>}Entities`]: Array<E>;
-} & {
-    [K in Collection as `${Lowercase<K>}CurrentPage`]: number;
-} & {
-    [K in Collection as `${Lowercase<K>}PageSize`]: number;
-} & {
-    [K in Collection as `${Lowercase<K>}TotalCount`]: number;
-} & {
-    [K in Collection as `${Lowercase<K>}PageCount`]: number;
-} & {
-    [K in Collection as `${Lowercase<K>}PageNavigationArray`]: number;
-} & {
-    [K in Collection as `${Lowercase<K>}PageNavigationArrayMax`]: number;
-};
-export type NamedPaginationServiceSignals<E, Collection extends string> = {
-    [K in Collection as `selectedPage${Capitalize<K>}Entities`]: Signal<E[]>;
-} & {
-    [K in Collection as `${Lowercase<K>}CurrentPage`]: Signal<number>;
-} & {
-    [K in Collection as `${Lowercase<K>}PageSize`]: Signal<number>;
-} & {
-    [K in Collection as `${Lowercase<K>}TotalCount`]: Signal<number>;
-} & {
-    [K in Collection as `${Lowercase<K>}PageCount`]: Signal<number>;
-} & {
-    [K in Collection as `${Lowercase<K>}PageNavigationArray`]: Signal<Page[]>;
-} & {
-    [K in Collection as `${Lowercase<K>}PageNavigationArrayMax`]: Signal<number>;
-} & {
-    [K in Collection as `hasNext${Capitalize<K>}Page`]: Signal<boolean>;
-} & {
-    [K in Collection as `hasPrevious${Capitalize<K>}Page`]: Signal<boolean>;
-};
-export type PaginationServiceState<E> = {
-    selectedPageEntities: Array<E>;
-    currentPage: number;
-    pageSize: number;
-    totalCount: number;
-    pageCount: number;
-    pageNavigationArray: Page[];
-    pageNavigationArrayMax: number;
-};
-export type PaginationServiceSignals<E> = {
-    selectedPageEntities: Signal<E[]>;
-    currentPage: Signal<number>;
-    pageSize: Signal<number>;
-    totalCount: Signal<number>;
-    pageCount: Signal<number>;
-    pageNavigationArray: Signal<Page[]>;
-    pageNavigationArrayMax: Signal<number>;
-    hasNextPage: Signal<boolean>;
-    hasPreviousPage: Signal<boolean>;
-};
-export type SetPaginationState<E, Collection extends string | undefined> = Collection extends string ? NamedPaginationServiceState<E, Collection> : PaginationServiceState<E>;
-export declare function withPagination<E, Collection extends string>(options: {
-    entity: E;
-    collection: Collection;
-}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
-    state: NamedPaginationServiceState<E, Collection>;
-    props: NamedPaginationServiceSignals<E, Collection>;
-}>;
-export declare function withPagination<E>(): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
-    state: PaginationServiceState<E>;
-    props: PaginationServiceSignals<E>;
-}>;
-export declare function gotoPage<E, Collection extends string>(page: number, options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function setPageSize<E, Collection extends string>(pageSize: number, options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function nextPage<E, Collection extends string>(options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function previousPage<E, Collection extends string>(options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function firstPage<E, Collection extends string>(options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function setMaxPageNavigationArrayItems<E, Collection extends string>(maxPageNavigationArrayItems: number, options?: {
-    collection: Collection;
-}): Partial<SetPaginationState<E, Collection>>;
-export declare function createPageArray(currentPage: number, itemsPerPage: number, totalItems: number, paginationRange: number): Page[];

package/lib/with-redux.d.ts

@@ -1,147 +0,0 @@
-import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult, WritableStateSource } from '@ngrx/signals';
-import { Observable } from 'rxjs';
-/** Actions **/
-type Payload = Record<string, unknown>;
-type ActionFn<Type extends string = string, ActionPayload extends Payload = Payload> = ((payload: ActionPayload) => ActionPayload & {
-    type: Type;
-}) & {
-    type: Type;
-};
-type ActionFns = Record<string, ActionFn>;
-export type ActionsFnSpecs = Record<string, Payload>;
-type ActionFnCreator<Spec extends ActionsFnSpecs> = {
-    [ActionName in keyof Spec]: (Record<never, never> extends Spec[ActionName] ? () => Spec[ActionName] & {
-        type: ActionName;
-    } : (payload: Spec[ActionName]) => Spec[ActionName] & {
-        type: ActionName;
-    }) & {
-        type: ActionName & string;
-    };
-};
-type ActionFnPayload<Action> = Action extends (payload: infer Payload) => void ? Payload : never;
-type ActionFnsCreator<Spec extends ActionsFnSpecs> = Spec extends {
-    private: Record<string, Payload>;
-    public: Record<string, Payload>;
-} ? ActionFnCreator<Spec['private']> & ActionFnCreator<Spec['public']> : ActionFnCreator<Spec>;
-type PublicActionFns<Spec extends ActionsFnSpecs> = Spec extends {
-    public: Record<string, Payload>;
-} ? ActionFnCreator<Spec['public']> : ActionFnCreator<Spec>;
-export declare function payload<Type extends Payload>(): Type;
-export declare const noPayload: {};
-/** Reducer **/
-type ReducerFunction<ReducerAction, State> = (state: State, action: ActionFnPayload<ReducerAction>) => void;
-type ReducerFactory<StateActionFns extends ActionFns, State> = (actions: StateActionFns, on: <ReducerAction extends {
-    type: string;
-}>(action: ReducerAction, reducerFn: ReducerFunction<ReducerAction, State>) => void) => void;
-/**
- * Creates a reducer function to separate the reducer logic into another file.
- *
- * ```typescript
- * interface FlightState {
- *   flights: Flight[];
- *   effect1: boolean;
- *   effect2: boolean;
- * }
- *
- * const initialState: FlightState = {
- *   flights: [],
- *   effect1: false,
- *   effect2: false,
- * };
- *
- * const actions = {
- *   init: noPayload,
- *   updateEffect1: payload<{ value: boolean }>(),
- *   updateEffect2: payload<{ value: boolean }>(),
- * };
- *
- * const reducer = createReducer<FlightState, typeof actions>((actions, on) => {
- *   on(actions.updateEffect1, (state, { value }) => {
- *     patchState(state, { effect1: value });
- *   });
- *
- *   on(actions.updateEffect2, (state, { value }) => {
- *     patchState(state, { effect2: value });
- *   });
- * });
- *
- * signalStore(
- *   withState(initialState),
- *   withRedux({
- *     actions,
- *     reducer,
- *   })
- * );
- * ```
- * @param reducerFactory
- */
-export declare function createReducer<State extends object, Actions extends ActionsFnSpecs>(reducerFactory: ReducerFactory<ActionFnsCreator<Actions>, WritableStateSource<State>>): ReducerFactory<ActionFnsCreator<Actions>, WritableStateSource<State>>;
-/** Effect **/
-type EffectsFactory<StateActionFns extends ActionFns> = (actions: StateActionFns, create: <EffectAction extends {
-    type: string;
-}>(action: EffectAction) => Observable<ActionFnPayload<EffectAction>>) => Record<string, Observable<unknown>>;
-/**
- * @deprecated Use NgRx's `@ngrx/signals/events` starting in 19.2
- *
- * Creates the effects function to separate the effects logic into another file.
- *
- * ```typescript
- * interface FlightState {
- *   flights: Flight[];
- *   effect1: boolean;
- *   effect2: boolean;
- * }
- *
- * const initialState: FlightState = {
- *   flights: [],
- *   effect1: false,
- *   effect2: false,
- * };
- *
- * const actions = {
- *   init: noPayload,
- *   updateEffect1: payload<{ value: boolean }>(),
- *   updateEffect2: payload<{ value: boolean }>(),
- * };
- *
- * const effects = createEffects(actions, (actions, create) => {
- *   return {
- *     init1$: create(actions.init).pipe(
- *       map(() => actions.updateEffect1({ value: true }))
- *     ),
- *     init2$: create(actions.init).pipe(
- *       map(() => actions.updateEffect2({ value: true }))
- *     ),
- *   };
- * });
- *
- * signalStore(
- *   withState(initialState),
- *   withRedux({
- *     actions,
- *     effects,
- *   })
- * );
- * ```
- * @param actions
- * @param effectsFactory
- */
-export declare function createEffects<Actions extends ActionsFnSpecs>(actions: Actions, effectsFactory: EffectsFactory<ActionFnsCreator<Actions>>): EffectsFactory<ActionFnsCreator<Actions>>;
-/**
- * @param redux redux
- *
- * properties do not start with `with` since they are not extension functions on their own.
- *
- * no dependency to NgRx
- *
- * actions are passed to reducer and effects, but it is also possible to use other actions.
- * effects provide forAction and do not return anything. that is important because effects should stay inaccessible
- */
-export declare function withRedux<Spec extends ActionsFnSpecs, Input extends SignalStoreFeatureResult, StateActionFns extends ActionFnsCreator<Spec> = ActionFnsCreator<Spec>, PublicStoreActionFns extends PublicActionFns<Spec> = PublicActionFns<Spec>>(redux: {
-    actions: Spec;
-    reducer: ReducerFactory<StateActionFns, WritableStateSource<Input['state']>>;
-    effects: EffectsFactory<StateActionFns>;
-}): SignalStoreFeature<Input, EmptyFeatureResult & {
-    methods: PublicStoreActionFns;
-}>;
-export {};

package/lib/with-reset.d.ts

@@ -1,29 +0,0 @@
-import { StateSource } from '@ngrx/signals';
-export type PublicMethods = {
-    resetState(): void;
-};
-/**
- * Adds a `resetState` method to the store, which resets the state
- * to the initial state.
- *
- * If you want to set a custom initial state, you can use {@link setResetState}.
- */
-export declare function withReset(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
-    state: {};
-    props: {
-        _resetState: {
-            value: {};
-        };
-    };
-    methods: {
-        resetState: () => void;
-    };
-}>;
-/**
- * Sets the reset state of the store to the given state.
- *
- * Throws an error if the store is not configured with {@link withReset}.
- * @param store the instance of a SignalStore
- * @param state the state to set as the reset state
- */
-export declare function setResetState<State extends object>(store: StateSource<State>, state: State): void;

package/lib/with-undo-redo.d.ts

@@ -1,31 +0,0 @@
-import { Signal } from '@angular/core';
-import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult } from '@ngrx/signals';
-export type StackItem = Record<string, unknown>;
-export type NormalizedUndoRedoOptions = {
-    maxStackSize: number;
-    collections?: string[];
-    keys: string[];
-    skip: number;
-};
-export declare function getUndoRedoKeys(collections?: string[]): string[];
-type NonNever<T> = T extends never ? never : T;
-type ExtractEntityCollection<T> = T extends `${infer U}Entities` ? U : never;
-type ExtractEntityCollections<Store extends SignalStoreFeatureResult> = NonNever<{
-    [K in keyof Store['props']]: ExtractEntityCollection<K>;
-}[keyof Store['props']]>;
-type OptionsForState<Store extends SignalStoreFeatureResult> = Partial<Omit<NormalizedUndoRedoOptions, 'collections' | 'keys'>> & {
-    collections?: ExtractEntityCollections<Store>[];
-    keys?: (keyof Store['state'])[];
-};
-export declare function withUndoRedo<Input extends EmptyFeatureResult>(options?: OptionsForState<Input>): SignalStoreFeature<Input, EmptyFeatureResult & {
-    props: {
-        canUndo: Signal<boolean>;
-        canRedo: Signal<boolean>;
-    };
-    methods: {
-        undo: () => void;
-        redo: () => void;
-        clearStack: () => void;
-    };
-}>;
-export {};

package/redux-connector/index.d.ts

@@ -1,2 +0,0 @@
-export { createReduxState, mapAction, withActionMappers, } from './src/lib/create-redux';
-export { reduxMethod } from './src/lib/rxjs-interop/redux-method';

package/redux-connector/src/lib/create-redux.d.ts

@@ -1,13 +0,0 @@
-import { ActionCreator, ActionType } from '@ngrx/store/src/models';
-import { CreateReduxState, MapperTypes, Store } from './model';
-export declare function mapAction<Creators extends readonly ActionCreator[]>(...args: [
-    ...creators: Creators,
-    storeMethod: (action: ActionType<Creators[number]>) => unknown
-]): MapperTypes<Creators>;
-export 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>;
-export declare function withActionMappers(...mappers: MapperTypes<ActionCreator[]>[]): MapperTypes<ActionCreator[]>[];
-export declare function createReduxState<StoreName extends string, STORE extends Store>(storeName: StoreName, signalStore: STORE, withActionMappers: (store: InstanceType<STORE>) => MapperTypes<ActionCreator[]>[]): CreateReduxState<StoreName, STORE>;