@reforgium/internal 1.3.0 → 2.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 rtommievich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -5,8 +5,28 @@
 
 Shared infrastructure package for Reforgium Angular libraries.
 
+`internal` is being tightened into a foundation layer. The target boundary is documented in
+[INTERNAL_V2.md](./INTERNAL_V2.md).
+
+The first classification pass is documented in
+[INTERNAL_V2_AUDIT.md](./INTERNAL_V2_AUDIT.md).
+
+The file-by-file pass is documented in
+[INTERNAL_V2_FILE_AUDIT.md](./INTERNAL_V2_FILE_AUDIT.md).
+
+Short version:
+
+- foundation primitives belong here
+- feature semantics do not
+- legacy compatibility for `angular-common-kit` does not
+
+`@reforgium/internal` is infrastructure for Reforgium packages and is not intended as a user-facing product package.
+
 ## Install
 
+`internal` is primarily consumed transitively by other `@reforgium/*` packages.
+Direct installation is possible for workspace and low-level internal use, but it is not the recommended first entrypoint for app code.
+
 ```bash
 npm i @reforgium/internal
 ```
@@ -16,6 +36,8 @@ npm i @reforgium/internal
 `@reforgium/internal` exports:
 
 - `models`
+- `codecs`
+- `storage`
 - `tokens`
 - `utils`
 
@@ -23,11 +45,40 @@ npm i @reforgium/internal
 
 Main model groups:
 
-- `api.ts`: `RestMethods`, `SortToken`, `PageableRequest`, `PageableResponse<T>`, `ErrorResponse`, `QueryParams`, `Query`
-- `components.ts`: `Appearance`, `SelectOption`, `SelectIconOption`
+- `query.models.ts`: `SortToken`, `SortDirection`, `SortRule`, `SortInput`, `QueryArrayMode`, `QueryFieldModes`, `QueryParams`, `Query`
+- `transport.models.ts`: `RestMethods`, `PageableRequest`, `PageableResponse<T>`, `ErrorResponse`
 - `elements.ts`: `Direction`, `ElementRect`, `ElementSize`, `ElementPosition`, `ElementEdges`
 - `util.ts`: `AnyType`, `AnyDict`, `LiteralOf`, `ValueOf`, `Nullable`, `Nullish`, `NullableProps`, `OptionalExcept`, `RequiredExcept`, `Mutable`, JSON helper types
 
+Compatibility-only model surface:
+
+- `components.ts`: `Appearance`, `SelectOption`, `SelectIconOption`
+- `api.ts`: deprecated mixed facade kept for compatibility; prefer explicit query and transport types
+
+### Codecs
+
+Main codec exports:
+
+- `Serializer`
+- `SerializerFieldError`
+- `SerializerConfig`
+- `FieldConfig`
+- `SerializedType`
+
+These are shared bidirectional transform primitives used by `statum` and `regula`.
+
+### Storage
+
+Main storage exports:
+
+- `StorageInterface`
+- `StorageStrategy`, `StorageStrategyOptions`
+- `MemoryStorage`
+- `LocalStorage`
+- `SessionStorage`
+- `LruCache`
+- `storageStrategy(...)`
+
 ### Tokens
 
 Language tokens:
@@ -44,7 +95,8 @@ Theme/device/validation tokens:
 
 - `SELECTED_THEME`, `CHANGE_THEME`, `Themes`
 - `CURRENT_DEVICE`, `Devices`
-- `VALIDATION_MESSAGES`, `ValidationMessages`, `ValidationErrorData`
+- `VALIDATION_MESSAGES`, `ValidationMessages`, `ValidationErrorData`:
+  compatibility-only legacy validation token surface
 
 Example:
 
