@reforgium/statum 3.0.1 → 3.1.1

package/package.json

@@ -1,7 +1,7 @@
 {
-  "version": "3.0.1",
+  "version": "3.1.1",
   "name": "@reforgium/statum",
-  "description": "Signals-first query and data stores for Angular",
+  "description": "Signals-first API state and query stores for Angular",
   "author": "rtommievich",
   "license": "MIT",
   "type": "module",
@@ -21,10 +21,21 @@
   },
   "keywords": [
     "reforgium",
-    "state",
+    "angular",
+    "angular-library",
+    "signals",
+    "signal-store",
     "store",
-    "signal",
-    "angular"
+    "data-store",
+    "resource-store",
+    "entity-store",
+    "dictionary",
+    "query",
+    "pagination",
+    "cache",
+    "http",
+    "api",
+    "serializer"
   ],
   "types": "../../dist/@reforgium/statum/index.d.ts",
   "files": [
@@ -42,7 +53,7 @@
   "peerDependencies": {
     "@angular/common": ">=18.0.0",
     "@angular/core": ">=18.0.0",
-    "@reforgium/internal": ">=1.3.0",
+    "@reforgium/internal": ">=2.0.0",
     "rxjs": ">=7.0.0"
   },
   "module": "fesm2022/reforgium-statum.mjs",

package/types/reforgium-statum.d.ts

@@ -1,295 +1,28 @@
-import { AnyType, AnyDict, RestMethods, QueryParams, PageableRequest, PageableResponse } from '@reforgium/internal';
+import { DataType, SerializerConfig, Serializer, RestMethods, AnyDict, AnyType, QueryParams, PageableRequest, PageableResponse, StorageStrategy } from '@reforgium/internal';
+export { DataType, FieldConcatType, FieldConfig, FormatConfig, LocalStorage, LruCache, MemoryStorage, ParseFormatConfig, SerializedType, Serializer, SerializerConfig, SerializerFieldError, SessionStorage, StorageInterface, StorageStrategy, StorageStrategyOptions, Types, storageStrategy } from '@reforgium/internal';
 import * as _angular_core from '@angular/core';
 import { Signal, WritableSignal, EnvironmentProviders, InjectionToken } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
 import * as _reforgium_statum from '@reforgium/statum';
 
-/**
- * List of supported primitive and composite data types
- * that can be serialized/deserialized.
- *
- * Used in field serialization configuration.
- */
-type Types = 'string' | 'number' | 'boolean' | 'array' | 'object' | 'date' | 'period' | 'nullable';
-type FieldConcatType = 'comma' | 'multi' | 'json';
-/**
- * Allowed "flat" values after serialization.
- * Such values are safe to pass in a query string or JSON.
- */
-type SerializedPrimitives = string | number | boolean | null;
-type SerializedTypeType = SerializedPrimitives | SerializedPrimitives[];
-type DatePeriod = [Date | null, Date | null];
-/**
- * Generic configuration shape to define `parse`/`format`
- * for converting a value from/to a serialized form.
- *
- * @template TypeFrom — domain type before serialization
- * @template TypeTo   — serialized type (by default a primitive/array of primitives)
- */
-type ParseFormatConfig<TypeFrom, TypeTo = SerializedTypeType> = {
-    parse?: (val: TypeTo) => TypeFrom;
-    format?: (val: TypeFrom) => TypeTo;
-};
-/**
- * Simplified configuration when only `format` is needed.
- */
-type FormatConfig<TypeFrom, TypeTo = SerializedTypeType> = {
-    format?: (val: TypeFrom) => TypeTo;
-};
-type FieldConfig = ({
-    type: Types;
-    concatType?: FieldConcatType;
-} | FieldsTypeConfig<DataType, AnyType>) & {
-    concatType?: FieldConcatType;
-};
-type FieldsTypeConfig<EntityType extends DataType, TypeFrom, TypeTo = SerializedTypeType> = {
-    parse: (val: TypeTo, data: SerializedType) => TypeFrom;
-    format: (val: TypeFrom, data: EntityType) => TypeTo;
-};
-type PeriodSplitMode = {
-    mode: 'split';
-    dateFromKeyPostfix: string;
-    dateToKeyPostfix: string;
-};
-type PeriodJoinMode = {
-    mode: 'join';
-    concat: string;
-};
-type SerializerConfig = {
-    mapString: {
-        trim?: boolean;
-    } & ParseFormatConfig<string>;
-    mapNumber: {
-        fromString?: boolean;
-    } & ParseFormatConfig<number>;
-    mapBoolean: {
-        true?: string;
-        false?: string;
-    } & ParseFormatConfig<boolean>;
-    mapDate: {
-        dateFormat?: string;
-    } & ParseFormatConfig<Date>;
-    /**
-     * Settings for date period transformation.
-     * Allows choosing a mode:
-     *  - split: split the period into two keys (e.g., createdFrom/createdTo)
-     *  - join: join into a string using a delimiter
-     * And set the date format.
-     */
-    mapPeriod: {
-        transformMode?: PeriodSplitMode | PeriodJoinMode;
-        dateFormat?: string;
-    } & ParseFormatConfig<DatePeriod>;
-    /**
-     * Settings for handling "empty" values.
-     * - remove: remove the field from the result;
-     * - replaceWith: replace with a fixed value;
-     * - includeEmptyString: treat an empty string as "nullable".
-     */
-    mapNullable: {
-        remove?: boolean;
-        replaceWith?: string;
-        includeEmptyString?: boolean;
-    } & ParseFormatConfig<null | undefined>;
-    /**
-     * Array settings:
-     * - concatType: serialization strategy (`comma` | `multi` | `json`);
-     * - removeNullable: remove empty items;
-     * - format: custom array formatter.
-     */
-    mapArray: {
-        concatType: FieldConcatType;
-        removeNullable?: boolean;
-    } & FormatConfig<AnyType[]>;
-    /**
-     * Object settings:
-     * - deep: deep (recursive) serialization or treat as JSON string;
-     * - format: custom object formatter.
-     */
-    mapObject: {
-        deep: boolean;
-    } & FormatConfig<DataType>;
-    /**
-     * Per-field overrides by key.
-     */
-    mapFields?: Record<string, FieldConfig>;
-};
-/**
- * Flat serialization result: dictionary key → primitive(s).
- */
-type SerializedType = Record<string, SerializedTypeType>;
-/**
- * Generic dictionary of domain data.
- */
-type DataType = AnyDict;
-
-declare class SerializerFieldError extends Error {
-    readonly field: string;
-    readonly stage: 'parse' | 'format';
-    readonly originalError: unknown;
-    constructor(field: string, stage: 'parse' | 'format', originalError: unknown);
-}
-/**
- * Universal serializer/deserializer for values used in forms, filters, and DTOs.
- *
- * Supports types: `string | number | boolean | Date | [Date, Date] (period) | array | object | nullable`.
- * Capabilities:
- * - normalize values according to config (trim strings, parse numbers from strings, boolean strings, etc.),
- * - transform date periods into paired keys (`from/to`) or a single joined string,
- * - build/parse a query string (or JSON) to and from an object.
- *
- * Example:
- * ```ts
- * type Filters = { q?: string; active?: boolean; created?: [Date, Date] | null };
- * const s = new Serializer<Filters>({
- *   mapPeriod: { transformMode: { mode: 'split', dateFromKeyPostfix: 'From', dateToKeyPostfix: 'To' } }
- * });
- *
- * // -> { q: 'john', createdFrom: '2025-01-01', createdTo: '2025-01-31' }
- * const plain = s.serialize({
- *   q: '  john ',
- *   active: undefined,
- *   created: [new Date('2025-01-01'), new Date('2025-01-31')]
- * });
- *
- * // -> 'q=john&createdFrom=2025-01-01&createdTo=2025-01-31'
- * const qs = s.toQuery({ q: 'john', created: [new Date('2025-01-01'), new Date('2025-01-31')] });
- *
- * // <- { q: 'john', created: [Date, Date] }
- * const parsed = s.deserialize('q=john&createdFrom=2025-01-01&createdTo=2025-01-31');
- * ```
- */
-declare class Serializer<EntityType extends DataType> {
-    readonly config: SerializerConfig;
-    /**
-     * Creates a serializer with a partially overridden configuration.
-     * Provide only the options you want to change (the rest are taken from defaults).
-     *
-     * @param config partial transformation configuration
-     */
-    constructor(config?: Partial<SerializerConfig>);
-    /**
-     * Converts a domain object into a flat serialized representation
-     * (ready to send to an API or build a query string).
-     *
-     * Rules are taken from `config`:
-     * — strings can be trimmed (if enabled),
-     * — numbers can be converted from strings/numbers,
-     * — boolean supports custom true/false representations,
-     * — dates are formatted by `dateFormat`,
-     * — date periods can be split/joined,
-     * — `nullable` can be removed from the result (`remove`) or formatted.
-     *
-     * @param obj source object
-     * @returns a flat dictionary with string/primitive values
-     */
-    serialize(obj: EntityType): SerializedType;
-    /**
-     * Parse serialized data into a domain object.
-     *
-     * Source can be:
-     * — a query string (`key=value&arr=1,2`) or `JSON.stringify(obj)`,
-     * — an already prepared flat object.
-     *
-     * Transformations are reverse of `serialize`: strings → number/boolean/Date/period,
-     * arrays are collected according to strategy (`comma`/`pipe`/`multi`), objects — deeply or as JSON.
-     *
-     * @param val query string or object
-     * @returns a domain object of the specified type
-     */
-    deserialize: (val: string | AnyDict) => EntityType;
-    /** Parse only query-string input. */
-    deserializeQuery: (query: string) => EntityType;
-    /** Parse only JSON object input. */
-    deserializeJson: (json: string) => EntityType;
-    /**
-     * Build a query string from a domain object using `serialize` rules
-     * and the array joining strategy (`concatType`).
-     *
-     * @param val domain object
-     * @returns query string (suitable for URL or history API)
-     */
-    toQuery: (val: EntityType) => string;
-    /**
-     * Returns a new serializer instance with a merged configuration.
-     * Useful for ad-hoc overrides for a specific call.
-     *
-     * @param config partial config changes
-     * @returns new `Serializer` with the provided `config` applied
-     */
-    withConfig(config: Partial<SerializerConfig>): Serializer<EntityType>;
-    private serializeElement;
-    private deserializeElement;
-    private parseQuery;
-    private parseJsonObject;
-    private parseInputString;
-    private mergeConfig;
-    private resolveArrayFieldModes;
-}
-
 declare const createQuerySerializer: <EntityType extends DataType = DataType>(config?: Partial<SerializerConfig>) => Serializer<EntityType>;
 declare const createBodySerializer: <EntityType extends DataType = DataType>(config?: Partial<SerializerConfig>) => Serializer<EntityType>;
 declare const createStrictSerializer: <EntityType extends DataType = DataType>(config?: Partial<SerializerConfig>) => Serializer<EntityType>;
 
-type StorageStrategy = 'memory' | 'lru' | 'session' | 'persist';
-type StorageStrategyOptions = {
-    lruLimit?: number;
-};
-
-type StorageInterface<Key, Type> = {
-    prefix?: string;
-    get(key: Key): Type | null;
-    set(key: Key, value: Type): void;
-    remove(key: Key): void;
-    clear(): void;
-    get length(): number;
-};
-
-declare class LruCache<KeyT, ValueT> implements StorageInterface<KeyT, ValueT> {
-    private map;
-    private _limit;
-    constructor(limit?: number);
-    get limit(): number;
-    get length(): number;
-    set limit(value: number);
-    get(key: KeyT): NonNullable<ValueT> | null;
-    set(key: KeyT, value: ValueT): void;
-    remove(key: KeyT): boolean;
-    clear(): void;
-    has(key: KeyT): boolean;
-    keys(): KeyT[];
-    values(): ValueT[];
-    entries(): [KeyT, ValueT][];
-    toArray(): ValueT[];
-    fromArray(entries: [KeyT, ValueT][]): void;
-}
-
-/**
- * Factory for data storage strategies.
- *
- * Returns a `StorageInterface` implementation depending on the selected strategy:
- * - `'memory'`  — in-memory storage (for the session lifetime);
- * - `'session'` — `sessionStorage`, lives until the tab is closed;
- * - `'persist'` — `localStorage`, persists between sessions;
- * - `'lru'`     — size-limited cache (Least Recently Used).
- *
- * Used to choose an appropriate storage implementation
- * depending on the scenario: temporary data, long-term, cache, etc.
- *
- * @param strategy storage strategy type (`memory`, `session`, `persist`, `lru`)
- * @returns instance implementing `StorageInterface<Key, Type>`
- */
-declare const storageStrategy: <Key = string, Type extends AnyType = AnyDict>(strategy: StorageStrategy, options?: StorageStrategyOptions) => StorageInterface<Key, Type>;
-
 /**
  * Object for request body (payload).
  * Commonly used with POST/PUT/PATCH/DELETE.
+  * `FormData`, `Blob`, and `ArrayBuffer` are passed through as-is without serialization.
  */
-type PayloadData = AnyDict;
+type PayloadData = AnyDict | FormData | Blob | ArrayBuffer;
 /**
- * Simple parameters dictionary (string/number).
- * Suitable for path params and query.
+ * Simple path parameters dictionary (string/number).
  */
 type SimpleDict = Record<string, string | number>;
+/**
+ * Query parameters dictionary with scalar and array support.
+ */
+type QueryDict = Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
 /**
  * Resource status in `ResourceStore`:
  * - `idle`    — not loaded yet
@@ -310,6 +43,11 @@ type RetryConfig = {
     attempts?: number;
     delayMs?: number;
     backoff?: RetryBackoff;
+    /**
+     * Add ±25% random jitter to the retry delay to avoid synchronized retries
+     * across multiple clients hitting the same endpoint simultaneously.
+     */
+    jitter?: boolean;
     shouldRetry?: (error: unknown, attempt: number) => boolean;
 };
 /**
@@ -347,6 +85,12 @@ type ResourceStoreOptions = {
     retry?: RetryConfig;
     /** Trace hook for request/cache lifecycle events. */
     onTrace?: (event: ResourceTraceEvent) => void;
