@angular-architects/ngrx-toolkit 20.0.2 → 20.0.3

package/index.d.ts

@@ -0,0 +1,945 @@
+import * as _ngrx_signals from '@ngrx/signals';
+import { StateSource, patchState as patchState$1, WritableStateSource, PartialStateUpdater, SignalStoreFeature, EmptyFeatureResult, SignalStoreFeatureResult, StateSignals } from '@ngrx/signals';
+import { ValueProvider, Signal, ProviderToken, WritableSignal } from '@angular/core';
+import { Observable } from 'rxjs';
+import { EntityId, NamedEntityState } from '@ngrx/signals/entities';
+
+/**
+ * Provides the configuration options for connecting to the Redux DevTools Extension.
+ */
+declare function provideDevtoolsConfig(config: ReduxDevtoolsConfig): ValueProvider;
+/**
+ * Options for connecting to the Redux DevTools Extension.
+ * @example
+ * const devToolsOptions: ReduxDevtoolsConfig = {
+ *   name: 'My App',
+ * };
+ */
+type ReduxDevtoolsConfig = {
+    /** Optional name for the devtools instance. If empty, "NgRx SignalStore" will be used. */
+    name?: string;
+};
+
+type Action = {
+    type: string;
+};
+type Connection = {
+    send: (action: Action, state: Record<string, unknown>) => void;
+};
+type ReduxDevtoolsExtension = {
+    connect: (options: ReduxDevtoolsConfig) => Connection;
+};
+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;
+};
+type TrackerStores = Record<string, StateSource<object>>;
+
+declare const DEVTOOLS_FEATURE: unique symbol;
+type Mapper = (state: object) => object;
+type DevtoolsOptions = {
+    indexNames?: boolean;
+    map?: Mapper;
+    tracker?: new () => 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.
+ */
+type DevtoolsFeature = {
+    [DEVTOOLS_FEATURE]: true;
+} & Partial<DevtoolsOptions>;
+
+/**
+ * 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
+ * ```
+ *
+ */
+declare function withDisabledNameIndices(): DevtoolsFeature;
+
+/**
+ * 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.
+ */
+declare function withGlitchTracking(): DevtoolsFeature;
+
+/**
+ * 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
+ */
+declare function withMapper<State extends object>(map: (state: State) => Record<string, unknown>): DevtoolsFeature;
+
+/**
+ * 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
+ */
+declare function renameDevtoolsName<State extends object>(store: StateSource<State>, newName: string): void;
+
+type PatchFn = typeof patchState$1 extends (arg1: infer First, ...args: infer Rest) => infer Returner ? (state: First, action: string, ...rest: Rest) => Returner : never;
+/**
+ * @deprecated Has been renamed to `updateState`
+ */
+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
+ */
+declare function updateState<State extends object>(stateSource: WritableStateSource<State>, action: string, ...updaters: Array<Partial<NoInfer<State>> | PartialStateUpdater<NoInfer<State>>>): void;
+
+declare global {
+    interface Window {
+        __REDUX_DEVTOOLS_EXTENSION__: ReduxDevtoolsExtension | undefined;
+    }
+}
+/**
+ * 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
+ */
+declare function withDevtools(name: string, ...features: DevtoolsFeature[]): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult>;
+
+/**
+ * Stub for DevTools integration. Can be used to disable DevTools in production.
+ */
+declare const withDevToolsStub: typeof withDevtools;
+
+/** 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>;
+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>;
+declare function payload<Type extends Payload>(): Type;
+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
+ */
+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
+ */
+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
+ */
+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;
+}>;
+
+type CallState = 'init' | 'loading' | 'loaded' | {
+    error: string;
+};
+type CallStateSlice = {
+    callState: CallState;
+};
+type NamedCallStateSlice<Collection extends string> = {
+    [K in keyof CallStateSlice as Collection extends '' ? `${Collection}${K}` : `${Collection}${Capitalize<K>}`]: CallStateSlice[K];
+};
+type CallStateSignals = {
+    loading: Signal<boolean>;
+    loaded: Signal<boolean>;
+    error: Signal<string | null>;
+};
+type NamedCallStateSignals<Prop extends string> = {
+    [K in keyof CallStateSignals as Prop extends '' ? `${Prop}${K}` : `${Prop}${Capitalize<K>}`]: CallStateSignals[K];
+};
+type SetCallState<Prop extends string | undefined> = Prop extends string ? NamedCallStateSlice<Prop> : CallStateSlice;
+declare function deriveCallStateKeys<Collection extends string>(collection?: Collection): {
+    callStateKey: string;
+    loadingKey: string;
+    loadedKey: string;
+    errorKey: string;
+};
+declare function getCallStateKeys(config?: {
+    collection?: string;
+}): {
+    callStateKey: string;
+    loadingKey: string;
+    loadedKey: string;
+    errorKey: string;
+};
+declare function getCollectionArray(config: {
+    collection?: string;
+} | {
+    collections?: string[];
+}): string[] | undefined;
+declare function withCallState<Collection extends string>(config: {
+    collections: Collection[];
+}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: NamedCallStateSlice<Collection>;
+    props: NamedCallStateSignals<Collection>;
+}>;
+declare function withCallState<Collection extends string>(config: {
+    collection: Collection;
+}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: NamedCallStateSlice<Collection>;
+    props: NamedCallStateSignals<Collection>;
+}>;
+declare function withCallState(): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: CallStateSlice;
+    props: CallStateSignals;
+}>;
+declare function setLoading<Prop extends string | undefined = undefined>(prop?: Prop): SetCallState<Prop>;
+declare function setLoaded<Prop extends string | undefined = undefined>(prop?: Prop): SetCallState<Prop>;
+declare function setError<Prop extends string | undefined = undefined>(error: unknown, prop?: Prop): SetCallState<Prop>;
+
+/**
+ * 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.
+ */
+
+type EntityState<Entity> = {
+    entityMap: Record<EntityId, Entity>;
+    ids: EntityId[];
+};
+
+type Filter = Record<string, unknown>;
+type Entity = {
+    id: EntityId;
+};
+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>;
+}
+declare function capitalize(str: string): string;
+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;
+};
+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;
+};
+type DataServiceState<E extends Entity, F extends Filter> = {
+    filter: F;
+    selectedIds: Record<EntityId, boolean>;
+    current: E;
+};
+type DataServiceComputed<E extends Entity> = {
+    selectedEntities: Signal<E[]>;
+};
+type NamedDataServiceComputed<E extends Entity, Collection extends string> = {
+    [K in Collection as `selected${Capitalize<K>}Entities`]: Signal<E[]>;
+};
+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>;
+};
+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>;
+};
+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>;
+}>;
+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>;
+}>;
+
+/** 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.
+ */
+
+type Page = {
+    label: string | number;
+    value: number;
+};
+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;
+};
+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>;
+};
+type PaginationServiceState<E> = {
+    selectedPageEntities: Array<E>;
+    currentPage: number;
+    pageSize: number;
+    totalCount: number;
+    pageCount: number;
+    pageNavigationArray: Page[];
+    pageNavigationArrayMax: number;
+};
+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>;
+};
+type PageState<Collection extends string | undefined> = Collection extends string ? {
+    [K in Collection as `${Lowercase<K>}CurrentPage`]: number;
+} : {
+    currentPage: number;
+};
+type PageSizeState<Collection extends string | undefined> = Collection extends string ? {
+    [K in Collection as `${Lowercase<K>}PageSize`]: number;
+} : {
+    pageSize: number;
+};
+type SetPaginationState<E, Collection extends string | undefined> = Collection extends string ? NamedPaginationServiceState<E, Collection> : PaginationServiceState<E>;
+declare function withPagination<E, Collection extends string>(options: {
+    entity: E;
+    collection: Collection;
+}): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: NamedPaginationServiceState<E, Collection>;
+    props: NamedPaginationServiceSignals<E, Collection>;
+}>;
+declare function withPagination<E>(): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: PaginationServiceState<E>;
+    props: PaginationServiceSignals<E>;
+}>;
+declare function gotoPage<Collection extends string>(page: number, options?: {
+    collection: Collection;
+}): PageState<Collection>;
+declare function setPageSize<Collection extends string>(pageSize: number, options?: {
+    collection: Collection;
+}): PageSizeState<Collection>;
+type SetPageState<Collection extends string | undefined> = (state: PageState<Collection>) => PageState<Collection>;
+declare function nextPage<Collection extends string>(options?: {
+    collection: Collection;
+}): SetPageState<Collection>;
+declare function previousPage<Collection extends string>(options?: {
+    collection: Collection;
+}): SetPageState<Collection>;
+declare function firstPage<Collection extends string>(options?: {
+    collection: Collection;
+}): PageState<Collection>;
+declare function setMaxPageNavigationArrayItems<E, Collection extends string>(maxPageNavigationArrayItems: number, options?: {
+    collection: Collection;
+}): Partial<SetPaginationState<E, Collection>>;
+declare function createPageArray(currentPage: number, itemsPerPage: number, totalItems: number, paginationRange: number): Page[];
+
+/**
+ * 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}.
+ */
+declare function withReset(): _ngrx_signals.SignalStoreFeature<_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
+ */
+declare function setResetState<State extends object>(store: StateSource<State>, state: State): void;
+
+type StackItem = Record<string, unknown>;
+type NormalizedUndoRedoOptions = {
+    maxStackSize: number;
+    collections?: string[];
+    keys: string[];
+    skip: number;
+};
+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'])[];
+};
+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;
+    };
+}>;
+
+/**
+ * Starting from v20, the root properties of the state object
+ * are all of type `WritableSignal`.
+ *
+ * That means, we cannot freeze root properties, which are of a
+ * primitive data type.
+ *
+ * This is a breaking change, because in v19 the state was a Signal.
+ * We had the possibility to freeze that Signal's
+ * object and could therefore provide immutability for
+ * root properties of primitive data types.
+ *
+ * For example:
+ *
+ * ```ts
+ * const state = {
+ *   id: 1, // was frozen in v19, but not in >= v20
+ *   address: {
+ *     street: 'Main St',
+ *     city: 'Springfield',
+ *   }
+ * }
+ * ```
+ */
+/**
+ * Prevents mutation of the state.
+ *
+ * This is done by applying `Object.freeze` to each root
+ * property of the state. Any mutable change within
+ * or outside the `SignalStore` will throw an error.
+ *
+ * Root properties of the state having a primitive data type
+ * are not supported.
+ *
+ *  * For example:
+ *
+ * ```ts
+ * const state = {
+ *   // ⛔️ are not frozen -> mutable changes possible
+ *   id: 1,
+ *
+ *   // ✅ are frozen -> mutable changes throw
+ *   address: {
+ *     street: 'Main St',
+ *     city: 'Springfield',
+ *   }
+ * }
+ * ```
+ *
+ * @param state the state object
+ * @param options enable protection in production (default: false)
+ */
+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 applying `Object.freeze` to each root
+ * property of the state. Any mutable change within
+ * or outside the `SignalStore` will throw an error.
+ *
+ * Root properties of the state having a primitive data type
+ * are not supported.
+ *
+ *  * For example:
+ *
+ * ```ts
+ * const state = {
+ *   // ⛔️ are not frozen -> mutable changes possible
+ *   id: 1,
+ *
+ *   // ✅ are frozen -> mutable changes throw
+ *   address: {
+ *     street: 'Main St',
+ *     city: 'Springfield',
+ *   }
+ * }
+ * ```
+ *
+ * @param stateFactory a function returning the state object
+ * @param options enable protection in production (default: false)
+ */
+declare function withImmutableState<State extends object>(stateFactory: () => State, options?: {
+    enableInProduction?: boolean;
+}): SignalStoreFeature<SignalStoreFeatureResult, EmptyFeatureResult & {
+    state: State;
+}>;
+
+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;
+};
+declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string): SignalStoreFeature<Input, SyncFeatureResult>;
+declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string, storageStrategy: AsyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, AsyncFeatureResult>;
+declare function withStorageSync<Input extends SignalStoreFeatureResult>(key: string, storageStrategy: SyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;
+declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;
+declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>, storageStrategy: AsyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, AsyncFeatureResult>;
+declare function withStorageSync<Input extends SignalStoreFeatureResult>(config: SyncConfig<Input['state']>, storageStrategy: SyncStorageStrategy<Input['state']>): SignalStoreFeature<Input, SyncFeatureResult>;
+
+type SyncMethods = {
+    clearStorage(): void;
+    readFromStorage(): void;
+    writeToStorage(): void;
+};
+type SyncFeatureResult = EmptyFeatureResult & {
+    methods: SyncMethods;
+};
+type SyncStoreForFactory<State extends object> = WritableStateSource<State>;
+type SyncStorageStrategy<State extends object> = ((config: Required<SyncConfig<State>>, store: SyncStoreForFactory<State>, useStubs: boolean) => SyncMethods) & {
+    type: 'sync';
+};
+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.
+ */
+declare const SYNC_STATUS: unique symbol;
+type SyncStatus = 'idle' | 'syncing' | 'synced';
+type InternalAsyncProps = AsyncFeatureResult['props'] & {
+    [SYNC_STATUS]: WritableSignal<SyncStatus>;
+};
+type AsyncFeatureResult = EmptyFeatureResult & {
+    methods: AsyncMethods;
+    props: {
+        isSynced: Signal<boolean>;
+        whenSynced: () => Promise<void>;
+    };
+};
+type AsyncStoreForFactory<State extends object> = WritableStateSource<State> & InternalAsyncProps;
+type AsyncStorageStrategy<State extends object> = ((config: Required<SyncConfig<State>>, store: AsyncStoreForFactory<State>, useStubs: boolean) => AsyncMethods) & {
+    type: 'async';
+};
+
+declare function withIndexedDB<State extends object>(): AsyncStorageStrategy<State>;
+
+declare function withLocalStorage<State extends object>(): SyncStorageStrategy<State>;
+declare function withSessionStorage<State extends object>(): SyncStorageStrategy<State>;
+
+/**
+ * `withConditional` activates a feature based on a given condition.
+ *
+ * **Use Cases**
+ * - Conditionally activate features based on the **store state** or other criteria.
+ * - Choose between **two different implementations** of a feature.
+ *
+ * **Type Constraints**
+ * Both features must have **exactly the same state, props, and methods**.
+ * Otherwise, a type error will occur.
+ *
+ *
+ * **Usage**
+ *
+ * ```typescript
+ * const withUser = signalStoreFeature(
+ *   withState({ id: 1, name: 'Konrad' }),
+ *   withHooks(store => ({
+ *     onInit() {
+ *       // user loading logic
+ *     }
+ *   }))
+ * );
+ *
+ * function withFakeUser() {
+ *   return signalStoreFeature(
+ *     withState({ id: 0, name: 'anonymous' })
+ *   );
+ * }
+ *
+ * signalStore(
+ *   withMethods(() => ({
+ *     useRealUser: () => true
+ *   })),
+ *   withConditional((store) => store.useRealUser(), withUser, withFakeUser)
+ * )
+ * ```
+ *
+ * @param condition - A function that determines which feature to activate based on the store state.
+ * @param featureIfTrue - The feature to activate if the condition evaluates to `true`.
+ * @param featureIfFalse - The feature to activate if the condition evaluates to `false`.
+ * @returns A `SignalStoreFeature` that applies the selected feature based on the condition.
+ */
+declare function withConditional<Input extends SignalStoreFeatureResult, Output extends SignalStoreFeatureResult>(condition: (store: StateSignals<Input['state']> & Input['props'] & Input['methods']) => boolean, featureIfTrue: SignalStoreFeature<NoInfer<Input>, Output>, featureIfFalse: SignalStoreFeature<NoInfer<Input>, NoInfer<Output>>): SignalStoreFeature<Input, Output>;
+declare const emptyFeature: SignalStoreFeature<_ngrx_signals.EmptyFeatureResult, {
+    state: {};
+    props: {};
+    methods: {};
+}>;
+
+type StoreForFactory<Input extends SignalStoreFeatureResult> = StateSignals<Input['state']> & Input['props'] & Input['methods'];
+/**
+ * @deprecated Use `import { withFeature } from '@ngrx/signals'` instead, starting with `ngrx/signals` 19.1: https://ngrx.io/guide/signals/signal-store/custom-store-features#connecting-a-custom-feature-with-the-store
+ *
+ * Allows to pass properties, methods, or signals from a SignalStore
+ * to a feature.
+ *
+ * Typically, a `signalStoreFeature` can have input constraints on
+ *
+ * ```typescript
+ * function withSum(a: Signal<number>, b: Signal<number>) {
+ *   return signalStoreFeature(
+ *     withComputed(() => ({
+ *       sum: computed(() => a() + b())
+ *     }))
+ *   );
+ * }
+ *
+ * signalStore(
+ *   withState({ a: 1, b: 2 }),
+ *   withFeatureFactory((store) => withSum(store.a, store.b))
+ * );
+ * ```
+ * @param factoryFn
+ */
+declare function withFeatureFactory<Input extends SignalStoreFeatureResult, Output extends SignalStoreFeatureResult>(factoryFn: (store: StoreForFactory<Input>) => SignalStoreFeature<Input, Output>): SignalStoreFeature<Input, Output>;
+
+export { capitalize, createEffects, createPageArray, createReducer, deriveCallStateKeys, emptyFeature, firstPage, getCallStateKeys, getCollectionArray, getDataServiceKeys, getUndoRedoKeys, gotoPage, nextPage, noPayload, patchState, payload, previousPage, provideDevtoolsConfig, renameDevtoolsName, setError, setLoaded, setLoading, setMaxPageNavigationArrayItems, setPageSize, setResetState, updateState, withCallState, withConditional, withDataService, withDevToolsStub, withDevtools, withDisabledNameIndices, withFeatureFactory, withGlitchTracking, withImmutableState, withIndexedDB, withIndexedDB as withIndexeddb, withLocalStorage, withMapper, withPagination, withRedux, withReset, withSessionStorage, withStorageSync, withUndoRedo };
+export type { CallState, CallStateSignals, CallStateSlice, DataService, DataServiceComputed, DataServiceMethods, DataServiceState, Entity, Filter, NamedCallStateSignals, NamedCallStateSlice, NamedDataServiceComputed, NamedDataServiceMethods, NamedDataServiceState, NamedPaginationServiceSignals, NamedPaginationServiceState, NormalizedUndoRedoOptions, Page, PaginationServiceSignals, PaginationServiceState, ReduxDevtoolsConfig, SetCallState, SetPaginationState, StackItem, SyncConfig };