@@ -134,6 +186,39 @@ makeQuery({ ids: [1, 2, 3], q: 'ok' }, 'multi');
 // ids=1&ids=2&ids=3&q=ok
 ```
 
+`storage` example:
+
+```ts
+import { LruCache, storageStrategy } from '@reforgium/internal';
+
+const pages = new LruCache<number, string[]>(5);
+pages.set(1, ['a', 'b']);
+
+const persisted = storageStrategy<string, { updatedAt: number }>('persist');
+persisted.set('users', { updatedAt: Date.now() });
+```
+
+`codecs` example:
+
+```ts
+import { Serializer } from '@reforgium/internal';
+
+const serializer = new Serializer<{
+  search: string;
+  createdAt: Date;
+}>({
+  mapFields: {
+    createdAt: { type: 'date' },
+  },
+});
+
+serializer.serialize({
+  search: '  regula  ',
+  createdAt: new Date('2026-04-04'),
+});
+// { search: 'regula', createdAt: '2026-04-04' }
+```
+
 ## License
 
 MIT

package/fesm2022/reforgium-internal.mjs

@@ -1,5 +1,179 @@
 import { InjectionToken, makeEnvironmentProviders, signal, effect, untracked } from '@angular/core';
 
+class LocalStorage {
+    prefix;
+    constructor(prefix = 're') {
+        this.prefix = prefix;
+    }
+    get length() {
+        return Object.keys(localStorage).filter((key) => key.startsWith(this.safePrefix())).length;
+    }
+    get(key) {
+        const storageKey = this.getSafePrefix(key);
+        const raw = localStorage.getItem(storageKey);
+        if (raw == null) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            return parsed ?? null;
+        }
+        catch {
+            localStorage.removeItem(storageKey);
+            return null;
+        }
+    }
+    set(key, value) {
+        localStorage.setItem(this.getSafePrefix(key), JSON.stringify(value));
+    }
+    remove(key) {
+        localStorage.removeItem(this.getSafePrefix(key));
+    }
+    clear() {
+        const keys = Object.keys(localStorage).filter((key) => key.startsWith(this.safePrefix()));
+        keys.forEach((key) => localStorage.removeItem(key));
+    }
+    getSafePrefix(key) {
+        return this.prefix ? `${this.prefix}:${key}` : String(key);
+    }
+    safePrefix() {
+        return this.prefix ? `${this.prefix}:` : '';
+    }
+}
+
+class LruCache {
+    map = new Map();
+    _limit = 100;
+    constructor(limit = 100) {
+        this.limit = limit;
+    }
+    get limit() {
+        return this._limit;
+    }
+    get length() {
+        return this.map.size;
+    }
+    set limit(value) {
+        this._limit = Math.max(1, Math.floor(value || 0));
+    }
+    get(key) {
+        if (!this.map.has(key)) {
+            return null;
+        }
+        const val = this.map.get(key);
+        this.map.delete(key);
+        this.map.set(key, val);
+        return val;
+    }
+    set(key, value) {
+        if (this.map.has(key)) {
+            this.map.delete(key);
+        }
+        else if (this.map.size >= this.limit) {
+            const oldest = this.map.keys().next().value;
+            oldest !== undefined && this.map.delete(oldest);
+        }
+        this.map.set(key, value);
+    }
+    remove(key) {
+        return this.map.delete(key);
+    }
+    clear() {
+        this.map.clear();
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    keys() {
+        return Array.from(this.map.keys());
+    }
+    values() {
+        return Array.from(this.map.values());
+    }
+    entries() {
+        return Array.from(this.map.entries());
+    }
+    toArray() {
+        return Array.from(this.map.values());
+    }
+    fromArray(entries) {
+        this.map.clear();
+        for (const [k, v] of entries) {
+            this.set(k, v);
+        }
+    }
+}
+
+class MemoryStorage {
+    cache = new Map();
+    get length() {
+        return this.cache.size;
+    }
+    get(key) {
+        return this.cache.get(key) ?? null;
+    }
+    set(key, value) {
+        this.cache.set(key, value);
+    }
+    remove(key) {
+        this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+
+class SessionStorage {
+    prefix;
+    constructor(prefix = 're') {
+        this.prefix = prefix;
+    }
+    get length() {
+        return Object.keys(sessionStorage).filter((key) => key.startsWith(this.safePrefix())).length;
+    }
+    get(key) {
+        const storageKey = this.getSafePrefix(key);
+        const raw = sessionStorage.getItem(storageKey);
+        if (raw == null) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            return parsed ?? null;
+        }
+        catch {
+            sessionStorage.removeItem(storageKey);
+            return null;
+        }
+    }
+    set(key, value) {
+        sessionStorage.setItem(this.getSafePrefix(key), JSON.stringify(value));
+    }
+    remove(key) {
+        sessionStorage.removeItem(this.getSafePrefix(key));
+    }
+    clear() {
+        const keys = Object.keys(sessionStorage).filter((key) => key.startsWith(this.safePrefix()));
+        keys.forEach((key) => sessionStorage.removeItem(key));
+    }
+    getSafePrefix(key) {
+        return this.prefix ? `${this.prefix}:${key}` : String(key);
+    }
+    safePrefix() {
+        return this.prefix ? `${this.prefix}:` : '';
+    }
+}
+
+const storageStrategy = (strategy, options = {}) => {
+    const fabrics = {
+        memory: () => new MemoryStorage(),
+        session: () => new SessionStorage(),
+        persist: () => new LocalStorage(),
+        lru: () => new LruCache(options.lruLimit ?? 100),
+    };
+    return fabrics[strategy]();
+};
+
 /**
  * Built-in languages always available in the registry.
  */
@@ -73,27 +247,18 @@ const CHANGE_THEME = new InjectionToken('RE_CHANGE_THEME');
 const CURRENT_DEVICE = new InjectionToken('RE_CURRENT_DEVICE');
 
 /**
- * Injection token for a validation messages map.
- * Can be overridden in feature modules to provide custom validation messages.
- * Defaults to an empty object when not provided.
- *
- * @example
- * // In a feature module:
- * providers: [
- *   {
- *     provide: VALIDATION_MESSAGES,
- *     useValue: {
- *       required: () => 'This field is required',
- *       minlength: (error) => `Min length: ${error.requiredLength}`
- *     }
- *   }
- * ]
+ * Legacy validation messages token.
  */
 const VALIDATION_MESSAGES = new InjectionToken('RE_VALIDATION_MESSAGES', {
     providedIn: 'root',
     factory: () => ({}),
 });
 
+/**
+ * @deprecated Legacy validation token surface is being isolated from the `internal v2`
+ * foundation boundary. Do not add new consumers here.
+ */
+
 /**
  * Browser-only helper that downloads a file from a Blob object and prompts the user to save it.
  *
@@ -207,7 +372,7 @@ function base64ToBlob(base64, mimeType = '') {
  * ```
  */
 const debounceSignal = (src, ms = 150, opts) => {
-    const out = signal(src(), ...(ngDevMode ? [{ debugName: "out" }] : []));
+    const out = signal(src(), ...(ngDevMode ? [{ debugName: "out" }] : /* istanbul ignore next */ []));
     let timeoutRef;
     effect((onCleanup) => {
         const v = src();
@@ -246,7 +411,7 @@ const debounceSignal = (src, ms = 150, opts) => {
  * ```
  */
 const throttleSignal = (src, ms = 100, opts) => {
-    const out = signal(src(), ...(ngDevMode ? [{ debugName: "out" }] : []));
+    const out = signal(src(), ...(ngDevMode ? [{ debugName: "out" }] : /* istanbul ignore next */ []));
     let last = 0;
     let queued;
     let timeoutRef;
@@ -305,6 +470,9 @@ const pad = (n) => n.toString().padStart(2, '0');
  * @returns {string} Formatted date string. Returns an empty string if the input date is invalid.
  */
 const formatDate = (date, format = 'yyyy-MM-dd') => {
+    if (!date) {
+        return '';
+    }
     if (isNaN(date['getTime']?.())) {
         return '';
     }
@@ -565,7 +733,7 @@ const concatArray = (value, mode, key) => {
  * if the input is invalid.
  */
 function formatToSpacedNumber(num) {
-    const stringed = String(num).replaceAll(' ', '');
+    const stringed = String(num).replace(/ /g, '');
     if (num === null || num === undefined || Number.isNaN(+stringed)) {
         return '';
     }
@@ -1111,9 +1279,308 @@ const generateId = (limit = 15, radix = 36) => Math.random()
     .toString(radix)
     .substring(2, limit + 2);
 
+const serializeString = (config, value) => config.mapString.format?.(value) ?? (config.mapString.trim ? value.trim() : value);
+const serializeNumber = (config, value) => config.mapNumber.format?.(value) ?? Number(value);
+const serializeBoolean = (config, value) => config.mapBoolean.format?.(value) ?? (value ? (config.mapBoolean.true ?? true) : (config.mapBoolean.false ?? false));
+const serializeDate = (config, value) => config.mapDate.format?.(value) ?? formatDate(value, config.mapDate.dateFormat);
+
+const getTypedField = (field) => {
+    return field && 'type' in field ? field : undefined;
+};
+class SerializerFieldError extends Error {
+    field;
+    stage;
+    originalError;
+    constructor(field, stage, originalError) {
+        const originalMessage = originalError instanceof Error ? originalError.message : String(originalError);
+        super(`Serializer ${stage} error for field "${field}": ${originalMessage}`);
+        this.field = field;
+        this.stage = stage;
+        this.originalError = originalError;
+        this.name = 'SerializerFieldError';
+    }
+}
+class Serializer {
+    config;
+    constructor(config = {}) {
+        this.config = this.mergeConfig({
+            mapString: { trim: true },
+            mapNumber: { fromString: false },
+            mapBoolean: {},
+            mapArray: { concatType: 'comma' },
+            mapObject: { deep: true },
+            mapDate: { dateFormat: 'yyyy-MM-dd' },
+            mapPeriod: {
+                dateFormat: 'yyyy-MM-dd',
+                transformMode: { mode: 'split', dateFromKeyPostfix: 'From', dateToKeyPostfix: 'To' },
+            },
+            mapNullable: { remove: true, includeEmptyString: false },
+        }, config);
+    }
+    serialize(obj, _seen = new WeakSet()) {
+        const result = {};
+        if (obj != null && typeof obj === 'object') {
+            _seen.add(obj);
+        }
+        for (const [key, value] of Object.entries(obj ?? {})) {
+            const fields = this.config.mapFields?.[key];
+            const typedField = getTypedField(fields);
+            if (fields && 'format' in fields) {
+                try {
+                    result[key] = fields.format(value, obj);
+                }
+                catch (error) {
+                    throw new SerializerFieldError(key, 'format', error);
+                }
+                continue;
+            }
+            if (typedField?.type === 'nullable' || isNullable(value, this.config.mapNullable?.includeEmptyString)) {
+                if (this.config.mapNullable.remove) {
+                    continue;
+                }
+            }
+            if (typedField?.type === 'period' || isDatePeriod(value)) {
+                const transform = this.config.mapPeriod.transformMode;
+                const [from, to] = value;
+                if (transform?.mode === 'split') {
+                    result[`${key}${transform.dateFromKeyPostfix}`] = formatDate(from, this.config.mapPeriod.dateFormat);
+                    result[`${key}${transform.dateToKeyPostfix}`] = formatDate(to, this.config.mapPeriod.dateFormat);
+                    continue;
+                }
+            }
+            result[key] = this.serializeElement(value, key, _seen);
+        }
+        if (obj != null && typeof obj === 'object') {
+            _seen.delete(obj);
+        }
+        return result;
+    }
+    deserialize = (val) => {
+        const data = typeof val === 'string' ? this.parseInputString(val) : val;
+        const result = {};
+        for (const [key, value] of Object.entries(data ?? {})) {
+            const field = this.config.mapFields?.[key];
+            const typedField = getTypedField(field);
+            if (field && 'parse' in field) {
+                try {
+                    result[key] = field.parse(value, data);
+                }
+                catch (error) {
+                    throw new SerializerFieldError(key, 'parse', error);
+                }
+                continue;
+            }
+            if (typedField?.type === 'nullable' ||
+                (typedField?.type !== 'array' && isNullable(value, this.config.mapNullable?.includeEmptyString))) {
+                if (this.config.mapNullable.remove) {
+                    continue;
+                }
+            }
+            const periodTransform = this.config.mapPeriod.transformMode;
+            if (periodTransform.mode === 'split') {
+                const isFrom = (key || '').endsWith(periodTransform.dateFromKeyPostfix);
+                const isTo = (key || '').endsWith(periodTransform.dateToKeyPostfix);
+                const keyJoint = (key || '')
+                    .replace(periodTransform.dateFromKeyPostfix, '')
+                    .replace(periodTransform.dateToKeyPostfix, '');
+                const jointField = this.config.mapFields?.[keyJoint];
+                const fieldType = jointField && 'type' in jointField ? jointField.type : undefined;
+                if (fieldType === 'period' && (isFrom || isTo)) {
+                    result[keyJoint] ??= [null, null];
+                    if (isFrom) {
+                        result[keyJoint][0] = parseToDate(value, this.config.mapPeriod.dateFormat);
+                    }
+                    else if (isTo) {
+                        result[keyJoint][1] = parseToDate(value, this.config.mapPeriod.dateFormat);
+                    }
+                    continue;
+                }
+            }
+            result[key] = this.deserializeElement(value, key);
+        }
+        return result;
+    };
+    deserializeQuery = (query) => {
+        return this.deserialize(this.parseQuery(query));
+    };
+    deserializeJson = (json) => {
+        return this.deserialize(this.parseJsonObject(json));
+    };
+    toQuery = (val) => {
+        return buildQueryParams(this.serialize(val), this.config.mapArray.concatType, this.resolveArrayFieldModes());
+    };
+    withConfig(config) {
+        return new Serializer(this.mergeConfig(this.config, config));
+    }
+    serializeElement(value, key, _seen = new WeakSet()) {
+        const fields = this.config.mapFields?.[key || ''];
+        const typedField = getTypedField(fields);
+        if (fields && 'format' in fields) {
+            return;
+        }
+        if (typedField?.type === 'nullable' || isNullable(value, this.config.mapNullable?.includeEmptyString)) {
+            const nullableVal = value ?? null;
+            return this.config.mapNullable.format?.(nullableVal) || this.config.mapNullable.replaceWith || nullableVal;
+        }
+        if (typedField?.type === 'string') {
+            return serializeString(this.config, value);
+        }
+        if (typedField?.type === 'number' || isNumber(value, this.config.mapNumber.fromString)) {
+            return serializeNumber(this.config, value);
+        }
+        if (typeof value === 'string') {
+            return serializeString(this.config, value);
+        }
+        if (typedField?.type === 'boolean' || typeof value === 'boolean') {
+            return serializeBoolean(this.config, value);
+        }
+        if (typedField?.type === 'date' || value instanceof Date) {
+            return serializeDate(this.config, value);
+        }
+        if (typedField?.type === 'period' || isDatePeriod(value)) {
+            const mapPeriod = this.config.mapPeriod;
+            if (mapPeriod.format) {
+                return mapPeriod.format(value);
+            }
+            const [from, to] = value;
+            const transform = mapPeriod.transformMode;
+            if (transform.mode === 'join') {
+                const period = [
+                    formatDate(from, this.config.mapPeriod.dateFormat),
+                    formatDate(to, this.config.mapPeriod.dateFormat),
+                ];
+                return period.join(transform.concat);
+            }
+        }
+        if (typedField?.type === 'array' || Array.isArray(value)) {
+            return value.map((it) => this.serializeElement(it, undefined, _seen));
+        }
+        if (typedField?.type === 'object' || isObject(value)) {
+            if (this.config.mapObject.deep && !this.config.mapObject.format && value != null && _seen.has(value)) {
+                return undefined;
+            }
+            return (this.config.mapObject.format?.(value) ??
+                (this.config.mapObject.deep ? this.serialize(value, _seen) : JSON.stringify(value)));
+        }
+    }
+    deserializeElement(value, key) {
+        const field = this.config.mapFields?.[key || ''];
+        const typedField = getTypedField(field);
+        if (field && 'format' in field) {
+            return;
+        }
+        if (typedField?.type === 'array' || Array.isArray(value)) {
+            const array = Array.isArray(value) ? value : [value];
+            if (this.config.mapArray.removeNullable) {
+                if (!isNullable(value, this.config.mapNullable?.includeEmptyString)) {
+                    return array.map((it) => this.deserializeElement(it));
+                }
+                return;
+            }
+            return !value ? [] : array.map((it) => this.deserializeElement(it));
+        }
+        if (typedField?.type === 'object') {
+            try {
+                if (this.config.mapObject.deep) {
+                    return isObject(value) ? this.deserialize(value) : value;
+                }
+                return typeof value === 'string' ? JSON.parse(value) : value;
+            }
+            catch {
+                return value;
+            }
+        }
+        if (typedField?.type === 'nullable' || isNullable(value, this.config.mapNullable?.includeEmptyString)) {
+            return this.config.mapNullable.parse?.(value) || value;
+        }
+        if (typedField?.type === 'boolean' ||
+            typeof value === 'boolean' ||
+            value === this.config.mapBoolean.true ||
+            value === this.config.mapBoolean.false) {
+            return this.config.mapBoolean.parse?.(value) ?? (value === this.config.mapBoolean.true || value === true);
+        }
+        const maybeDate = parseToDate(value, this.config.mapDate.dateFormat);
+        if (typedField?.type === 'date' || maybeDate) {
+            return this.config.mapDate.parse?.(value) || maybeDate;
+        }
+        const periodTransform = this.config.mapPeriod.transformMode;
+        if (periodTransform.mode === 'join') {
+            const maybePeriod = parseToDatePeriod(value, this.config.mapPeriod.dateFormat);
+            if (typedField?.type === 'period' || (maybePeriod || []).some(Boolean)) {
+                return this.config.mapPeriod.parse?.(value) || maybePeriod;
+            }
+        }
+        if (typedField?.type === 'number' || isNumber(value, this.config.mapNumber.fromString)) {
+            return this.config.mapNumber.parse?.(value) || Number(String(value).trim());
+        }
+        if (typedField?.type === 'string' || typeof value === 'string') {
+            const parsed = this.config.mapString.parse?.(value);
+            if (parsed !== undefined) {
+                return parsed;
+            }
+            return this.config.mapString.trim ? String(value).trim() : value;
+        }
+        return value;
+    }
+    parseQuery(val) {
+        return parseQueryParamsByMode(val, undefined, this.resolveArrayFieldModes());
+    }
+    parseJsonObject(val) {
+        try {
+            const parsed = JSON.parse(val);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON input: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        throw new Error('Invalid JSON input: expected a JSON object');
+    }
+    parseInputString(val) {
+        try {
+            return this.parseJsonObject(val);
+        }
+        catch {
+            return this.parseQuery(val);
+        }
+    }
+    mergeConfig(base, override) {
+        return {
+            ...base,
+            ...override,
+            mapString: { ...base.mapString, ...override.mapString },
+            mapNumber: { ...base.mapNumber, ...override.mapNumber },
+            mapBoolean: { ...base.mapBoolean, ...override.mapBoolean },
+            mapDate: { ...base.mapDate, ...override.mapDate },
+            mapPeriod: {
+                ...base.mapPeriod,
+                ...override.mapPeriod,
+                transformMode: {
+                    ...base.mapPeriod.transformMode,
+                    ...override.mapPeriod?.transformMode,
+                },
+            },
+            mapNullable: { ...base.mapNullable, ...override.mapNullable },
+            mapArray: { ...base.mapArray, ...override.mapArray },
+            mapObject: { ...base.mapObject, ...override.mapObject },
+            mapFields: { ...(base.mapFields || {}), ...(override.mapFields || {}) },
+        };
+    }
+    resolveArrayFieldModes() {
+        const result = {};
+        Object.entries(this.config.mapFields || {}).forEach(([key, field]) => {
+            if ('type' in field && field.type === 'array') {
+                result[key] = field.concatType ?? this.config.mapArray.concatType;
+            }
+        });
+        return result;
+    }
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { BUILTIN_LANGS, CHANGE_LANG, CHANGE_THEME, CURRENT_DEVICE, REGISTER_LANG, SELECTED_LANG, SELECTED_THEME, TRANSLATION, VALIDATION_MESSAGES, appendQueryParams, appendQueryParamsByMode, base64ToBlob, buildQueryParams, compareRoutes, concatArray, copyText, debounceSignal, deepEqual, downloadByBlob, downloadByUrl, fillUrlWithParams, formatDate, formatToLocaledDate, formatToSpacedNumber, generateId, getAvailableHeight, getChainedValue, getCorrectedPosition, isDatePeriod, isNullable, isNumber, isObject, makeQuery, materializeRoutePath, mergeQueryParams, normalizeSortInput, normalizeUrl, parseQueryArray, parseQueryParams, parseQueryParamsByMode, parseSortToken, parseToDate, parseToDatePeriod, provideLangs, reformatDateToISO, sortInputToTokens, sortRuleToToken, throttleSignal, toDate, toSortToken, truncate };
+export { BUILTIN_LANGS, CHANGE_LANG, CHANGE_THEME, CURRENT_DEVICE, LocalStorage, LruCache, MemoryStorage, REGISTER_LANG, SELECTED_LANG, SELECTED_THEME, Serializer, SerializerFieldError, SessionStorage, TRANSLATION, VALIDATION_MESSAGES, appendQueryParams, appendQueryParamsByMode, base64ToBlob, buildQueryParams, compareRoutes, concatArray, copyText, debounceSignal, deepEqual, downloadByBlob, downloadByUrl, fillUrlWithParams, formatDate, formatToLocaledDate, formatToSpacedNumber, generateId, getAvailableHeight, getChainedValue, getCorrectedPosition, isDatePeriod, isNullable, isNumber, isObject, makeQuery, materializeRoutePath, mergeQueryParams, normalizeSortInput, normalizeUrl, parseQueryArray, parseQueryParams, parseQueryParamsByMode, parseSortToken, parseToDate, parseToDatePeriod, provideLangs, reformatDateToISO, sortInputToTokens, sortRuleToToken, storageStrategy, throttleSignal, toDate, toSortToken, truncate };
 //# sourceMappingURL=reforgium-internal.mjs.map

package/package.json

@@ -1,7 +1,7 @@
 {
-  "version": "1.3.0",
+  "version": "2.0.2",
   "name": "@reforgium/internal",
-  "description": "reforgium Libs Internal package. Shared libs models and tokens.",
+  "description": "Hidden Reforgium foundation package for shared primitives, tokens, and infrastructure.",
   "author": "rtommievich",
   "license": "MIT",
   "type": "module",
@@ -21,12 +21,11 @@
   },
   "keywords": [
     "reforgium",
-    "common",
     "internal",
-    "angular",
-    "signal"
+    "foundation",
+    "infrastructure"
   ],
-  "types": "../../dist/@reforgium/internal/types/reforgium-internal.d.ts",
+  "types": "./src/public-api.ts",
   "typings": "types/reforgium-internal.d.ts",
   "module": "fesm2022/reforgium-internal.mjs",
   "files": [
@@ -37,12 +36,6 @@
     "CHANGELOG.md",
     "LICENSE*"
   ],
-  "dependencies": {
-    "tslib": "^2.8.1"
-  },
-  "peerDependencies": {
-    "@angular/core": ">=19.0.0"
-  },
   "exports": {
     "./package.json": {
       "default": "./package.json"
@@ -51,5 +44,11 @@
       "types": "./types/reforgium-internal.d.ts",
       "default": "./fesm2022/reforgium-internal.mjs"
     }
+  },
+  "dependencies": {
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "@angular/core": ">=19.0.0"
   }
 }

package/types/reforgium-internal.d.ts

@@ -1,64 +1,29 @@
 import { EnvironmentProviders, InjectionToken, Signal, Injector } from '@angular/core';
 
 /**
- * Color semantics (appearance)
- * Used for buttons, icons, notifications, etc.
+ * Legacy UI-facing appearance semantics.
  *
- * @typedef {('primary' | 'success' | 'warning' | 'error' | 'info' | 'light' | 'gray' | 'inherit')} Appearance
- *
- * Possible values:
- * - `primary` - main accent color
- * - `success` - successful action completion
- * - `warning` - warning
- * - `error` - error
- * - `info` - informational message
- * - `light` - light theme
- * - `gray` - gray/neutral color
- * - `inherit` - inherit color from parent
+ * This model remains only for compatibility with legacy consumers.
+ * It is not part of the desired `internal v2` foundation boundary.
  */
 type Appearance = 'primary' | 'success' | 'warning' | 'error' | 'info' | 'light' | 'gray' | 'inherit';
 /**
- * Base model for a selection option.
- * Universal for selecting, lists, autocompletes, and radio groups.
- *
- * @template ValueType - Type of the option value (string or number). Default is `string | number`.
- *
- * @property {string} label - Displayed label of the option for the user
- * @property {ValueType} value - Value of the option used programmatically
+ * Legacy option model for UI selects.
  *
- * @example
- * ```typescript
- * const option: SelectOption<string> = { label: 'Option 1', value: 'option1' };
- * const numericOption: SelectOption<number> = { label: 'First', value: 1 };
- * ```
+ * This model remains only for compatibility with legacy consumers.
+ * It is not part of the desired `internal v2` foundation boundary.
  */
 type SelectOption<ValueType extends string | number = string | number> = {
-    /** Displayed label */
     label: string;
-    /** Value (string or number) */
     value: ValueType;
 };
 /**
- * Option with icon (for icon-select or dropdown with graphics)
- * Extends the base model {@link SelectOption} by adding an icon field.
+ * Legacy icon option model for UI selects.
  *
- * @template ValueType - Type of the option value (string or number). Default is `string | number`.
- *
- * @property {string} label - Displayed label of the option (inherited from SelectOption)
- * @property {ValueType} value - Value of the option (inherited from SelectOption)
- * @property {string} icon - Name of the icon to display next to the option (read-only)
- *
- * @example
- * ```typescript
- * const iconOption: SelectIconOption<string> = {
- *   label: 'Settings',
- *   value: 'settings',
- *   icon: 'settings-icon'
- * };
- * ```
+ * This model remains only for compatibility with legacy consumers.
+ * It is not part of the desired `internal v2` foundation boundary.
  */
 type SelectIconOption<ValueType extends string | number = string | number> = SelectOption<ValueType> & {
-    /** Icon name */
     readonly icon: string;
 };
 
@@ -124,6 +89,75 @@ type ElementEdges = {
  */
 type ElementRect = Readonly<Partial<ElementPosition> & ElementSize & ElementEdges>;
 
+/**
+ * Single sort token in format "field,direction".
+ * Used to specify sorting criteria for a single field.
+ *
+ * @template F - Field name type, defaults to string
+ */
+type SortToken<F extends string = string> = `${F},${'asc' | 'desc'}`;
+type SortDirection = 'asc' | 'desc';
+type SortRule<F extends string = string> = {
+    sort: F;
+    order: SortDirection;
+};
+type SortInput<F extends string = string> = SortRule<F> | ReadonlyArray<SortRule<F>> | null | undefined;
+type QueryArrayMode = 'comma' | 'json' | 'multi';
+type QueryFieldModes = Partial<Record<string, QueryArrayMode>>;
+/**
+ * Common query parameters interface for API-like requests.
+ *
+ * Kept as a generic query contract rather than a transport implementation detail.
+ */
+interface QueryParams<Filters = unknown> {
+    page?: number;
+    size?: number;
+    sort?: SortToken | ReadonlyArray<SortToken>;
+    filters?: Partial<Filters>;
+}
+type QueryScalar = string | number | boolean;
+type Query = Record<string, QueryScalar | ReadonlyArray<QueryScalar>>;
+
+/**
+ * Supported REST API HTTP methods.
+ *
+ * This is transport-facing and remains in `internal` only while no clearer transport
+ * contract layer exists.
+ */
+type RestMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/**
+ * Pagination request with optional multi-field sorting.
+ *
+ * This remains transport/data-domain flavored and should not define the long-term
+ * `internal v2` foundation boundary by itself.
+ */
+type PageableRequest = {
+    page: number;
+    size?: number;
+    sort?: string | ReadonlyArray<string>;
+};
+/**
+ * Paginated response structure.
+ */
+type PageableResponse<T> = {
+    pageable?: {
+        offset?: number;
+        pageNumber: number;
+        pageSize: number;
+    };
+    totalElements: number;
+    content: T[];
+};
+/**
+ * Business-level error response structure.
+ */
+type ErrorResponse = {
+    errorCode: number | string;
+    message: string;
+    fields?: Record<string, string>;
+    details?: unknown;
+};
+
 /**
  * Universal type "anything".
  * Prefer to use `unknown` to avoid `any` leaks.
@@ -216,161 +250,72 @@ type JsonObject = {
     [k: string]: JsonValue;
 };
 
-/**
- * Supported REST API HTTP methods.
- * Defines the standard set of HTTP methods used for API requests.
- */
-type RestMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-/**
- * Single sort token in format "field,direction".
- * Used to specify sorting criteria for a single field.
- *
- * @template F - Field name type, defaults to string
- * @example
- * ```typescript
- * const sort: SortToken = "name,asc";
- * const sort2: SortToken<"id" | "createdAt"> = "id,desc";
- * ```
- */
-type SortToken<F extends string = string> = `${F},${'asc' | 'desc'}`;
-type SortDirection = 'asc' | 'desc';
-type SortRule<F extends string = string> = {
-    sort: F;
-    order: SortDirection;
+type StorageInterface<Key, Type = AnyType> = {
+    prefix?: string;
+    get(key: Key): Type | null;
+    set(key: Key, value: Type): void;
+    remove(key: Key): void | boolean;
+    clear(): void;
+    get length(): number;
 };
-type SortInput<F extends string = string> = SortRule<F> | ReadonlyArray<SortRule<F>> | null | undefined;
-type QueryArrayMode = 'comma' | 'json' | 'multi';
-type QueryFieldModes = Partial<Record<string, QueryArrayMode>>;
-/**
- * Pagination request with optional multi-field sorting.
- * Used to request paginated data from API endpoints.
- */
-type PageableRequest = {
-    /**
-     * Page number (0-based indexing).
-     * The first page is 0, the second page is 1, etc.
-     */
-    page: number;
-    /**
-     * Optional page size limit.
-     * Specifies the maximum number of items to return per page.
-     */
-    size?: number;
-    /**
-     * Optional sorting criteria.
-     * Can be a single sort token or an array of sort tokens for multi-field sorting.
-     * Format: "field,direction" where direction is "asc" or "desc".
-     * @example ["name,asc", "createdAt,desc"]
-     */
-    sort?: SortToken | ReadonlyArray<SortToken>;
+type StorageStrategy = 'memory' | 'lru' | 'session' | 'persist';
+type StorageStrategyOptions = {
+    lruLimit?: number;
 };
-/**
- * Paginated response structure.
- * Compatible with Spring Data pagination format but type-safe.
- *
- * @template T - Type of items in the content array
- */
-type PageableResponse<T> = {
-    /**
-     * Optional pagination metadata.
-     * Contains information about the current page position and size.
-     */
-    pageable?: {
-        /**
-         * Optional zero-based offset of the first item in the current page.
-         */
-        offset?: number;
-        /**
-         * Current page number (0-based indexing).
-         */
-        pageNumber: number;
-        /**
-         * Number of items per page.
-         */
-        pageSize: number;
-    };
-    /**
-     * Total number of elements across all pages.
-     */
-    totalElements: number;
-    /**
-     * Array of items for the current page.
-     */
-    content: T[];
-};
-/**
- * Business-level error response structure.
- * Used to communicate structured error information from API endpoints.
- */
-type ErrorResponse = {
-    /**
-     * Error code identifier.
-     * Can be a numeric code or string constant for error categorization.
-     */
-    errorCode: number | string;
-    /**
-     * Human-readable error message.
-     * Provides a description of the error for display or logging.
-     */
-    message: string;
-    /**
-     * Optional field-level validation errors map.
-     * Maps form/DTO field names to their respective error messages.
-     * Supports multiple errors per field when concatenated in the string value.
-     */
-    fields?: Record<string, string>;
-    /**
-     * Optional arbitrary error details.
-     * Can contain additional context such as error code enums, hints, or debugging information.
-     */
-    details?: unknown;
-};
-/**
- * Common query parameters interface for API requests.
- * Combines pagination, sorting, and filtering capabilities.
- *
- * @template Filters - Type of the domain model used for filtering, defaults to unknown
- */
-interface QueryParams<Filters = unknown> {
-    /**
-     * Optional page number for pagination (0-based indexing).
-     */
-    page?: number;
-    /**
-     * Optional page size limit.
-     */
-    size?: number;
-    /**
-     * Optional sorting criteria.
-     * Can be a single sort token or an array of sort tokens for multi-field sorting.
-     */
-    sort?: SortToken | ReadonlyArray<SortToken>;
-    /**
-     * Optional filters as a partial subset of the domain model.
-     * Allows filtering by any combination of model properties.
-     */
-    filters?: Partial<Filters>;
+
+declare class LocalStorage<Key = string, Type extends AnyType = AnyDict> implements StorageInterface<Key, Type> {
+    prefix: string;
+    constructor(prefix?: string);
+    get length(): number;
+    get(key: Key): Type | null;
+    set(key: Key, value: Type): void;
+    remove(key: Key): void;
+    clear(): void;
+    private getSafePrefix;
+    private safePrefix;
+}
+
+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;
 }
-/**
- * Allowed scalar value types for query parameters.
- * Represents primitive types that can be safely serialized in URL query strings.
- */
-type QueryScalar = string | number | boolean;
-/**
- * Universal query parameters dictionary with array support.
- * Maps parameter names to scalar values or arrays of scalar values.
- * Useful for building flexible query strings with multiple values per parameter.
- *
- * @example
- * ```typescript
- * const query: Query = {
- *   status: "active",
- *   tags: ["typescript", "angular"],
- *   limit: 10
- * };
- * ```
- */
-type Query = Record<string, QueryScalar | ReadonlyArray<QueryScalar>>;
+
+declare class MemoryStorage<Key = string, Type extends AnyType = AnyDict> implements StorageInterface<Key, Type> {
+    private cache;
+    get length(): number;
+    get(key: Key): Type | null;
+    set(key: Key, value: Type): void;
+    remove(key: Key): void;
+    clear(): void;
+}
+
+declare class SessionStorage<Key = string, Type extends AnyType = AnyDict> implements StorageInterface<Key, Type> {
+    prefix: string;
+    constructor(prefix?: string);
+    get length(): number;
+    get(key: Key): Type | null;
+    set(key: Key, value: Type): void;
+    remove(key: Key): void;
+    clear(): void;
+    private getSafePrefix;
+    private safePrefix;
+}
+
+declare const storageStrategy: <Key = string, Type extends AnyType = AnyDict>(strategy: StorageStrategy, options?: StorageStrategyOptions) => StorageInterface<Key, Type>;
 
 /**
  * Built-in language codes.
@@ -467,7 +412,7 @@ declare const TRANSLATION: InjectionToken<TranslationProvider>;
  * `'light'` — light theme
  * `'dark'` — dark theme
  */
-type Themes = 'light' | 'dark';
+type Themes = 'light' | 'dark' | (string & {});
 /**
  * Provider for changing the application theme.
  *
@@ -522,12 +467,11 @@ type Devices = 'mobile' | 'tablet' | 'desktop-s' | 'desktop';
 declare const CURRENT_DEVICE: InjectionToken<Signal<Devices>>;
 
 /**
- * Represents flexible validation error data without enforced fields.
- * Contains common properties like requiredLength and actualLength
- * and allows additional string properties through index signature.
+ * Legacy validation token surface kept only for compatibility with legacy consumers.
  *
- * @property {string} requiredLength - The required length for validation.
- * @property {string} actualLength - The actual length of the validated value.
+ * This token set is form/UI-facing and does not belong to the desired `internal v2`
+ * foundation boundary. Keep usage isolated and migrate consumers away from the top-level
+ * `@reforgium/internal` surface over time.
  */
 type ValidationErrorData = {
     requiredLength: string;
@@ -535,32 +479,11 @@ type ValidationErrorData = {
     [key: string]: string;
 };
 /**
- * Map of validation error names to message generator functions.
- * Each key represents an error name, and the value is a function
- * that takes validation error data and returns a formatted error message.
- *
- * @example
- * const messages: ValidationMessages = {
- *   minlength: (error) => `Minimum length is ${error.requiredLength}`
- * };
+ * Legacy validation message map.
  */
 type ValidationMessages = Record<string, (error: ValidationErrorData) => string>;
 /**
- * Injection token for a validation messages map.
- * Can be overridden in feature modules to provide custom validation messages.
- * Defaults to an empty object when not provided.
- *
- * @example
- * // In a feature module:
- * providers: [
- *   {
- *     provide: VALIDATION_MESSAGES,
- *     useValue: {
- *       required: () => 'This field is required',
- *       minlength: (error) => `Min length: ${error.requiredLength}`
- *     }
- *   }
- * ]
+ * Legacy validation messages token.
  */
 declare const VALIDATION_MESSAGES: InjectionToken<ValidationMessages>;
 
@@ -668,7 +591,7 @@ declare const throttleSignal: <T>(src: Signal<T>, ms?: number, opts?: {
  *
  * @returns {string} Formatted date string. Returns an empty string if the input date is invalid.
  */
-declare const formatDate: (date: Date, format?: string) => string;
+declare const formatDate: (date?: Date | null, format?: string) => string;
 /**
  * Formats the given date into a `day month year` string using the `ru-RU` locale.
  * The month is abbreviated and normalized without a trailing dot.
@@ -729,7 +652,7 @@ declare const toDate: (v: unknown) => Date;
  *   reformatDateToISO("24.11.2025", "dd.MM.yyyy")
  *   → "2025-11-24T00:00:00.000Z"
  */
-declare function reformatDateToISO(dateStr: string, mask: string): string | null;
+declare function reformatDateToISO(dateStr?: string | null, mask?: string | null): string | null;
 
 /**
  * Determines if the given value is null/undefined.
@@ -1005,6 +928,96 @@ declare function deepEqual(a: AnyType, b: AnyType, seen?: Map<any, any>): boolea
  */
 declare const generateId: (limit?: number, radix?: number) => string;
 
-export { BUILTIN_LANGS, CHANGE_LANG, CHANGE_THEME, CURRENT_DEVICE, REGISTER_LANG, SELECTED_LANG, SELECTED_THEME, TRANSLATION, VALIDATION_MESSAGES, appendQueryParams, appendQueryParamsByMode, base64ToBlob, buildQueryParams, compareRoutes, concatArray, copyText, debounceSignal, deepEqual, downloadByBlob, downloadByUrl, fillUrlWithParams, formatDate, formatToLocaledDate, formatToSpacedNumber, generateId, getAvailableHeight, getChainedValue, getCorrectedPosition, isDatePeriod, isNullable, isNumber, isObject, makeQuery, materializeRoutePath, mergeQueryParams, normalizeSortInput, normalizeUrl, parseQueryArray, parseQueryParams, parseQueryParamsByMode, parseSortToken, parseToDate, parseToDatePeriod, provideLangs, reformatDateToISO, sortInputToTokens, sortRuleToToken, throttleSignal, toDate, toSortToken, truncate };
-export type { AnyDict, AnyType, Appearance, Devices, Direction, ElementEdges, ElementPosition, ElementRect, ElementSize, ErrorResponse, JsonObject, JsonPrimitive, JsonValue, Langs, LiteralOf, Mutable, Nullable, NullableProps, Nullish, OptionalExcept, PageableRequest, PageableResponse, Query, QueryArrayMode, QueryFieldModes, QueryParams, QueryScalar, RequiredExcept, RestMethods, SelectIconOption, SelectOption, SortDirection, SortInput, SortRule, SortToken, Themes, ValidationErrorData, ValidationMessages, ValueOf };
+type Types = 'string' | 'number' | 'boolean' | 'array' | 'object' | 'date' | 'period' | 'nullable';
+type FieldConcatType = 'comma' | 'multi' | 'json';
+type SerializedPrimitives = string | number | boolean | null;
+type SerializedTypeType = SerializedPrimitives | SerializedPrimitives[];
+type DatePeriod = [Date | null, Date | null];
+type ParseFormatConfig<TypeFrom, TypeTo = SerializedTypeType> = {
+    parse?: (val: TypeTo) => TypeFrom;
+    format?: (val: TypeFrom) => TypeTo;
+};
+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>;
+    mapPeriod: {
+        transformMode?: PeriodSplitMode | PeriodJoinMode;
+        dateFormat?: string;
+    } & ParseFormatConfig<DatePeriod>;
+    mapNullable: {
+        remove?: boolean;
+        replaceWith?: string;
+        includeEmptyString?: boolean;
+    } & ParseFormatConfig<null | undefined>;
+    mapArray: {
+        concatType: FieldConcatType;
+        removeNullable?: boolean;
+    } & FormatConfig<AnyType[]>;
+    mapObject: {
+        deep: boolean;
+    } & FormatConfig<DataType>;
+    mapFields?: Record<string, FieldConfig>;
+};
+type SerializedType = Record<string, SerializedTypeType>;
+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);
+}
+declare class Serializer<EntityType extends DataType> {
+    readonly config: SerializerConfig;
+    constructor(config?: Partial<SerializerConfig>);
+    serialize(obj: EntityType, _seen?: WeakSet<object>): SerializedType;
+    deserialize: (val: string | AnyDict) => EntityType;
+    deserializeQuery: (query: string) => EntityType;
+    deserializeJson: (json: string) => EntityType;
+    toQuery: (val: EntityType) => string;
+    withConfig(config: Partial<SerializerConfig>): Serializer<EntityType>;
+    private serializeElement;
+    private deserializeElement;
+    private parseQuery;
+    private parseJsonObject;
+    private parseInputString;
+    private mergeConfig;
+    private resolveArrayFieldModes;
+}
+
+export { BUILTIN_LANGS, CHANGE_LANG, CHANGE_THEME, CURRENT_DEVICE, LocalStorage, LruCache, MemoryStorage, REGISTER_LANG, SELECTED_LANG, SELECTED_THEME, Serializer, SerializerFieldError, SessionStorage, TRANSLATION, VALIDATION_MESSAGES, appendQueryParams, appendQueryParamsByMode, base64ToBlob, buildQueryParams, compareRoutes, concatArray, copyText, debounceSignal, deepEqual, downloadByBlob, downloadByUrl, fillUrlWithParams, formatDate, formatToLocaledDate, formatToSpacedNumber, generateId, getAvailableHeight, getChainedValue, getCorrectedPosition, isDatePeriod, isNullable, isNumber, isObject, makeQuery, materializeRoutePath, mergeQueryParams, normalizeSortInput, normalizeUrl, parseQueryArray, parseQueryParams, parseQueryParamsByMode, parseSortToken, parseToDate, parseToDatePeriod, provideLangs, reformatDateToISO, sortInputToTokens, sortRuleToToken, storageStrategy, throttleSignal, toDate, toSortToken, truncate };
+export type { AnyDict, AnyType, Appearance, DataType, Devices, Direction, ElementEdges, ElementPosition, ElementRect, ElementSize, ErrorResponse, FieldConcatType, FieldConfig, FormatConfig, JsonObject, JsonPrimitive, JsonValue, Langs, LiteralOf, Mutable, Nullable, NullableProps, Nullish, OptionalExcept, PageableRequest, PageableResponse, ParseFormatConfig, Query, QueryArrayMode, QueryFieldModes, QueryParams, QueryScalar, RequiredExcept, RestMethods, SelectIconOption, SelectOption, SerializedType, SerializerConfig, SortDirection, SortInput, SortRule, SortToken, StorageInterface, StorageStrategy, StorageStrategyOptions, Themes, Types, ValidationErrorData, ValidationMessages, ValueOf };
 //# sourceMappingURL=reforgium-internal.d.ts.map