+    /**
+     * Side-effect hook called with the full `HttpResponse` for every completed request.
+     * Useful for reading response headers (e.g. `X-Total-Count`, `Link`, correlation IDs).
+     * Errors thrown here are silently swallowed.
+     */
+    onResponse?: (response: HttpResponse<unknown>) => void;
     serializer?: Partial<SerializerConfig>;
 };
 /**
@@ -355,7 +99,7 @@ type ResourceStoreOptions = {
  * - `query`   — query string parameters
  * - `payload` — request body (for mutations)
  */
-type CallArgs<Params extends SimpleDict = SimpleDict, Query extends SimpleDict = SimpleDict, Payload extends PayloadData = PayloadData> = {
+type CallArgs<Params extends SimpleDict = SimpleDict, Query extends QueryDict = QueryDict, Payload extends PayloadData = PayloadData> = {
     params?: Params;
     query?: Query;
     payload?: Payload;
@@ -385,6 +129,12 @@ type CallConfig<Response, Type> = {
      * - 'arraybuffer' - response as an ArrayBuffer
      */
     responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+    /**
+     * Controls what is passed to `parseResponse`:
+     * - `'body'` (default) — receives the response body (`Response`)
+     * - `'response'` — receives the full `HttpResponse<Response>` (headers, status, body)
+     */
+    observe?: 'body' | 'response';
     /**
      * Custom response parser.
      * Allows converting server `Response` to the domain type `Type`.
@@ -481,7 +231,7 @@ declare class ResourceStore<Data> {
      * @param cfg  Call settings (strategy, ttlMs, revalidate, parseResponse, delay, delayMode, dedupe, promote)
      * @returns Deserialized `Data`
      */
-    get<Param extends SimpleDict = SimpleDict, Query extends PayloadData = PayloadData, Response extends AnyType = Data>(args: CallArgs<Param, Query, never>, cfg?: GetCallConfig<Response, Data>): Promise<Data>;
+    get<Param extends SimpleDict = SimpleDict, Query extends QueryDict = QueryDict, Response extends AnyType = Data>(args: CallArgs<Param, Query, never>, cfg?: GetCallConfig<Response, Data>): Promise<Data>;
     /**
      * POST request.
      *
@@ -489,7 +239,7 @@ declare class ResourceStore<Data> {
      * @param cfg  Call settings (parseResponse, delay, delayMode, dedupe, promote)
      * @returns API response (by default — as returned by the server)
      */
-    post<Param extends SimpleDict = SimpleDict, Payload extends PayloadData = PayloadData, Query extends PayloadData = PayloadData, Response extends AnyType = AnyType>(args: CallArgs<Param, Query, Payload>, cfg?: CallConfig<Response, Response>): Promise<Response>;
+    post<Param extends SimpleDict = SimpleDict, Payload extends PayloadData = PayloadData, Query extends QueryDict = QueryDict, Response extends AnyType = AnyType>(args: CallArgs<Param, Query, Payload>, cfg?: CallConfig<Response, Response>): Promise<Response>;
     /**
      * PUT request (full resource update).
      *
@@ -497,7 +247,7 @@ declare class ResourceStore<Data> {
      * @param cfg  Call settings (parseResponse, delay, delayMode, dedupe, promote)
      * @returns API response (by default — as returned by the server)
      */
-    put<Param extends SimpleDict = SimpleDict, Payload extends PayloadData = PayloadData, Query extends SimpleDict = SimpleDict, Response extends AnyType = AnyType>(args: CallArgs<Param, Query, Partial<Payload>>, cfg?: CallConfig<Response, Response>): Promise<Response>;
+    put<Param extends SimpleDict = SimpleDict, Payload extends PayloadData = PayloadData, Query extends QueryDict = QueryDict, Response extends AnyType = AnyType>(args: CallArgs<Param, Query, Partial<Payload>>, cfg?: CallConfig<Response, Response>): Promise<Response>;
     /**
      * PATCH request (partial update).
      *
@@ -505,7 +255,7 @@ declare class ResourceStore<Data> {
      * @param cfg  Call settings (parseResponse, delay, delayMode, dedupe, promote)
      * @returns API response (by default — as returned by the server)
      */
-    patch<Param extends SimpleDict = SimpleDict, Payload extends PayloadData = PayloadData, Query extends SimpleDict = SimpleDict, Response extends AnyType = AnyType>(args: CallArgs<Param, Query, Partial<Payload>>, cfg?: CallConfig<Response, Response>): Promise<Response>;
+    patch<Param extends SimpleDict = SimpleDict, Payload extends PayloadData = PayloadData, Query extends QueryDict = QueryDict, Response extends AnyType = AnyType>(args: CallArgs<Param, Query, Partial<Payload>>, cfg?: CallConfig<Response, Response>): Promise<Response>;
     /**
      * DELETE request.
      *
@@ -513,7 +263,7 @@ declare class ResourceStore<Data> {
      * @param cfg  Call settings (parseResponse, delay, delayMode, dedupe, promote)
      * @returns API response (by default — as returned by the server)
      */
-    delete<Param extends SimpleDict = SimpleDict, Payload extends PayloadData = PayloadData, Query extends SimpleDict = SimpleDict, Response extends AnyType = AnyType>(args: CallArgs<Param, Query, Payload>, cfg?: CallConfig<Response, Response>): Promise<Response>;
+    delete<Param extends SimpleDict = SimpleDict, Payload extends PayloadData = PayloadData, Query extends QueryDict = QueryDict, Response extends AnyType = AnyType>(args: CallArgs<Param, Query, Payload>, cfg?: CallConfig<Response, Response>): Promise<Response>;
     /**
      * Cancel scheduled/running requests for a specific call.
      *
@@ -521,7 +271,7 @@ declare class ResourceStore<Data> {
      * @param args   Arguments used to build the URL (params, query)
      * @param reason Cancellation reason (optional)
      */
-    abort<Param extends SimpleDict = SimpleDict, Query extends PayloadData = PayloadData>(method: RestMethods, args: CallArgs<Param, Query>, reason?: string | Error): void;
+    abort<Param extends SimpleDict = SimpleDict, Query extends QueryDict = QueryDict>(method: RestMethods, args: CallArgs<Param, Query>, reason?: string | Error): void;
     /**
      * Cancel all scheduled/running requests for this store.
      *
@@ -645,13 +395,16 @@ type SetRouteParamsOptions = {
     abort?: boolean;
 };
 
+type BivariantCallback<Args, Return> = {
+    bivarianceHack(data: Args): Return;
+}['bivarianceHack'];
 /**
  * Configuration for the paginated data store.
  *
  * Controls request method, page cache, debounce delay, concurrency policy, and
  * request/response transformations.
  */
-type PagedQueryStoreConfig<ItemsType extends object, FilterType = unknown> = {
+type PagedQueryStoreConfig<ItemsType extends object, FilterType extends AnyDict = AnyDict> = {
     /** Optional base URL prepended to the route before the request is sent. */
     baseUrl?: string;
     /** Transport HTTP method: `GET`/`POST`/`PATCH`/`PUT`/`DELETE`. Defaults to global config or `POST`. */
@@ -666,9 +419,9 @@ type PagedQueryStoreConfig<ItemsType extends object, FilterType = unknown> = {
     debounceTime?: number;
     /** Concurrency policy for overlapping requests. Defaults to `latest-wins`. */
     concurrency?: PagedQueryConcurrency;
-    /** Initial pagination params. `page` is required. */
+    /** Initial pagination params. Omitted `page` defaults to `0`. */
     presetQuery?: {
-        page: number;
+        page?: number;
         pageSize?: number;
     };
     /** Initial filters. Will be sent with the first request. */
@@ -680,7 +433,7 @@ type PagedQueryStoreConfig<ItemsType extends object, FilterType = unknown> = {
      * Useful for mapping `page/pageSize` and selected filter fields to API-specific query keys.
      * Returned object can contain nullable values; they are filtered before the transport call.
      */
-    parseRequest?: (data: PageableRequest & Partial<FilterType> & AnyDict) => AnyDict;
+    parseRequest?: BivariantCallback<PageableRequest & Partial<FilterType> & AnyDict, AnyDict>;
     /**
      * Custom parser of API response into unified `PageableResponse<ItemsType>`.
      * Use if the server returns an array or a non-standard structure.
@@ -733,7 +486,7 @@ type PagedQueryStoreProviderConfig = {
  * effect(() => console.log(ds.items(), ds.loading()));
  * ```
  */
-declare class PagedQueryStore<ItemsType extends AnyDict, FilterType = AnyDict> {
+declare class PagedQueryStore<ItemsType extends AnyDict, FilterType extends AnyDict = AnyDict> {
     #private;
     private route;
     config: PagedQueryStoreConfig<ItemsType, FilterType>;
@@ -774,29 +527,10 @@ declare class PagedQueryStore<ItemsType extends AnyDict, FilterType = AnyDict> {
     get totalElements(): number;
     /** Current sort rules. */
     get sort(): QuerySortRule[];
-    /**
-     * @deprecated Prefer `fetch(...)`, `refetchWith(...)`, or a dedicated setter method.
-     * Direct state mutation bypasses request semantics and should be treated as legacy.
-     */
     set filters(value: Partial<FilterType>);
-    /**
-     * @deprecated Prefer `fetch(...)`, `refetchWith(...)`, or a dedicated setter method.
-     * Direct state mutation bypasses request semantics and should be treated as legacy.
-     */
     set query(value: AnyDict);
-    /**
-     * @deprecated Prefer `updatePage(...)`, `fetch(...)`, or `refetchWith(...)`.
-     * Direct state mutation bypasses request semantics and should be treated as legacy.
-     */
     set page(value: number);
-    /**
-     * @deprecated Prefer `updatePageSize(...)`.
-     * Direct state mutation bypasses request semantics and should be treated as legacy.
-     */
     set pageSize(value: number);
-    /**
-     * @deprecated Managed by transport responses. Direct assignment should be treated as legacy.
-     */
     set totalElements(value: number);
     /**
      * Fetch data with explicit filters and query params from the first page.
@@ -1215,6 +949,6 @@ type StatumConfig = PagedQueryProviderConfig & SerializerProviderConfig & DictPr
 declare const STATUM_CONFIG: InjectionToken<StatumConfig>;
 declare const provideStatum: (config: StatumConfig) => EnvironmentProviders;
 
-export { AbortError, CacheMissError, DictLocalStore, DictStore, EntityStore, LruCache, PagedQueryStore, RESOURCE_PROFILES, ResourceStore, STATUM_CONFIG, Serializer, SerializerFieldError, createBodySerializer, createQuerySerializer, createResourceProfile, createStrictSerializer, isAbort, provideStatum, storageStrategy };
-export type { DataType, DictLocalConfig, DictStoreConfig, DictStoreProviderConfig, EntityId, EntityStoreConfig, FetchInput, FetchParams, FieldConfig, OffsetPaginationType, PagedQueryStoreConfig, PagedQueryStoreProviderConfig, QuerySortInput, QuerySortOrder, QuerySortRule, RefetchWithInput, ResourceProfileName, ResourceRoutesMap, ResourceStatus, ResourceStoreOptions, ResourceTraceEvent, RetryConfig, SerializedType, SerializerConfig, SetRouteParamsOptions, StatumConfig, StorageInterface, StorageStrategy, StorageStrategyOptions, Types, UpdateByOffsetOptions, UpdatePageInput, UpdatePageOptions };
+export { AbortError, CacheMissError, DictLocalStore, DictStore, EntityStore, PagedQueryStore, RESOURCE_PROFILES, ResourceStore, STATUM_CONFIG, createBodySerializer, createQuerySerializer, createResourceProfile, createStrictSerializer, isAbort, provideStatum };
+export type { DictLocalConfig, DictStoreConfig, DictStoreProviderConfig, EntityId, EntityStoreConfig, FetchInput, FetchParams, OffsetPaginationType, PagedQueryStoreConfig, PagedQueryStoreProviderConfig, QuerySortInput, QuerySortOrder, QuerySortRule, RefetchWithInput, ResourceProfileName, ResourceRoutesMap, ResourceStatus, ResourceStoreOptions, ResourceTraceEvent, RetryConfig, SetRouteParamsOptions, StatumConfig, UpdateByOffsetOptions, UpdatePageInput, UpdatePageOptions };
 //# sourceMappingURL=reforgium-statum.d.ts.map