@angular-architects/ngrx-toolkit 19.3.0 → 19.4.0

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/rx-mutation.d.ts

@@ -1,58 +0,0 @@
-import { Injector } from '@angular/core';
-import { Observable } from 'rxjs';
-import { FlatteningOperator } from './flattening-operator';
-import { Mutation } from './with-mutations';
-export type Func<P, R> = (params: P) => R;
-export interface RxMutationOptions<P, R> {
-    operation: Func<P, Observable<R>>;
-    onSuccess?: (result: R, params: P) => void;
-    onError?: (error: unknown, params: P) => void;
-    operator?: FlatteningOperator;
-    injector?: Injector;
-}
-/**
- * Creates a mutation that leverages RxJS.
- *
- * For each mutation the following options can be defined:
- * - `operation`: A function that defines the mutation logic. It returns an Observable.
- * - `onSuccess`: A callback that is called when the mutation is successful.
- * - `onError`: A callback that is called when the mutation fails.
- * - `operator`: An optional wrapper of an RxJS flattening operator. By default `concat` sematics are used.
- * - `injector`: An optional Angular injector to use for dependency injection.
- *
- * The `operation` is the only mandatory option.
- *
- * ```typescript
- * export type Params = {
- *   value: number;
- * };
- *
- * export const CounterStore = signalStore(
- *   { providedIn: 'root' },
- *   withState({ counter: 0 }),
- *   withMutations((store) => ({
- *     increment: rxMutation({
- *       operation: (params: Params) => {
- *         return calcSum(store.counter(), params.value);
- *       },
- *       operator: concatOp,
- *       onSuccess: (result) => {
- *         console.log('result', result);
- *         patchState(store, { counter: result });
- *       },
- *       onError: (error) => {
- *         console.error('Error occurred:', error);
- *       },
- *     }),
- *   })),
- * );
- *
- * function calcSum(a: number, b: number): Observable<number> {
- *   return of(a + b);
- * }
- * ```
- *
- * @param options
- * @returns
- */
-export declare function rxMutation<P, R>(options: RxMutationOptions<P, R>): Mutation<P, R>;

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,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-mutations.d.ts

@@ -1,66 +0,0 @@
-import { Signal } from '@angular/core';
-import { EmptyFeatureResult, SignalStoreFeature, SignalStoreFeatureResult, StateSignals, WritableStateSource } from '@ngrx/signals';
-export type Mutation<P, R> = {
-    (params: P): Promise<MutationResult<R>>;
-    status: Signal<MutationStatus>;
-    isPending: Signal<boolean>;
-    error: Signal<unknown>;
-};
-type MutationsDictionary = Record<string, Mutation<any, any>>;
-export type MutationResult<T> = {
-    status: 'success';
-    value: T;
-} | {
-    status: 'error';
-    error: unknown;
-} | {
-    status: 'aborted';
-};
-export type MutationStatus = 'idle' | 'pending' | 'error' | 'success';
-export type MethodsDictionary = Record<string, Function>;
-type NamedMutationProps<T extends MutationsDictionary> = {
-    [Prop in keyof T as `${Prop & string}IsPending`]: Signal<boolean>;
-} & {
-    [Prop in keyof T as `${Prop & string}Status`]: Signal<MutationStatus>;
-} & {
-    [Prop in keyof T as `${Prop & string}Error`]: Signal<Error | undefined>;
-};
-type NamedMutationMethods<T extends MutationsDictionary> = {
-    [Prop in keyof T as `${Prop & string}`]: T[Prop] extends Mutation<infer P, infer R> ? Mutation<P, R> : never;
-};
-export type NamedMutationResult<T extends MutationsDictionary> = EmptyFeatureResult & {
-    props: NamedMutationProps<T>;
-    methods: NamedMutationMethods<T>;
-};
-/**
- * Adds mutation methods to the store. Also, for each mutation method, several
- * Signals are added informing about the mutation's status and errors.
- *
- * ```typescript
- * export type Params = {
- *   value: number;
- * };
- *
- * export const CounterStore = signalStore(
- *   { providedIn: 'root' },
- *   withState({ counter: 0 }),
- *   withMutations((store) => ({
- *     increment: rxMutation({ ... }),
- *   })),
- * );
- * ```
- *
- * There are several types of mutations. In the example shown, an {@link module:rx-mutation.rxMutation | rxMutation}
- * leveraging RxJS is used
- *
- * For the defined `increment` mutation, several the following properties and
- * methods are added to the store:
- * - `increment(params: Params): Promise<MutationResult<number>>`: The mutation method.
- * - `incrementIsPending`: A signal indicating if the mutation is in progress.
- * - `incrementStatus`: A signal representing the current status of the mutation.
- * - `incrementError`: A signal containing any error that occurred during the mutation.
- *
- * @param mutationsFactory
- */
-export declare function withMutations<Input extends SignalStoreFeatureResult, Result extends MutationsDictionary>(mutationsFactory: (store: Input['props'] & Input['methods'] & WritableStateSource<Input['state']> & StateSignals<Input['state']>) => Result): SignalStoreFeature<Input, NamedMutationResult<Result>>;
-export {};

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[];