@africanies/angular-web-sdk 0.1.12 → 0.1.13

package/.nx/cache/13293303228070520113/dist/libs/africanies-core/fesm2022/africanies-africanies-core.mjs

@@ -0,0 +1,4699 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injector, signal, Injectable, makeEnvironmentProviders, provideAppInitializer } from '@angular/core';
+import { SessionStorageService, AFRICANIES_SHIPPING_MODE_KEY, STORAGE_TOKEN, AFRICANIES_MODE_CONFIG_KEY, provideLocalStorage, AFRICANIES_ACCESS_TOKEN_KEY } from '@africanies/africanies-storage';
+import { of, timeout, throwError, map as map$1, tap as tap$1, catchError, finalize, firstValueFrom, forkJoin } from 'rxjs';
+import { HttpErrorResponse, HttpContextToken, HttpContext, HttpClient, HttpHeaders, HttpParams, provideHttpClient, withInterceptors } from '@angular/common/http';
+import { DEFAULT_PAGE_SIZE, NOTIFICATION_PAGE_SIZE } from '@africanies/africanies-models';
+import { take, tap, map } from 'rxjs/operators';
+import { ActivatedRoute, Router } from '@angular/router';
+
+/**
+ * DI token for the active {@link AfricaniesSdkConfig}.
+ *
+ * Apps must call {@link provideAfricaniesSdk} at bootstrap; injecting without that
+ * provider throws so misconfiguration fails fast rather than silently using
+ * an empty base URL.
+ */
+const AFRICANIES_SDK_CONFIG = new InjectionToken('AFRICANIES_SDK_CONFIG');
+
+const DEFAULT_MODE = 'sfn';
+/**
+ * Signal-based holder for the active {@link ShippingMode}.
+ *
+ * Persists through {@link SessionStorageService} under
+ * {@link AFRICANIES_SHIPPING_MODE_KEY} so each browser tab can hold its own STN/SFN
+ * context (refresh within the tab keeps the choice; other tabs are unaffected).
+ * Defaults to `'sfn'` when nothing is stored or the stored value is not a known
+ * mode — preferring a safe outbound default over failing open on corrupt storage.
+ *
+ * Changing mode clears {@link ApiClient}'s GET cache so `readAll` / by-id
+ * dumps cannot cross STN↔SFN (cache keys omit the mode header). `ApiClient`
+ * is resolved lazily via {@link Injector} to avoid a DI cycle.
+ *
+ * List screens should drop in-memory rows and show a blocking loader until
+ * the new mode's page arrives — STN rows must not linger on SFN. Use
+ * `listFetchKind` with `reason: 'mode'`.
+ *
+ * Features that must warn before a switch (e.g. mid Create Shipment) can
+ * {@link registerModeChangeGuard}. The shell switch uses
+ * {@link requestModeChange}; programmatic {@link setMode} bypasses the guard.
+ *
+ * Provided in root; no explicit provider registration is required.
+ * Pair with {@link shipmentModeInterceptor} so HTTP calls advertise the mode.
+ *
+ * @example
+ * ```ts
+ * const shipping = inject(ShippingModeService);
+ * shipping.setMode('stn');
+ * console.log(shipping.mode()); // 'stn'
+ * ```
+ */
+/**
+ * Signal-based holder for the active {@link ShippingMode}.
+ */
+class ShippingModeService {
+    storage = inject(SessionStorageService);
+    injector = inject(Injector);
+    _mode = signal(this.readInitialMode(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_mode" }] : /* istanbul ignore next */ []));
+    modeChangeGuard = null;
+    /**
+     * Read-only view of the current shipping mode (`Signal` = Angular's
+     * readonly signal surface; mutate only via {@link setMode} /
+     * {@link requestModeChange}).
+     */
+    mode = this._mode.asReadonly();
+    /**
+     * Register a single guard for shell mode switches. Pass `null` to clear
+     * (e.g. on feature destroy). Only one guard is active at a time.
+     * @param guard
+     */
+    registerModeChangeGuard(guard) {
+        this.modeChangeGuard = guard;
+    }
+    /**
+     * Shell switch entry point: runs any registered guard, then applies the
+     * mode when allowed.
+     *
+     * @param mode - `'stn'` or `'sfn'`.
+     * @returns Emits once with `true` when the mode changed, else `false`.
+     */
+    requestModeChange(mode) {
+        if (mode === this._mode()) {
+            return of(false);
+        }
+        const current = this._mode();
+        const guard = this.modeChangeGuard;
+        const allowed$ = guard ? guard(mode, current) : of(true);
+        return allowed$.pipe(take(1), tap((ok) => {
+            if (ok) {
+                this.applyMode(mode);
+            }
+        }), map((ok) => !!ok));
+    }
+    /**
+     * Updates the active mode and persists it for the current tab.
+     * No-ops when `mode` already matches the current value.
+     * Bypasses {@link registerModeChangeGuard} — prefer
+     * {@link requestModeChange} for user-driven switches.
+     *
+     * @param mode - `'stn'` or `'sfn'`.
+     */
+    setMode(mode) {
+        if (mode === this._mode()) {
+            return;
+        }
+        this.applyMode(mode);
+    }
+    applyMode(mode) {
+        this._mode.set(mode);
+        this.storage.set(AFRICANIES_SHIPPING_MODE_KEY, mode);
+        this.injector.get(ApiClient).clearCache();
+    }
+    readInitialMode() {
+        const stored = this.storage.get(AFRICANIES_SHIPPING_MODE_KEY);
+        return stored === 'stn' || stored === 'sfn' ? stored : DEFAULT_MODE;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ShippingModeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ShippingModeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ShippingModeService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Null-safe coercions for AFRICANIES wire JSON.
+ *
+ * Mappers should run every request/response field through these helpers so
+ * missing keys, `null`, and wrong JSON types never throw at `.map` / `.trim`.
+ */
+/**
+ * Narrow unknown JSON into a plain object record.
+ * @param value - Candidate value.
+ * @returns Record when a non-array object; otherwise `null`.
+ */
+function asRecord(value) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+/**
+ * Coerce a value to an array. Non-arrays become `[]`.
+ * @param value - Candidate list.
+ */
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+/**
+ * Map every element of a wire list. Non-arrays yield `[]`.
+ * @param value - Candidate list.
+ * @param mapOne - Per-item mapper.
+ */
+function mapArray(value, mapOne) {
+    return asArray(value).map(mapOne);
+}
+/**
+ * If a list payload is wrapped in a Laravel paginator / `{ data | items }`,
+ * return the inner array. Otherwise return `value` unchanged.
+ * @param value - Envelope `data` or a nested list field.
+ */
+function unwrapListPayload(value) {
+    if (Array.isArray(value) || value == null) {
+        return value;
+    }
+    const record = asRecord(value);
+    if (record === null) {
+        return value;
+    }
+    const nested = record['data'] ?? record['items'] ?? record['results'];
+    if (Array.isArray(nested)) {
+        return nested;
+    }
+    if (nested == null &&
+        ('current_page' in record ||
+            'currentPage' in record ||
+            'last_page' in record ||
+            'lastPage' in record ||
+            'per_page' in record ||
+            'perPage' in record)) {
+        return [];
+    }
+    return value;
+}
+/**
+ * Map a list-or-single payload (Laravel sometimes sends one object).
+ *
+ * - `null` / `undefined` → `[]`
+ * - paginator / `{ data | items }` → mapped inner rows
+ * - array → mapped items
+ * - anything else → one mapped item
+ *
+ * @param value - Envelope `data` (or a nested list field).
+ * @param mapOne - Per-item mapper.
+ */
+function mapList(value, mapOne) {
+    const list = unwrapListPayload(value);
+    if (list == null) {
+        return [];
+    }
+    if (Array.isArray(list)) {
+        return list.map(mapOne);
+    }
+    return [mapOne(list)];
+}
+/**
+ * Finite number, or `fallback` when missing/invalid.
+ * @param value - Raw numeric field.
+ * @param fallback - Default when not a finite number.
+ */
+function asNumber(value, fallback = 0) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : fallback;
+}
+/**
+ * Finite number, or `null` when missing/invalid.
+ * @param value - Raw numeric field.
+ */
+function asNullableNumber(value) {
+    if (value == null || value === '') {
+        return null;
+    }
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+}
+/**
+ * String, or `fallback` when the value cannot be stringified usefully.
+ * @param value - Raw string field.
+ * @param fallback - Default when nullish / non-scalar.
+ */
+function asString(value, fallback = '') {
+    if (value == null) {
+        return fallback;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return fallback;
+}
+/**
+ * String or `null` (never `undefined`).
+ * @param value - Raw string field.
+ */
+function asNullableString(value) {
+    if (value == null) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return null;
+}
+/**
+ * Boolean from wire flags (`true` / `false` / `1` / `0` / `"true"` / `"1"`).
+ * Missing values are `false`.
+ * @param value - Raw flag.
+ */
+function asBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return value === 1;
+    }
+    const trimmed = String(value ?? '')
+        .trim()
+        .toLowerCase();
+    return trimmed === '1' || trimmed === 'true';
+}
+/**
+ * Boolean or `null` when the field is absent / unparseable.
+ * @param value - Raw flag.
+ */
+function asNullableBoolean(value) {
+    if (value == null || value === '') {
+        return null;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return value === 1;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim().toLowerCase();
+        if (trimmed === '1' || trimmed === 'true') {
+            return true;
+        }
+        if (trimmed === '0' || trimmed === 'false') {
+            return false;
+        }
+    }
+    return null;
+}
+/**
+ * Wire `"1"` / `"0"` from a boolean, number, or string flag.
+ * @param value - Host or wire flag.
+ */
+function toFlag01(value) {
+    return asBoolean(value) ? '1' : '0';
+}
+/**
+ * User-model `0` / `1` flag, or `null` when absent.
+ * @param value - Raw flag.
+ */
+function asNullableFlag01(value) {
+    if (value == null || value === '') {
+        return null;
+    }
+    if (value === 1 || value === '1' || value === true) {
+        return 1;
+    }
+    if (value === 0 || value === '0' || value === false) {
+        return 0;
+    }
+    return null;
+}
+
+/**
+ * Laravel-style validation bag: `{ field: ["msg", ...] }`.
+ * @param value - Candidate JSON object.
+ */
+function isLaravelValidationBag(value) {
+    const record = asRecord(value);
+    if (record === null) {
+        return false;
+    }
+    const keys = Object.keys(record);
+    if (keys.length === 0) {
+        return false;
+    }
+    return keys.every((key) => {
+        const entry = record[key];
+        return (Array.isArray(entry) &&
+            entry.every((item) => typeof item === 'string'));
+    });
+}
+/**
+ * Flatten a validation bag into {@link ApiErrorDetailModel} rows.
+ *
+ * Uses messages in order; the first message per field is what
+ * {@link fieldErrorsMap} exposes for form binding.
+ * @param bag - Field → messages map.
+ */
+function mapLaravelValidationBag(bag) {
+    const details = [];
+    for (const [field, rawMessages] of Object.entries(bag)) {
+        const messages = asArray(rawMessages)
+            .map((m) => asString(m).trim())
+            .filter((m) => m.length > 0);
+        for (const message of messages) {
+            details.push({ field, message, code: null });
+        }
+    }
+    return details;
+}
+/**
+ * Join field errors for toast / banner copy (one line per message, de-duped).
+ * Prefer this over top-level `message` when a bag is present — the envelope
+ * `message` is often only the first field.
+ * @param errors - Normalized field errors.
+ */
+function joinApiErrorMessages(errors) {
+    if (!errors?.length) {
+        return null;
+    }
+    const lines = [];
+    const seen = new Set();
+    for (const detail of errors) {
+        const message = detail.message.trim();
+        if (!message || seen.has(message)) {
+            continue;
+        }
+        seen.add(message);
+        lines.push(message);
+    }
+    return lines.length > 0 ? lines.join('\n') : null;
+}
+/**
+ * First message per field for form control binding.
+ * @param errors - Normalized field errors.
+ */
+function fieldErrorsMap(errors) {
+    const map = {};
+    if (!errors?.length) {
+        return map;
+    }
+    for (const detail of errors) {
+        const field = detail.field?.trim();
+        const message = detail.message.trim();
+        if (!field || !message || field in map) {
+            continue;
+        }
+        map[field] = message;
+    }
+    return map;
+}
+
+/**
+ * Whether the payload looks like an AFRICANIES API envelope.
+ * @param value
+ */
+function isWrappedEnvelope(value) {
+    const record = asRecord(value);
+    return record !== null && 'success' in record && 'data' in record;
+}
+/**
+ * Laravel LengthAwarePaginator nested inside the envelope `data` field.
+ * @param value
+ */
+function isLaravelPaginator(value) {
+    const record = asRecord(value);
+    if (record === null) {
+        return false;
+    }
+    return ((Array.isArray(record['data']) || record['data'] == null) &&
+        ('current_page' in record ||
+            'currentPage' in record ||
+            'last_page' in record ||
+            'lastPage' in record ||
+            'per_page' in record ||
+            'perPage' in record));
+}
+/**
+ * Map pagination from snake_case (preferred), legacy camelCase, or Laravel keys.
+ * @param value
+ */
+function normalizePagination(value) {
+    const record = asRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const current_page = record['current_page'] ?? record['currentPage'];
+    const per_page = record['per_page'] ?? record['perPage'];
+    const total_items = record['total_items'] ?? record['totalItems'] ?? record['total'];
+    const total_pages = record['total_pages'] ??
+        record['totalPages'] ??
+        record['last_page'] ??
+        record['lastPage'];
+    let has_next_page = record['has_next_page'] ?? record['hasNextPage'];
+    let has_previous_page = record['has_previous_page'] ?? record['hasPreviousPage'];
+    if (has_next_page == null) {
+        const next_page_url = record['next_page_url'] ?? record['nextPageUrl'];
+        has_next_page = next_page_url != null && next_page_url !== '';
+    }
+    if (has_previous_page == null) {
+        const prev_page_url = record['prev_page_url'] ?? record['prevPageUrl'];
+        has_previous_page = prev_page_url != null && prev_page_url !== '';
+    }
+    return {
+        current_page: asNumber(current_page),
+        per_page: asNumber(per_page),
+        total_items: asNumber(total_items),
+        total_pages: asNumber(total_pages),
+        has_next_page: Boolean(has_next_page),
+        has_previous_page: Boolean(has_previous_page),
+    };
+}
+/**
+ * Flatten a Laravel paginator in `data` into list payload + {@link PaginationMetaModel}.
+ * @param raw
+ */
+function unwrapLaravelPaginator(raw) {
+    if (!isLaravelPaginator(raw)) {
+        return {
+            data: raw ?? null,
+            pagination: null,
+        };
+    }
+    const record = asRecord(raw);
+    if (record === null) {
+        return { data: null, pagination: null };
+    }
+    return {
+        data: Array.isArray(record['data']) ? record['data'] : [],
+        pagination: normalizePagination(record),
+    };
+}
+/**
+ * Coalesce a single error entry so missing field/code become `null`.
+ * @param value
+ */
+function normalizeErrorDetail(value) {
+    const record = asRecord(value) ?? {};
+    return {
+        field: asString(record['field']) || null,
+        message: asString(record['message']),
+        code: asString(record['code']) || null,
+    };
+}
+/**
+ * Resolve field errors from an envelope `errors` value or a failure `data` bag.
+ * @param errorsRaw - Wire `errors` (array or Laravel object map).
+ * @param data - Envelope `data` (may hold a validation bag on failure).
+ * @param success - Envelope success flag.
+ */
+function resolveErrors(errorsRaw, data, success) {
+    if (Array.isArray(errorsRaw)) {
+        const details = asArray(errorsRaw).map(normalizeErrorDetail);
+        return details.length > 0 ? details : null;
+    }
+    if (isLaravelValidationBag(errorsRaw)) {
+        const details = mapLaravelValidationBag(asRecord(errorsRaw) ?? {});
+        return details.length > 0 ? details : null;
+    }
+    // Soft/hard validation failures often put the bag in `data` (not `errors`).
+    if (!success && isLaravelValidationBag(data)) {
+        const details = mapLaravelValidationBag(asRecord(data) ?? {});
+        return details.length > 0 ? details : null;
+    }
+    return null;
+}
+/**
+ * Normalize any HTTP JSON body into a fully null-safe {@link ApiResponseModel}.
+ *
+ * Envelope fields use snake_case where the wire does (`status_code`,
+ * pagination keys). Paginated list reads often embed a Laravel paginator in
+ * `data` (`data.data` + totals) — that shape is flattened here so consumers
+ * always see `data: T[]` and `pagination`.
+ *
+ * Validation failures that return a Laravel field bag in `errors` or `data`
+ * are lifted into `errors: ApiErrorDetailModel[]`. On failure, a bag in
+ * `data` is cleared (`data: null`) so it is not typed as success payload `T`.
+ * Top-level `message` is enriched to the joined field messages when a bag
+ * exists (API `message` alone is often only the first field).
+ * @param raw
+ */
+function normalize(raw) {
+    if (isWrappedEnvelope(raw)) {
+        const record = asRecord(raw);
+        if (record !== null) {
+            const successRaw = record['success'];
+            const success = typeof successRaw === 'boolean' ? successRaw : Boolean(successRaw);
+            const status_code = record['status_code'] ?? record['statusCode'] ?? null;
+            let pagination = normalizePagination(record['pagination']);
+            let data = record['data'] ?? null;
+            if (pagination === null && isLaravelPaginator(data)) {
+                const unwrapped = unwrapLaravelPaginator(data);
+                data = unwrapped.data ?? null;
+                pagination = unwrapped.pagination;
+            }
+            const errors = resolveErrors(record['errors'], data, success);
+            const apiMessage = asNullableString(record['message']);
+            // Do not leave a validation bag typed as success payload `T`.
+            if (!success && isLaravelValidationBag(data)) {
+                data = null;
+            }
+            return {
+                success,
+                message: joinApiErrorMessages(errors) ?? apiMessage,
+                data,
+                errors,
+                pagination,
+                status_code: status_code === null || status_code === undefined
+                    ? null
+                    : asNumber(status_code),
+            };
+        }
+    }
+    return {
+        success: true,
+        message: null,
+        data: raw ?? null,
+        errors: null,
+        pagination: null,
+        status_code: null,
+    };
+}
+
+/**
+ * Resolve user-facing error copy from an API envelope, raw body, or HttpClient error.
+ *
+ * Prefers joined field messages when present; otherwise envelope / HTTP `message`.
+ *
+ * Prefer relying on {@link ApiClient}: HTTP failures are already rethrown as
+ * `Error` with this text on `.message`. Hosts mainly need this helper when
+ * calling Angular `HttpClient` directly (e.g. toast interceptor).
+ *
+ * @param input - Normalized response, raw JSON body, or {@link HttpErrorResponse}.
+ */
+function formatApiErrorMessage(input) {
+    if (typeof input === 'string' && input.trim()) {
+        return input.trim();
+    }
+    if (input instanceof HttpErrorResponse) {
+        const fromBody = formatApiErrorMessage(input.error);
+        if (fromBody !== 'Something went wrong.') {
+            return fromBody;
+        }
+        if (input.status === 0) {
+            return 'Network error. Check your connection.';
+        }
+        if (input.status === 401 || input.status === 403) {
+            return 'Authentication failed. Check your access token.';
+        }
+        if (input.status >= 500) {
+            return 'Server error. Try again in a moment.';
+        }
+        if (input.message?.trim()) {
+            return input.message.trim();
+        }
+        return `Request failed (${input.status})`;
+    }
+    if (input && typeof input === 'object' && 'success' in input && 'data' in input) {
+        const normalized = normalize(input);
+        return (joinApiErrorMessages(normalized.errors) ??
+            normalized.message?.trim() ??
+            'Something went wrong.');
+    }
+    if (input && typeof input === 'object') {
+        const record = asRecord(input);
+        if (record &&
+            typeof record['message'] === 'string' &&
+            record['message'].trim()) {
+            return record['message'].trim();
+        }
+    }
+    if (input instanceof Error && input.message.trim()) {
+        return input.message.trim();
+    }
+    return 'Something went wrong.';
+}
+
+/**
+ * Tiny in-memory TTL cache for {@link ApiClient} GET responses.
+ *
+ * Intentionally process-local and non-persistent: it exists to skip identical
+ * GETs within a short window (e.g. rapid remounts), not to replace TanStack
+ * Query or server cache headers.
+ *
+ * ## When NOT to use caching (`cacheTtlMs`)
+ *
+ * - Frequently changing data (dashboards, live rates, inventory) — stale reads
+ *   are worse than an extra round-trip.
+ * - User-specific or permission-sensitive payloads — another user/session in
+ *   the same SPA tab could theoretically share the in-memory map.
+ * - After mutations that invalidate list/detail views — this cache has no
+ *   tag-based invalidation; prefer TanStack Query for that.
+ * - Large payloads — every entry stays in heap until TTL expiry.
+ *
+ * Prefer omitting `cacheTtlMs` unless you have a measured hot-spot and a
+ * known staleness budget.
+ */
+/**
+ * Key/value store with per-entry TTL eviction on read.
+ */
+class HttpResponseCache {
+    store = new Map();
+    /**
+     * Returns a cached value when present and not expired.
+     *
+     * @param key - Stable request identity (method + URL + relevant params).
+     * @returns The stored value, or `null` on miss / expiry.
+     */
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry) {
+            return null;
+        }
+        if (Date.now() >= entry.expiresAt) {
+            this.store.delete(key);
+            return null;
+        }
+        return entry.value;
+    }
+    /**
+     * Stores a value until `ttlMs` elapses.
+     *
+     * @param key - Stable request identity.
+     * @param value - Value to reuse for subsequent hits.
+     * @param ttlMs - Time-to-live in milliseconds from now.
+     */
+    set(key, value, ttlMs) {
+        this.store.set(key, {
+            value,
+            expiresAt: Date.now() + ttlMs,
+        });
+    }
+    /**
+     * Drops every entry. Useful after logout or global invalidation hooks.
+     */
+    clear() {
+        this.store.clear();
+    }
+}
+
+/**
+ * Per-request shipping-mode override for {@link shipmentModeInterceptor}.
+ *
+ * When set, `x-shipment-mode` uses this value instead of
+ * {@link ShippingModeService.mode}. The tab / session mode is unchanged.
+ * Sentinel `null` means “use the active tab mode”.
+ */
+const SHIPPING_MODE_OVERRIDE = new HttpContextToken(() => null);
+/**
+ * Narrow unknown JSON / option values to a {@link ShippingMode}.
+ *
+ * @param value - Candidate value.
+ * @returns `'stn'` or `'sfn'` when valid; otherwise `undefined`.
+ */
+function asShippingMode$1(value) {
+    return value === 'stn' || value === 'sfn' ? value : undefined;
+}
+/**
+ * Tag a request so {@link shipmentModeInterceptor} sends a different
+ * `x-shipment-mode` without calling {@link ShippingModeService.setMode}.
+ *
+ * Prefer {@link ApiRequestOptions.shippingMode} on {@link ApiClient} calls.
+ * Use this helper with raw `HttpClient`.
+ *
+ * @param mode - Mode for this request only.
+ * @param context - Existing context to merge (e.g. from {@link withToast}).
+ * @returns HttpContext with the override set.
+ *
+ * @example
+ * ```ts
+ * this.http.post(url, body, { context: withShippingMode('stn') });
+ * ```
+ */
+function withShippingMode(mode, context) {
+    return (context ?? new HttpContext()).set(SHIPPING_MODE_OVERRIDE, mode);
+}
+
+/** DI token for the HTTP → toast bridge. */
+const AFRICANIES_HTTP_TOAST = new InjectionToken('AFRICANIES_HTTP_TOAST');
+/**
+ * Present only when the request was tagged with {@link withToast}.
+ * Sentinel `null` means “not tagged”.
+ */
+const TOAST_HTTP_OPTIONS = new HttpContextToken(() => null);
+/**
+ * Opt a request into HTTP toasts.
+ *
+ * Defaults: `success: true`, `error: true`. Pass flags to silence either side.
+ *
+ * @param options - Partial overrides for the defaults.
+ * @returns HttpContext ready to pass as `context` on HttpClient calls.
+ *
+ * @example
+ * ```ts
+ * // Success + error toasts
+ * this.http.post(url, body, { context: withToast() });
+ *
+ * // Errors only
+ * this.http.post(url, body, { context: withToast({ success: false }) });
+ *
+ * // Custom copy
+ * this.http.post(url, body, {
+ *   context: withToast({
+ *     successMessage: 'Shipment saved',
+ *     errorMessage: 'Could not save shipment',
+ *   }),
+ * });
+ * ```
+ */
+function withToast(options) {
+    return new HttpContext().set(TOAST_HTTP_OPTIONS, {
+        success: options?.success ?? true,
+        error: options?.error ?? true,
+        successMessage: options?.successMessage,
+        errorMessage: options?.errorMessage,
+    });
+}
+
+/**
+ * Resolve {@link HttpContext} toast flags for an {@link ApiClient} request.
+ *
+ * Precedence:
+ * 1. Per-request `toast: false` — never tag.
+ * 2. GET — silent by default (list/detail failures stay in-page). Opt in with
+ *    an explicit per-request toast object.
+ * 3. Otherwise merge config {@link AfricaniesSdkHttpToasts} with per-request overrides
+ *    (POST / PUT / PATCH / DELETE toast errors when config is `'errors'`).
+ *
+ * @param configMode - From {@link AfricaniesSdkConfig.httpToasts} (defaults to `'off'`).
+ * @param perRequest - From {@link ApiRequestOptions.toast}.
+ * @param method - HTTP verb so GET stays quiet under `'errors'` / `'all'`.
+ */
+function resolveHttpToastContext(configMode, perRequest, method) {
+    if (perRequest === false) {
+        return undefined;
+    }
+    const isGet = (method ?? '').toUpperCase() === 'GET';
+    if (isGet && perRequest == null) {
+        return undefined;
+    }
+    const fromConfig = isGet ? null : configToastDefaults(configMode);
+    const merged = perRequest
+        ? { ...(fromConfig ?? {}), ...perRequest }
+        : fromConfig;
+    if (!merged) {
+        return undefined;
+    }
+    const success = merged.success ?? true;
+    const error = merged.error ?? true;
+    if (!success && !error) {
+        return undefined;
+    }
+    return withToast({
+        success,
+        error,
+        successMessage: merged.successMessage,
+        errorMessage: merged.errorMessage,
+    });
+}
+function configToastDefaults(mode) {
+    if (mode == null || mode === 'off') {
+        return null;
+    }
+    if (mode === 'errors') {
+        return { success: false, error: true };
+    }
+    if (mode === 'all') {
+        return { success: true, error: true };
+    }
+    return mode;
+}
+
+/**
+ * Build {@link HttpContext} for an {@link ApiClient} request.
+ *
+ * Merges SDK config toasts, per-request toast flags, and optional
+ * {@link ApiRequestOptions.shippingMode} override.
+ *
+ * @param configMode - From {@link AfricaniesSdkConfig.httpToasts}.
+ * @param options - Per-request {@link ApiClient} options.
+ * @param method
+ */
+function resolveApiRequestContext(configMode, options, method) {
+    let context = resolveHttpToastContext(configMode, options.toast, method);
+    const shippingMode = asShippingMode$1(options.shippingMode);
+    if (shippingMode) {
+        context = withShippingMode(shippingMode, context);
+    }
+    return context;
+}
+/**
+ * Effective shipping mode for one {@link ApiClient} request.
+ *
+ * @param options - Per-request options (may include {@link ApiRequestOptions.shippingMode}).
+ * @param activeMode - Current tab mode from {@link ShippingModeService}.
+ */
+function resolveRequestShippingMode(options, activeMode) {
+    return asShippingMode$1(options?.shippingMode) ?? activeMode;
+}
+
+/**
+ * Build a path for the AFRICANIES list/detail `ResourceId` convention.
+ *
+ * | `id` | Path |
+ * |------|------|
+ * | `null` | `{basePath}` — paginated |
+ * | `'all'` | `{basePath}/all` — full list |
+ * | `number` | `{basePath}/{id}` — single record |
+ *
+ * @param basePath - Endpoint base (e.g. `/product/read`).
+ * @param id - {@link ResourceId}; defaults to `null` (paginated).
+ * @returns Absolute-or-relative path segment for {@link ApiClient.get}.
+ *
+ * @example
+ * ```ts
+ * buildResourcePath('/product/read')        // '/product/read'
+ * buildResourcePath('/product/read', 'all') // '/product/read/all'
+ * buildResourcePath('/product/read', 42)    // '/product/read/42'
+ * ```
+ */
+function buildResourcePath(basePath, id = null) {
+    const trimmed = basePath.replace(/\/+$/, '');
+    return id === null ? trimmed : `${trimmed}/${id}`;
+}
+/**
+ * Build query params for a {@link ResourceId} request.
+ *
+ * Pagination fields (`page`, `size`, `order`) are included only when
+ * `id === null`. Other keys are always passed through.
+ *
+ * Paginated lists (`id === null`) always send `size`, defaulting to
+ * {@link DEFAULT_PAGE_SIZE} (`15`) when omitted.
+ *
+ * @param id - Active resource id mode.
+ * @param params - Optional pagination + filter bag.
+ * @returns Params object for {@link ApiClient}, or `undefined` when empty.
+ */
+function buildResourceQueryParams(id, params) {
+    const { page, size, order, ...rest } = params ?? {};
+    const out = {};
+    for (const [key, value] of Object.entries(rest)) {
+        if (value === null || value === undefined || value === '') {
+            continue;
+        }
+        out[key] = value;
+    }
+    if (id === null) {
+        if (page !== undefined) {
+            out['page'] = page;
+        }
+        out['size'] = size ?? DEFAULT_PAGE_SIZE;
+        if (order !== undefined) {
+            out['order'] = order;
+        }
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/**
+ * In-memory GET cache TTL for reference reads.
+ *
+ * Paginated lists (`id === null`) are never cached — page contents change.
+ * `'all'` and by-id may use a short TTL for stable catalogs.
+ *
+ * @param id - Active resource id mode.
+ * @param ttlMs - Desired TTL for stable reads.
+ * @returns TTL to pass to {@link ApiClient}, or `undefined` to skip cache.
+ */
+function resourceCacheTtlMs(id, ttlMs) {
+    return id === null ? undefined : ttlMs;
+}
+/**
+ * Map wire `data` according to {@link ResourceId} shape.
+ *
+ * - `null` / `'all'` → list mapper → `T[]`
+ * - `number` → one mapper → `T` (first element if the wire sent an array)
+ *
+ * @typeParam T - Domain model type.
+ * @param id - Active resource id mode.
+ * @param raw - Envelope `data` payload.
+ * @param mapOne - Mapper for a single record.
+ * @param mapMany - Mapper for a list (or single object coerced to list).
+ * @returns Mapped payload, or `null` when by-id data is missing.
+ *          List reads (`null` / `'all'`) return `[]` when `raw` is nullish.
+ */
+function mapResourcePayload(id, raw, mapOne, mapMany) {
+    if (raw == null) {
+        return typeof id === 'number' ? null : [];
+    }
+    if (typeof id === 'number') {
+        const item = Array.isArray(raw) ? raw[0] : raw;
+        return item == null ? null : mapOne(item);
+    }
+    return mapMany(raw);
+}
+
+/**
+ * Endpoint-agnostic HTTP façade over Angular {@link HttpClient}.
+ *
+ * Domain services own path strings — this client never hard-codes product
+ * routes (except helpers like {@link getResource} that only know conventions).
+ *
+ * Features:
+ * - `responseMode` overloads (`wrapped` | `raw`)
+ * - {@link normalize} on every **2xx** body
+ * - HTTP failures rethrown as `Error` whose `.message` is already
+ *   user-facing ({@link formatApiErrorMessage}) — consumers do not need to
+ *   parse `HttpErrorResponse` bodies
+ * - **No automatic retry** — fail fast so UIs can show Select / table /
+ *   error-state Retry instead of a stuck loading spinner
+ * - Optional per-GET TTL cache via `cacheTtlMs`
+ *
+ * @example
+ * ```ts
+ * const api = inject(ApiClient);
+ * api.get<User>('/users/1').subscribe({
+ *   next: (res) => {
+ *     if (res.success) console.log(res.data);
+ *     else console.error(res.message); // already joined when a validation bag exists
+ *   },
+ *   error: (err: Error) => console.error(err.message),
+ * });
+ * ```
+ */
+/**
+ * Endpoint-agnostic HTTP façade over Angular {@link HttpClient}.
+ */
+class ApiClient {
+    http = inject(HttpClient);
+    config = inject(AFRICANIES_SDK_CONFIG);
+    shippingMode = inject(ShippingModeService);
+    cache = new HttpResponseCache();
+    get(path, options = {}) {
+        return this.request('GET', path, undefined, options);
+    }
+    post(path, body, options = {}) {
+        return this.request('POST', path, body, options);
+    }
+    patch(path, body, options = {}) {
+        return this.request('PATCH', path, body, options);
+    }
+    put(path, body, options = {}) {
+        return this.request('PUT', path, body, options);
+    }
+    delete(path, body, options = {}) {
+        return this.request('DELETE', path, body, options);
+    }
+    getResource(basePath, id, query, options = {}) {
+        const path = buildResourcePath(basePath, id);
+        const params = {
+            mode: resolveRequestShippingMode(options, this.shippingMode.mode()),
+            ...(options.params ?? {}),
+        };
+        // Pagination applies only to the paginated-list shape (id === null).
+        // Size always ships — SDK default is 15 unless the caller overrides.
+        if (id === null) {
+            if (query?.page !== undefined) {
+                params['page'] = query.page;
+            }
+            params['size'] = query?.size ?? DEFAULT_PAGE_SIZE;
+            if (query?.order !== undefined) {
+                params['order'] = query.order;
+            }
+        }
+        const { responseMode: _ignored, ...requestOptions } = options;
+        return this.get(path, { ...requestOptions, params });
+    }
+    /**
+     * Paginated list — {@link ResourceId} `null`.
+     * IDE-friendly alias for `getResource(basePath, null, query)`.
+     *
+     * Page size defaults to {@link DEFAULT_PAGE_SIZE} (`15`) unless
+     * `query.size` is set. Bind `res.pagination` to `africanies-pagination`.
+     *
+     * @typeParam T - Element type of the list.
+     * @param basePath - Resource base path (no trailing id segment).
+     * @param query - Optional page/size/order.
+     */
+    getResourcePage(basePath, query) {
+        return this.getResource(basePath, null, query);
+    }
+    /**
+     * Full unpaginated dump — {@link ResourceId} `'all'`.
+     * IDE-friendly alias for `getResource(basePath, 'all')`.
+     *
+     * @typeParam T - Element type of the list.
+     * @param basePath - Resource base path.
+     */
+    getResourceAll(basePath) {
+        return this.getResource(basePath, 'all');
+    }
+    /**
+     * Single record — {@link ResourceId} number.
+     * IDE-friendly alias for `getResource(basePath, id)`.
+     *
+     * @typeParam T - Record type.
+     * @param basePath - Resource base path.
+     * @param id - Numeric primary key.
+     */
+    getResourceById(basePath, id) {
+        return this.getResource(basePath, id);
+    }
+    /**
+     * Clears the in-memory GET cache (e.g. on logout).
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    buildHttpContext(options, method) {
+        return resolveApiRequestContext(this.config.httpToasts, options, method);
+    }
+    request(method, path, body, options) {
+        const responseMode = options.responseMode ?? 'wrapped';
+        const url = this.resolveUrl(path);
+        const hasBody = method === 'POST' ||
+            method === 'PUT' ||
+            method === 'PATCH' ||
+            (method === 'DELETE' && body !== undefined && body !== null);
+        const isFormData = typeof FormData !== 'undefined' && body instanceof FormData;
+        // FormData must not send application/json — the browser sets multipart + boundary.
+        let headers = this.buildHeaders(options.headers, hasBody && !isFormData);
+        if (isFormData && headers.has('Content-Type')) {
+            headers = headers.delete('Content-Type');
+        }
+        const params = this.buildParams(options.params);
+        const context = this.buildHttpContext(options, method);
+        const cacheKey = method === 'GET' && options.cacheTtlMs != null
+            ? `${method} ${url}?${params.toString()}`
+            : null;
+        if (cacheKey) {
+            const hit = this.cache.get(cacheKey);
+            if (hit !== null) {
+                return of(this.unwrap(hit, responseMode));
+            }
+        }
+        let req$;
+        const httpOpts = context ? { headers, params, context } : { headers, params };
+        switch (method) {
+            case 'GET':
+                req$ = this.http.get(url, httpOpts);
+                break;
+            case 'POST':
+                req$ = this.http.post(url, body, httpOpts);
+                break;
+            case 'PUT':
+                req$ = this.http.put(url, body, httpOpts);
+                break;
+            case 'PATCH':
+                req$ = this.http.patch(url, body, httpOpts);
+                break;
+            case 'DELETE':
+                req$ = this.http.delete(url, hasBody ? { ...httpOpts, body } : httpOpts);
+                break;
+        }
+        // No automatic GET retry — admin shells own Retry via UI
+        // (`africanies-select` showRetry, table error→refreshClick, error-state).
+        if (this.config.timeout != null) {
+            req$ = req$.pipe(timeout({
+                each: this.config.timeout,
+                with: () => throwError(() => new Error(`AFRICANIES API request timed out after ${this.config.timeout}ms: ${method} ${url}`)),
+            }));
+        }
+        return req$.pipe(map$1((raw) => normalize(raw)), tap$1((envelope) => {
+            if (cacheKey && options.cacheTtlMs != null) {
+                this.cache.set(cacheKey, envelope, options.cacheTtlMs);
+            }
+        }), map$1((envelope) => this.unwrap(envelope, responseMode)), catchError((err) => throwError(() => new Error(formatApiErrorMessage(err)))));
+    }
+    unwrap(envelope, responseMode) {
+        if (responseMode === 'raw') {
+            // Callers opting into raw want the payload; null stays null-compatible via cast.
+            return envelope.data;
+        }
+        return envelope;
+    }
+    resolveUrl(path) {
+        if (/^https?:\/\//i.test(path)) {
+            return path;
+        }
+        const base = this.config.baseUrl.replace(/\/+$/, '');
+        const suffix = path.startsWith('/') ? path : `/${path}`;
+        return `${base}${suffix}`;
+    }
+    buildHeaders(extra, withJsonContentType = false) {
+        let headers = new HttpHeaders({
+            Accept: 'application/json',
+            ...(this.config.defaultHeaders ?? {}),
+            ...(extra ?? {}),
+        });
+        // Only set JSON content-type when sending a body; avoid spurious GET headers.
+        if (withJsonContentType && !headers.has('Content-Type')) {
+            headers = headers.set('Content-Type', 'application/json');
+        }
+        return headers;
+    }
+    buildParams(params) {
+        let httpParams = new HttpParams();
+        if (!params) {
+            return httpParams;
+        }
+        for (const [key, value] of Object.entries(params)) {
+            if (value === null || value === undefined || value === '') {
+                continue;
+            }
+            httpParams = httpParams.set(key, String(value));
+        }
+        return httpParams;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ApiClient, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ApiClient, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ApiClient, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/** Public mode-config endpoint path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const MODE_CONFIG_PATH = '/public/mode/config';
+/** Fallback region when the wire omits a required branch/key. */
+const DEFAULT_REGION = {
+    dimension_unit: 'cm',
+    mass_unit: 'KG',
+    currency: 'NGN',
+    currency_symbol: '',
+};
+function asDimensionUnit(value) {
+    return value === 'inches' ? 'inches' : 'cm';
+}
+function asMassUnit(value) {
+    return value === 'LBS' ? 'LBS' : 'KG';
+}
+function asCurrency(value) {
+    return value === 'USD' ? 'USD' : 'NGN';
+}
+/**
+ * Map a region object into {@link ModeRegionConfigModel} (snake_case).
+ * @param raw
+ */
+function mapRegionConfig(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        dimension_unit: asDimensionUnit(record['dimension_unit'] ?? record['dimensionUnit']),
+        mass_unit: asMassUnit(record['mass_unit'] ?? record['massUnit']),
+        currency: asCurrency(record['currency']),
+        currency_symbol: asString(record['currency_symbol'] ?? record['currencySymbol']),
+    };
+}
+/**
+ * Map every region entry under a mode branch (`default`, `ng`, `us`, …).
+ * @param modeRaw
+ */
+function mapModeRegions(modeRaw) {
+    const mode = asRecord(modeRaw) ?? {};
+    const out = {};
+    for (const [key, value] of Object.entries(mode)) {
+        out[key] = mapRegionConfig(value);
+    }
+    return out;
+}
+function regionOrDefault(regions, key) {
+    return regions[key] ?? regions['default'] ?? { ...DEFAULT_REGION };
+}
+/**
+ * Deep-map mode config preserving snake_case region fields.
+ * @param raw
+ */
+function mapModeConfigData(raw) {
+    const record = asRecord(raw) ?? {};
+    const sfnRegions = mapModeRegions(record['sfn']);
+    const stnRegions = mapModeRegions(record['stn']);
+    const sfn = {
+        default: regionOrDefault(sfnRegions, 'default'),
+        ng: regionOrDefault(sfnRegions, 'ng'),
+    };
+    const stn = {
+        default: regionOrDefault(stnRegions, 'default'),
+        us: regionOrDefault(stnRegions, 'us'),
+        cn: regionOrDefault(stnRegions, 'cn'),
+        gb: regionOrDefault(stnRegions, 'gb'),
+    };
+    return { sfn, stn };
+}
+/**
+ * Minimal runtime guard for hydrated storage payloads.
+ * @param value
+ */
+function isModeConfigData(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const record = value;
+    const sfn = record['sfn'];
+    const stn = record['stn'];
+    if (sfn === null || typeof sfn !== 'object' || Array.isArray(sfn)) {
+        return false;
+    }
+    if (stn === null || typeof stn !== 'object' || Array.isArray(stn)) {
+        return false;
+    }
+    const sfnRecord = sfn;
+    const stnRecord = stn;
+    return (sfnRecord['default'] != null &&
+        typeof sfnRecord['default'] === 'object' &&
+        stnRecord['default'] != null &&
+        typeof stnRecord['default'] === 'object');
+}
+/**
+ * Resolve currency and measurement units for a country within a shipping mode.
+ * @param config
+ * @param mode
+ * @param countryCode
+ */
+function resolveModeRegionConfig(config, mode, countryCode) {
+    const regions = mode === 'sfn' ? config?.sfn : config?.stn;
+    const keyed = (regions ?? {});
+    if (countryCode != null && countryCode !== '') {
+        const key = asString(countryCode).toLowerCase();
+        if (key !== 'default') {
+            const region = keyed[key];
+            if (region != null) {
+                return region;
+            }
+        }
+    }
+    return keyed['default'] ?? { ...DEFAULT_REGION };
+}
+
+/**
+ * Source of truth for region currency and measurement units (STN / SFN).
+ *
+ * On startup (via {@link provideModeConfig}), loads
+ * `GET /public/mode/config`, normalizes snake_case wire fields once, and
+ * persists the mapped record to storage. {@link getRegionConfig} reads that
+ * saved record and resolves by country code + active shipping mode.
+ *
+ * @example
+ * ```ts
+ * // app.config.ts
+ * providers: [
+ *   provideAfricaniesSdk({ baseUrl: 'https://test-api-export.africaniestest.com/api' }),
+ *   provideHttpClient(withInterceptors([shipmentModeInterceptor])),
+ *   provideModeConfig(),
+ * ];
+ *
+ * // feature — format for shipment origin country
+ * const modeConfig = inject(ModeConfigService);
+ * const region = modeConfig.getRegionConfig('us');
+ * if (region) {
+ *   console.log(region.currency_symbol, region.mass_unit);
+ * }
+ * ```
+ */
+/**
+ * Source of truth for region currency and measurement units (STN / SFN).
+ */
+class ModeConfigService {
+    api = inject(ApiClient);
+    storage = inject(STORAGE_TOKEN);
+    shippingMode = inject(ShippingModeService);
+    _config = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_config" }] : /* istanbul ignore next */ []));
+    _loading = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_loading" }] : /* istanbul ignore next */ []));
+    /** Latest mode-config record (storage hydrate or last successful fetch). */
+    config = this._config.asReadonly();
+    /** `true` while {@link loadConfig} is in flight. */
+    loading = this._loading.asReadonly();
+    constructor() {
+        this.hydrateFromStorage();
+    }
+    /**
+     * Fetches mode config from the server, updates {@link config}, and persists.
+     *
+     * @returns Normalized API envelope; errors propagate to subscribers.
+     */
+    loadConfig() {
+        this._loading.set(true);
+        return this.api.get(MODE_CONFIG_PATH).pipe(tap$1((res) => {
+            if (res.success && res.data !== null) {
+                this.saveRecord(mapModeConfigData(res.data));
+            }
+        }), finalize(() => {
+            this._loading.set(false);
+        }));
+    }
+    /**
+     * Region units and currency for a country code under the active (or given) mode.
+     *
+     * @param countryCode - e.g. `'ng'`, `'us'`, `'cn'` — unknown keys use `default`.
+     * @param appType - Defaults to {@link ShippingModeService.mode}.
+     * @returns Resolved region, or `null` before the first load/hydrate.
+     */
+    getRegionConfig(countryCode, appType) {
+        const config = this._config();
+        if (config === null) {
+            return null;
+        }
+        const mode = appType ?? this.shippingMode.mode();
+        return resolveModeRegionConfig(config, mode, countryCode);
+    }
+    /**
+     * Replace the in-memory record and persist — used after {@link loadConfig}.
+     * @param config
+     */
+    saveRecord(config) {
+        this._config.set(config);
+        this.storage.set(AFRICANIES_MODE_CONFIG_KEY, config);
+    }
+    /** Restore the last saved server record so region lookups work offline. */
+    hydrateFromStorage() {
+        const stored = this.storage.get(AFRICANIES_MODE_CONFIG_KEY);
+        if (isModeConfigData(stored)) {
+            this._config.set(stored);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ModeConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ModeConfigService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ModeConfigService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Fetches `/public/mode/config` on app startup and hydrates {@link ModeConfigService}.
+ *
+ * Failures do not block bootstrap — cached storage (if any) remains usable.
+ * Pair with {@link provideAfricaniesSdk} and a real {@link AfricaniesSdkConfig.baseUrl}.
+ *
+ * @returns Environment providers that run the mode-config initializer.
+ */
+function provideModeConfig() {
+    return makeEnvironmentProviders([
+        provideAppInitializer(() => {
+            const modeConfig = inject(ModeConfigService);
+            return firstValueFrom(modeConfig.loadConfig().pipe(catchError(() => of(null))));
+        }),
+    ]);
+}
+
+/**
+ * Registers SDK configuration and ensures browser storage is available.
+ *
+ * Also calls {@link provideLocalStorage} so theme / mode-config / auth-token
+ * persistence works out of the box. {@link ShippingModeService} always uses
+ * {@link SessionStorageService} so each tab can hold its own STN/SFN mode.
+ * When {@link AfricaniesSdkConfig.loadModeConfig} is not `false`, {@link provideModeConfig}
+ * runs on startup.
+ *
+ * @param config - API origin and optional timeout / default headers.
+ * @returns Environment providers for `app.config.ts`.
+ *
+ * @example
+ * ```ts
+ * // app.config.ts
+ * import { ApplicationConfig } from '@angular/core';
+ * import {
+ *   provideAfricaniesSdk,
+ *   provideAfricaniesHttpClient,
+ * } from '@africanies/africanies-core';
+ * import { provideSessionStorage } from '@africanies/africanies-storage';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideAfricaniesSdk({
+ *       baseUrl: import.meta.env['NG_APP_API_URL'],
+ *       timeout: 30_000,
+ *     }),
+ *     // Optional: override the localStorage default registered above
+ *     // provideSessionStorage(),
+ *     provideAfricaniesHttpClient(),
+ *     // Or with app interceptors:
+ *     // provideAfricaniesHttpClient({ interceptors: [loggingInterceptor] }),
+ *   ],
+ * };
+ * ```
+ */
+function provideAfricaniesSdk(config) {
+    return makeEnvironmentProviders([
+        { provide: AFRICANIES_SDK_CONFIG, useValue: config },
+        provideLocalStorage(),
+        ...(config.loadModeConfig !== false ? [provideModeConfig()] : []),
+    ]);
+}
+
+/** Forgot-password path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const AUTH_FORGOT_PASSWORD_PATH = '/auth/forgot/password';
+
+/**
+ * Unauthenticated auth endpoints (`POST /auth/…`).
+ *
+ * **Forgot password is email-only.** `forgot()` POSTs `{ email }`; the
+ * backend emails a reset link. This product UI never collects a new password
+ * for that link (no token in the route, `/onboarding/reset-password` is
+ * **not** that flow).
+ *
+ * `/onboarding/reset-password` is first login with a default password: after
+ * login, if `user.default_password` is set, the host sends the user there to
+ * change current → new via {@link UserService.changePassword}.
+ *
+ * Token persistence stays on {@link AuthTokenService}. These calls do not
+ * require a bearer token — the interceptor omits `Authorization` when none
+ * is stored. Admin user/partner screens reuse {@link forgot} with that
+ * user’s email.
+ *
+ * @example
+ * ```ts
+ * const authApi = inject(AuthService);
+ *
+ * authApi.forgot('user@example.com').subscribe((res) => {
+ *   if (res.success) {
+ *     // Show res.message, then “Reset completed? Login here”.
+ *   }
+ * });
+ * ```
+ */
+/**
+ * Unauthenticated auth endpoints (`POST /auth/…`).
+ */
+class AuthService {
+    api = inject(ApiClient);
+    /**
+     * Request a password-reset email (`POST /auth/forgot/password`).
+     *
+     * Enable submit only when the address looks valid. Wire `data` is an empty
+     * array on success — use {@link ApiResponseModel.message} for the banner.
+     *
+     * @param email - Registered account email.
+     * @returns Normalized envelope (`data` is typically `[]`).
+     */
+    forgot(email) {
+        return this.api.post(AUTH_FORGOT_PASSWORD_PATH, { email: asString(email).trim() });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Holds the bearer access token used by {@link authInterceptor}.
+ *
+ * After login/register in the host app, call {@link set}. The SDK persists the
+ * token via {@link STORAGE_TOKEN} and attaches `Authorization: Bearer …` on
+ * outbound HTTP. On logout, call {@link UserService.logoutFromAllSessions}
+ * while the token is still set, then {@link clear} (also clears the GET cache).
+ *
+ * @example
+ * ```ts
+ * const auth = inject(AuthTokenService);
+ * const users = inject(UserService);
+ *
+ * // after login
+ * auth.set(res.access_token);
+ *
+ * // later — UserService.me() is authenticated automatically
+ * // on logout — POST while the token is still set, then drop it
+ * users.logoutFromAllSessions().subscribe({
+ *   next: () => auth.clear(),
+ *   error: () => auth.clear(),
+ * });
+ * ```
+ */
+/**
+ * Holds the bearer access token used by {@link authInterceptor}.
+ */
+class AuthTokenService {
+    storage = inject(STORAGE_TOKEN);
+    api = inject(ApiClient);
+    _token = signal(this.readInitialToken(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_token" }] : /* istanbul ignore next */ []));
+    /** Read-only view of the current access token. */
+    token = this._token.asReadonly();
+    /**
+     * Current access token, or `null` when logged out / unset.
+     */
+    get() {
+        return this._token();
+    }
+    /**
+     * Persist and activate an access token from login/register.
+     *
+     * @param accessToken - Bearer token string (whitespace-only is treated as clear).
+     */
+    set(accessToken) {
+        const trimmed = asString(accessToken).trim();
+        if (trimmed === '') {
+            this.clear();
+            return;
+        }
+        this._token.set(trimmed);
+        this.storage.set(AFRICANIES_ACCESS_TOKEN_KEY, trimmed);
+    }
+    /**
+     * Remove the token from memory and storage, and clear the HTTP GET cache.
+     */
+    clear() {
+        this._token.set(null);
+        this.storage.remove(AFRICANIES_ACCESS_TOKEN_KEY);
+        this.api.clearCache();
+    }
+    readInitialToken() {
+        const stored = this.storage.get(AFRICANIES_ACCESS_TOKEN_KEY);
+        if (typeof stored !== 'string') {
+            return null;
+        }
+        const trimmed = stored.trim();
+        return trimmed === '' ? null : trimmed;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AuthTokenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AuthTokenService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AuthTokenService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Enable forgot-password submit when the address looks like an email.
+ *
+ * Intentionally loose (`local@host.tld`) — the API owns uniqueness and
+ * deliverability. Empty / whitespace-only values fail.
+ *
+ * @param value - Raw field value.
+ * @returns Whether submit should be enabled.
+ */
+function isValidEmail(value) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(asString(value).trim());
+}
+
+/**
+ * Attaches the current shipping mode as an `x-shipment-mode` header.
+ *
+ * Uses {@link SHIPPING_MODE_OVERRIDE} when the request was tagged (via
+ * {@link ApiRequestOptions.shippingMode} or {@link withShippingMode});
+ * otherwise {@link ShippingModeService.mode}. The tab mode is never mutated.
+ *
+ * Some backends also expect `mode` as a query param (see {@link ApiClient.getResource});
+ * this interceptor covers the header half so domain calls stay consistent
+ * without each service remembering the header name.
+ *
+ * Prefer {@link provideAfricaniesHttpClient}, which registers this interceptor by
+ * default. {@link ShippingModeService} is `providedIn: 'root'` and needs no
+ * extra provider.
+ *
+ * @param req - Outgoing request.
+ * @param next - Next handler in the interceptor chain.
+ * @returns The downstream observable for the cloned request.
+ * @example
+ * ```ts
+ * provideAfricaniesSdk({ baseUrl: 'https://api.example.com' }),
+ * provideAfricaniesHttpClient(),
+ *
+ * api.post('/claim', body, { shippingMode: 'stn' });
+ * ```
+ */
+const shipmentModeInterceptor = (req, next) => {
+    const override = req.context.get(SHIPPING_MODE_OVERRIDE);
+    const mode = override ?? inject(ShippingModeService).mode();
+    return next(req.clone({
+        setHeaders: { 'x-shipment-mode': mode },
+    }));
+};
+
+/**
+ * Functional interceptor that sets `Authorization: Bearer <token>` when
+ * {@link AuthTokenService} has an access token (from {@link AuthTokenService.set}).
+ *
+ * Compose via {@link provideAfricaniesHttpClient} (preferred) or pass explicitly to
+ * `provideHttpClient(withInterceptors([...]))`.
+ * @param req
+ * @param next
+ */
+const authInterceptor = (req, next) => {
+    const token = inject(AuthTokenService).get();
+    if (token === null || token === '') {
+        return next(req);
+    }
+    return next(req.clone({
+        setHeaders: { Authorization: `Bearer ${token}` },
+    }));
+};
+
+/**
+ * Shows success / error toasts for requests tagged with {@link withToast}.
+ *
+ * Requires {@link AFRICANIES_HTTP_TOAST} (from `provideAfricaniesToasts` in `@africanies/africanies-ui`).
+ * Untagged requests never toast. Missing handler → silent no-op.
+ * @param req - Outgoing HTTP request.
+ * @param next - Next interceptor handler.
+ * @returns Observable for the HTTP response stream.
+ */
+const httpToastInterceptor = (req, next) => {
+    const options = req.context.get(TOAST_HTTP_OPTIONS);
+    if (!options) {
+        return next(req);
+    }
+    const toast = inject(AFRICANIES_HTTP_TOAST, { optional: true });
+    if (!toast) {
+        return next(req);
+    }
+    return next(req).pipe(tap$1(() => {
+        if (options.success) {
+            toast.success(options.successMessage ?? 'Done');
+        }
+    }), catchError((err) => {
+        if (options.error) {
+            toast.error(options.errorMessage ?? defaultHttpErrorMessage(err));
+        }
+        return throwError(() => err);
+    }));
+};
+/**
+ * @param err - Failure from HttpClient.
+ * @returns User-facing copy (joined field errors when the body is a validation bag).
+ */
+function defaultHttpErrorMessage(err) {
+    return formatApiErrorMessage(err);
+}
+
+/**
+ * Deep-map arbitrary JSON into {@link ApiJsonValue} with no `undefined`.
+ *
+ * - `undefined` / unsupported types → `null`
+ * - Arrays → every element mapped (never sparse/`undefined` slots)
+ * - Objects → every own key mapped to {@link ApiJsonValue}
+ *
+ * @param raw - Wire value (may be missing or malformed).
+ * @returns Null-safe JSON tree, or `null` when `raw` is nullish/unusable.
+ */
+function mapApiJsonValue(raw) {
+    if (raw === null || raw === undefined) {
+        return null;
+    }
+    if (typeof raw === 'string' || typeof raw === 'boolean') {
+        return raw;
+    }
+    if (typeof raw === 'number') {
+        return Number.isFinite(raw) ? raw : null;
+    }
+    if (Array.isArray(raw)) {
+        return raw.map((entry) => mapApiJsonValue(entry) ?? null);
+    }
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(record)) {
+        out[key] = mapApiJsonValue(value) ?? null;
+    }
+    return out;
+}
+/**
+ * Map a wire list into a null-safe {@link ApiJsonValue} array.
+ * Non-arrays become `[]`.
+ * @param raw - Candidate list.
+ * @returns Mapped array (never null/undefined).
+ */
+function mapApiJsonList(raw) {
+    return asArray(raw).map((entry) => mapApiJsonValue(entry) ?? null);
+}
+
+/**
+ * Registers `HttpClient` with AFRICANIES default interceptors baked in.
+ *
+ * Defaults (in order):
+ * 1. {@link shipmentModeInterceptor} — `x-shipment-mode`
+ * 2. {@link authInterceptor} — `Authorization` when {@link AuthTokenService} has a token
+ * 3. {@link httpToastInterceptor} — toasts for requests tagged with {@link withToast}
+ *    (no-op until `provideAfricaniesToasts()` registers {@link AFRICANIES_HTTP_TOAST})
+ * 4. Any {@link AfricaniesHttpClientOptions.interceptors} from the host
+ *
+ * @param options - Optional extra interceptors.
+ * @param features - Extra `provideHttpClient` features (`withFetch`, etc.).
+ * @returns Environment providers for `app.config.ts`.
+ *
+ * @example
+ * ```ts
+ * provideAfricaniesSdk({ baseUrl: 'https://api.example.com' }),
+ * provideAfricaniesHttpClient(),
+ * provideAfricaniesToasts(), // from @africanies/africanies-ui — enables HTTP toasts
+ * ```
+ */
+function provideAfricaniesHttpClient(options, ...features) {
+    const extras = options?.interceptors ?? [];
+    return provideHttpClient(withInterceptors([
+        shipmentModeInterceptor,
+        authInterceptor,
+        httpToastInterceptor,
+        ...extras,
+    ]), ...features);
+}
+
+/**
+ * Pick blocking vs keep-rows fetch for a list table.
+ *
+ * Body loading only when there is no initial data or the shipping mode
+ * switched. Page/size keeps rows. Tab focus and Refresh keep rows.
+ *
+ * @param options
+ * @param options.hasData - Rows from the *current* mode are already on screen.
+ * @param options.reason - What triggered this fetch.
+ * @returns Kind to map onto `loading` / `pageLoading` / `refreshing`.
+ *
+ * @example
+ * ```ts
+ * const kind = listFetchKind({
+ *   hasData: this.rows().length > 0,
+ *   reason: 'mode',
+ * });
+ * this.isLoading.set(kind === 'loading');
+ * if (kind === 'loading') {
+ *   this.rows.set([]);
+ * }
+ * ```
+ */
+function listFetchKind(options) {
+    if (!options.hasData || options.reason === 'mode') {
+        return 'loading';
+    }
+    if (options.reason === 'page') {
+        return 'pagination';
+    }
+    return 'refreshing';
+}
+
+/**
+ * Shared TanStack Query defaults for AFRICANIES consuming apps.
+ *
+ * `@tanstack/angular-query-experimental` is **not** a dependency of this SDK —
+ * query cache lifetime is app state. These helpers return a plain
+ * `defaultOptions` object you pass into your own `QueryClient`.
+ *
+ * Pin an **exact** `@tanstack/angular-query-experimental` version in the app
+ * (no caret/tilde): TanStack marks the Angular adapter experimental and
+ * breaking changes land without major bumps.
+ *
+ * Query retries default to **0** to match {@link ApiClient} (fail fast;
+ * screens use manual Retry). Apps can override per `QueryClient` if needed.
+ */
+/**
+ * Factory for TanStack `QueryClient` `defaultOptions`.
+ *
+ * @returns Plain defaults object — no Angular providers, no TanStack imports.
+ *
+ * @example
+ * ```ts
+ * // app.config.ts — pin exact experimental version in package.json
+ * import {
+ *   provideAngularQuery,
+ *   QueryClient,
+ * } from '@tanstack/angular-query-experimental';
+ * import { createAfricaniesQueryClientDefaults } from '@africanies/africanies-core';
+ *
+ * const queryClient = new QueryClient({
+ *   defaultOptions: createAfricaniesQueryClientDefaults(),
+ * });
+ *
+ * export const appConfig = {
+ *   providers: [provideAngularQuery(queryClient)],
+ * };
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Map injectQuery() signals → AsyncQueryStateModel for <africanies-async-state>
+ * import type { AsyncQueryStateModel } from '@africanies/africanies-models';
+ * import { injectQuery } from '@tanstack/angular-query-experimental';
+ *
+ * const query = injectQuery(() => ({
+ *   queryKey: ['shipments'],
+ *   queryFn: () => firstValueFrom(api.getResource<Shipment>('shipments', null)),
+ * }));
+ *
+ * const state: AsyncQueryStateModel<Shipment[] | null> = {
+ *   data: query.data()?.data ?? undefined,
+ *   isLoading: query.isLoading(),
+ *   isFetching: query.isFetching(),
+ *   isError: query.isError(),
+ *   error: query.error()?.message ?? null,
+ * };
+ * ```
+ */
+function createAfricaniesQueryClientDefaults() {
+    return {
+        queries: {
+            staleTime: 60_000,
+            gcTime: 5 * 60_000,
+            retry: 0,
+            retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30_000),
+        },
+        mutations: {
+            retry: 0,
+        },
+    };
+}
+/**
+ * Alias of {@link createAfricaniesQueryClientDefaults} for apps that prefer a
+ * `provide*` naming style beside {@link provideAfricaniesSdk}.
+ *
+ * Returns a plain object (not `EnvironmentProviders`) so it can be passed
+ * straight into `new QueryClient({ defaultOptions: ... })`.
+ *
+ * @returns Same object as {@link createAfricaniesQueryClientDefaults}.
+ *
+ * @example
+ * ```ts
+ * const queryClient = new QueryClient({
+ *   defaultOptions: provideAfricaniesQueryDefaults(),
+ * });
+ * ```
+ */
+function provideAfricaniesQueryDefaults() {
+    return createAfricaniesQueryClientDefaults();
+}
+
+/** Public country-read base path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const COUNTRY_READ_PATH = '/public/country/read';
+/**
+ * Map a wire state object into {@link CountryStateModel} (snake_case preserved).
+ * @param raw - State object from the wire.
+ * @returns Normalized {@link CountryStateModel}.
+ */
+function mapCountryState(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        name: asString(record['name']),
+        state_code: asString(record['state_code'] ?? record['stateCode']),
+    };
+}
+/**
+ * Map a wire country object into {@link CountryModel} (snake_case preserved).
+ * @param raw - Country object from the wire.
+ * @returns Normalized {@link CountryModel}.
+ */
+function mapCountry(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        name: asString(record['name']),
+        iso3: asString(record['iso3']),
+        iso2: asString(record['iso2']),
+        states: mapArray(record['states'], mapCountryState),
+    };
+}
+/**
+ * Map a list (or single object) payload into {@link CountryModel}[].
+ *
+ * @param raw - `data` payload from `/public/country/read/{id|all}`.
+ * @returns Mapped country list (empty when `raw` is null/undefined).
+ */
+function mapCountryList(raw) {
+    return mapList(raw, mapCountry);
+}
+
+/** In-memory GET cache TTL for country reference dumps / by-id (5 minutes). */
+const COUNTRY_CACHE_TTL_MS = 5 * 60_000;
+/**
+ * Public country utility reads (`GET /public/country/read/{id?}`).
+ *
+ * Uses the AFRICANIES {@link ResourceId} convention:
+ * - `null` (default) → paginated page
+ * - `'all'` → full list
+ * - `number` → single {@link CountryModel}
+ *
+ * @example
+ * ```ts
+ * const countries = inject(CountryService);
+ *
+ * countries.read(null, { page: 1 }).subscribe((res) => {
+ *   console.log(res.data, res.pagination);
+ * });
+ *
+ * countries.readAll().subscribe((res) => console.log(res.data?.length));
+ * countries.readById(1).subscribe((res) => console.log(res.data?.name));
+ * ```
+ */
+/**
+ * Public country utility reads (`GET /public/country/read/{id?}`).
+ */
+class CountryService {
+    api = inject(ApiClient);
+    read(id = null, params) {
+        return this.api
+            .get(buildResourcePath(COUNTRY_READ_PATH, id), {
+            params: buildResourceQueryParams(id, params),
+            cacheTtlMs: resourceCacheTtlMs(id, COUNTRY_CACHE_TTL_MS),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: mapResourcePayload(id, res.data, mapCountry, mapCountryList),
+        })));
+    }
+    /**
+     * Paginated page — alias for {@link read}(`null`, params).
+     * @param params
+     */
+    readPage(params) {
+        return this.read(null, params);
+    }
+    /**
+     * Full list — alias for {@link read}(`'all'`).
+     * @param params
+     */
+    readAll(params) {
+        return this.read('all', params);
+    }
+    /**
+     * Single record — alias for {@link read}(id).
+     * @param id
+     * @param params
+     */
+    readById(id, params) {
+        return this.read(id, params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: CountryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: CountryService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: CountryService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/** Default CDN for ISO country flags ([flagcdn.com](https://flagcdn.com)). */
+const COUNTRY_FLAG_CDN_BASE = 'https://flagcdn.com';
+/**
+ * Build a flagcdn.com URL from an ISO 3166-1 alpha-2 code.
+ *
+ * Examples:
+ * - `countryFlagUrl('NG')` → `https://flagcdn.com/w40/ng.png`
+ * - `countryFlagUrl('us', { width: 80, format: 'webp' })` → `https://flagcdn.com/w80/us.webp`
+ *
+ * @param iso2 - Two-letter country code (case-insensitive).
+ * @param options - Width, height, or format overrides.
+ * @returns CDN URL, or `''` when `iso2` is not two letters.
+ */
+function countryFlagUrl(iso2, options = {}) {
+    const code = iso2.trim().toLowerCase();
+    if (!/^[a-z]{2}$/.test(code)) {
+        return '';
+    }
+    const format = options.format ?? 'png';
+    if (options.height != null) {
+        return `${COUNTRY_FLAG_CDN_BASE}/h${options.height}/${code}.${format}`;
+    }
+    const width = options.width ?? 40;
+    return `${COUNTRY_FLAG_CDN_BASE}/w${width}/${code}.${format}`;
+}
+/**
+ * Map {@link CountryModel} rows into select options with flag CDN URLs.
+ *
+ * @param countries - Countries from {@link CountryService.readAll} / `readPage`.
+ * @param options - Passed through to {@link countryFlagUrl}.
+ */
+function mapCountrySelectOptions(countries, options) {
+    if (!countries?.length) {
+        return [];
+    }
+    return countries.map((country) => ({
+        label: country.name,
+        value: country.id,
+        iso2: country.iso2,
+        prefixImageUrl: countryFlagUrl(country.iso2, options),
+    }));
+}
+
+/**
+ * Public country utility exports.
+ */
+
+/** File read path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const FILE_READ_PATH = '/file/read';
+/** Query flag for multi-file waybill reads (`POST /file/read?multiple=yes`). */
+const FILE_READ_MULTIPLE_PARAM = 'yes';
+/**
+ * Map wire `data` into {@link FileReadModel} (snake_case preserved).
+ *
+ * `POST /file/read` returns a single object in `data` (not a list).
+ * If the wire unexpectedly sends a one-element array, the first entry is used.
+ *
+ * @param raw - Envelope `data` from `POST /file/read`.
+ * @returns Normalized {@link FileReadModel}.
+ */
+function mapFileRead(raw) {
+    const entry = Array.isArray(raw) ? raw[0] : raw;
+    const record = asRecord(entry) ?? {};
+    return {
+        mime_type: asString(record['mime_type'] ?? record['mimeType']),
+        base_64: asString(record['base_64'] ?? record['base64']),
+        url: asString(record['url']),
+    };
+}
+/**
+ * Map a list (or single object) payload into {@link FileReadModel}[].
+ *
+ * Used for `POST /file/read?multiple=yes` (e-commerce waybills).
+ *
+ * @param raw - Envelope `data` from multi-file reads.
+ * @returns Mapped file list (empty when `raw` is null/undefined).
+ */
+function mapFileReadList(raw) {
+    if (Array.isArray(raw)) {
+        return raw.map((entry) => mapFileRead(entry));
+    }
+    if (raw == null) {
+        return [];
+    }
+    return [mapFileRead(raw)];
+}
+
+/** Public document read base path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const DOCUMENT_READ_PATH = '/public/document/read';
+/**
+ * Map nested or legacy flat preview fields into {@link FileReadModel}.
+ * @param record - Document wire object.
+ */
+function mapDocumentFileRef(record) {
+    const nested = asRecord(record['file_ref'] ?? record['fileRef']);
+    if (nested !== null) {
+        return mapFileRead(nested);
+    }
+    const mime_type = asNullableString(record['mime_type'] ?? record['mimeType']);
+    const base_64 = asNullableString(record['base_64'] ?? record['base64']);
+    const url = asNullableString(record['url']);
+    if (mime_type === null && base_64 === null && url === null) {
+        return null;
+    }
+    return mapFileRead({
+        mime_type,
+        base_64,
+        url,
+    });
+}
+/**
+ * Map a wire document into {@link DocumentModel} (snake_case preserved).
+ * @param raw - Single document object from the API.
+ * @returns Normalized {@link DocumentModel}.
+ */
+function mapDocument(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        name: asString(record['name']),
+        description: asNullableString(record['description']),
+        type: asNullableString(record['type']),
+        active: asBoolean(record['active']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        file_ref: mapDocumentFileRef(record),
+    };
+}
+/**
+ * Map a list (or single object) payload into {@link DocumentModel}[].
+ * @param raw - `data` payload from `/public/document/read/{id|all}`.
+ * @returns Mapped document list.
+ */
+function mapDocumentList(raw) {
+    return mapList(raw, mapDocument);
+}
+
+/** In-memory GET cache TTL for document reference dumps / by-id (5 minutes). */
+const DOCUMENT_CACHE_TTL_MS = 5 * 60_000;
+/**
+ * Public document catalog reads (`GET /public/document/read/{id?}`).
+ *
+ * Uses the AFRICANIES {@link ResourceId} convention:
+ * - `null` (default) → paginated page
+ * - `'all'` → full list
+ * - `number` → single {@link DocumentModel} (may include preview `url` / `base_64`)
+ *
+ * @example
+ * ```ts
+ * const documents = inject(DocumentService);
+ *
+ * documents.readPage({ page: 1 }).subscribe((res) => {
+ *   console.log(res.data, res.pagination);
+ * });
+ * documents.readById(12).subscribe((res) => {
+ *   console.log(res.data?.url ?? res.data?.base_64);
+ * });
+ * ```
+ */
+/**
+ * Public document catalog reads (`GET /public/document/read/{id?}`).
+ */
+class DocumentService {
+    api = inject(ApiClient);
+    read(id = null, params) {
+        return this.api
+            .get(buildResourcePath(DOCUMENT_READ_PATH, id), {
+            params: buildResourceQueryParams(id, params),
+            cacheTtlMs: resourceCacheTtlMs(id, DOCUMENT_CACHE_TTL_MS),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: mapResourcePayload(id, res.data, mapDocument, mapDocumentList),
+        })));
+    }
+    /**
+     * Paginated page — alias for {@link read}(`null`, params).
+     * @param params
+     */
+    readPage(params) {
+        return this.read(null, params);
+    }
+    /**
+     * Full list — alias for {@link read}(`'all'`).
+     * @param params
+     */
+    readAll(params) {
+        return this.read('all', params);
+    }
+    /**
+     * Single record — alias for {@link read}(id).
+     * @param id
+     * @param params
+     */
+    readById(id, params) {
+        return this.read(id, params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: DocumentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: DocumentService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: DocumentService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Public document catalog exports.
+ */
+
+/** Public plan read base path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const PLAN_READ_PATH = '/public/plan/read';
+/**
+ * Map a wire plan package into {@link PlanPackageModel}.
+ * @param raw - Package object nested under a plan.
+ * @returns Normalized {@link PlanPackageModel}.
+ */
+function mapPlanPackage(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        plan_id: asNullableNumber(record['plan_id'] ?? record['planId']),
+        company_service_id: asNullableNumber(record['company_service_id'] ?? record['companyServiceId']),
+        name: asString(record['name']),
+        metrics: asNullableString(record['metrics']),
+        volume: asNullableNumber(record['volume']),
+        discount: asNullableString(record['discount']),
+        model: asNullableString(record['model']),
+        monthly: asNullableString(record['monthly']),
+        quarterly: asNullableString(record['quarterly']),
+        biannually: asNullableString(record['biannually']),
+        annually: asNullableString(record['annually']),
+        active: asBoolean(record['active']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+    };
+}
+/**
+ * Map a wire plan into {@link PlanModel} (snake_case preserved).
+ * @param raw - Single plan object from the API.
+ * @returns Normalized {@link PlanModel}.
+ */
+function mapPlan(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        name: asString(record['name']),
+        active: asBoolean(record['active']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        packages: mapArray(record['packages'], mapPlanPackage),
+    };
+}
+/**
+ * Map a list (or single object) payload into {@link PlanModel}[].
+ * @param raw - `data` payload from `/public/plan/read/{id|all}`.
+ * @returns Mapped plan list.
+ */
+function mapPlanList(raw) {
+    return mapList(raw, mapPlan);
+}
+
+/** In-memory GET cache TTL for plan reference dumps / by-id (5 minutes). */
+const PLAN_CACHE_TTL_MS = 5 * 60_000;
+/**
+ * Public subscription-plan reads (`GET /public/plan/read/{id?}`).
+ *
+ * Uses the AFRICANIES {@link ResourceId} convention:
+ * - `null` (default) → paginated page
+ * - `'all'` → full list
+ * - `number` → single {@link PlanModel}
+ *
+ * @example
+ * ```ts
+ * const plans = inject(PlanService);
+ *
+ * plans.readPage({ page: 1, order: 'desc' }).subscribe((res) => {
+ *   console.log(res.data, res.pagination);
+ * });
+ * plans.readById(1).subscribe((res) => {
+ *   console.log(res.data?.packages?.length);
+ * });
+ * ```
+ */
+/**
+ * Public subscription-plan reads (`GET /public/plan/read/{id?}`).
+ */
+class PlanService {
+    api = inject(ApiClient);
+    read(id = null, params) {
+        return this.api
+            .get(buildResourcePath(PLAN_READ_PATH, id), {
+            params: buildResourceQueryParams(id, params),
+            cacheTtlMs: resourceCacheTtlMs(id, PLAN_CACHE_TTL_MS),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: mapResourcePayload(id, res.data, mapPlan, mapPlanList),
+        })));
+    }
+    /**
+     * Paginated page — alias for {@link read}(`null`, params).
+     * @param params
+     */
+    readPage(params) {
+        return this.read(null, params);
+    }
+    /**
+     * Full list — alias for {@link read}(`'all'`).
+     * @param params
+     */
+    readAll(params) {
+        return this.read('all', params);
+    }
+    /**
+     * Single record — alias for {@link read}(id).
+     * @param id
+     * @param params
+     */
+    readById(id, params) {
+        return this.read(id, params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PlanService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PlanService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PlanService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Public plan catalog exports.
+ */
+
+/** Public service read base path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const SERVICE_READ_PATH = '/public/service/read';
+/**
+ * Map a wire service into {@link ServiceModel} (snake_case preserved).
+ * @param raw - Single service object from the API.
+ * @returns Normalized {@link ServiceModel}.
+ */
+function mapService(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        name: asString(record['name']),
+        description: asNullableString(record['description']),
+        model: asString(record['model']),
+        active: asBoolean(record['active']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+    };
+}
+/**
+ * Map a list (or single object) payload into {@link ServiceModel}[].
+ * @param raw - `data` payload from `/public/service/read/{id|all}`.
+ * @returns Mapped service list.
+ */
+function mapServiceList(raw) {
+    return mapList(raw, mapService);
+}
+
+/** In-memory GET cache TTL for service reference dumps / by-id (5 minutes). */
+const SERVICE_CACHE_TTL_MS = 5 * 60_000;
+/**
+ * Public subscription-service reads (`GET /public/service/read/{id?}`).
+ *
+ * Uses the AFRICANIES {@link ResourceId} convention:
+ * - `null` (default) → paginated page
+ * - `'all'` → full list
+ * - `number` → single {@link ServiceModel}
+ *
+ * @example
+ * ```ts
+ * const services = inject(ServiceService);
+ *
+ * services.readPage({ page: 1, search: 'box' }).subscribe((res) => {
+ *   console.log(res.data, res.pagination);
+ * });
+ * services.readAll().subscribe((res) => console.log(res.data?.length));
+ * services.readById(3).subscribe((res) => console.log(res.data?.name));
+ * ```
+ */
+/**
+ * Public subscription-service reads (`GET /public/service/read/{id?}`).
+ */
+class ServiceService {
+    api = inject(ApiClient);
+    read(id = null, params) {
+        return this.api
+            .get(buildResourcePath(SERVICE_READ_PATH, id), {
+            params: buildResourceQueryParams(id, params),
+            cacheTtlMs: resourceCacheTtlMs(id, SERVICE_CACHE_TTL_MS),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: mapResourcePayload(id, res.data, mapService, mapServiceList),
+        })));
+    }
+    /**
+     * Paginated page — alias for {@link read}(`null`, params).
+     * @param params
+     */
+    readPage(params) {
+        return this.read(null, params);
+    }
+    /**
+     * Full list — alias for {@link read}(`'all'`).
+     * @param params
+     */
+    readAll(params) {
+        return this.read('all', params);
+    }
+    /**
+     * Single record — alias for {@link read}(id).
+     * @param id
+     * @param params
+     */
+    readById(id, params) {
+        return this.read(id, params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ServiceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ServiceService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ServiceService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Public service catalog exports.
+ */
+
+/** Currency read base path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const CURRENCY_READ_PATH = '/currency/read';
+/** Create path (App Settings → Currencies). */
+const CURRENCY_CREATE_PATH = '/currency/create';
+/** Update path — name / short_code are not sent. */
+const CURRENCY_UPDATE_PATH = '/currency/update';
+/** Delete path — JSON body `{ id }`. */
+const CURRENCY_DELETE_PATH = '/currency/delete';
+/**
+ * Serialize a boolean / `"1"` / `"0"` flag for currency create/update.
+ * @param value - Host boolean or wire flag.
+ * @returns `"1"` or `"0"`.
+ */
+function toCurrencyFlag01(value) {
+    return toFlag01(value);
+}
+/**
+ * Map a currency ↔ payment-method pivot (snake_case preserved).
+ * @param raw - Pivot object from the wire.
+ * @returns Normalized {@link CurrencyPaymentMethodPivotModel}.
+ */
+function mapCurrencyPaymentMethodPivot(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        currency_id: asNumber(record['currency_id'] ?? record['currencyId']),
+        payment_method_id: asNumber(record['payment_method_id'] ?? record['paymentMethodId']),
+    };
+}
+/**
+ * Map a wire payment method into {@link CurrencyPaymentMethodModel}.
+ * @param raw - Payment-method object from the wire.
+ * @returns Normalized {@link CurrencyPaymentMethodModel}.
+ */
+function mapCurrencyPaymentMethod(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        name: asString(record['name']),
+        model: asString(record['model']),
+        active: asBoolean(record['active']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        pivot: mapCurrencyPaymentMethodPivot(record['pivot']),
+    };
+}
+/**
+ * Map a wire currency into {@link CurrencyModel} (snake_case preserved).
+ * @param raw - Currency object from the API.
+ * @returns Normalized {@link CurrencyModel}.
+ */
+function mapCurrency(raw) {
+    const record = asRecord(raw) ?? {};
+    const payment_methods = mapArray(record['payment_methods'] ?? record['paymentMethods'], mapCurrencyPaymentMethod);
+    const nairaGreater = asBoolean(record['is_naira_greater'] ??
+        record['isNairaGreater'] ??
+        record['is_local_currency_greater'] ??
+        record['isLocalCurrencyGreater']);
+    return {
+        id: asNumber(record['id']),
+        name: asString(record['name']),
+        short_code: asString(record['short_code'] ?? record['shortCode']),
+        division_rate: asString(record['division_rate'] ?? record['divisionRate']),
+        multiplication_rate: asString(record['multiplication_rate'] ?? record['multiplicationRate']),
+        is_local_currency_greater: nairaGreater,
+        is_naira_greater: nairaGreater,
+        active: asBoolean(record['active']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        payment_methods,
+    };
+}
+/**
+ * Map a list (or single object) payload into {@link CurrencyModel}[].
+ *
+ * @param raw - `data` payload from `/currency/read/{id|all}`.
+ * @returns Mapped currency list (empty when `raw` is null/undefined).
+ */
+function mapCurrencyList(raw) {
+    return mapList(raw, mapCurrency);
+}
+function paymentMethodIds(raw) {
+    return mapArray(raw, (entry) => asNumber(entry));
+}
+/**
+ * Wire body for `POST /currency/create`.
+ * @param body - Host create payload.
+ * @returns JSON body with `"1"` / `"0"` flags.
+ */
+function toCurrencyCreateBody(body) {
+    return {
+        name: asString(body?.name).trim(),
+        short_code: asString(body?.short_code).trim(),
+        multiplication_rate: asString(body?.multiplication_rate),
+        division_rate: asString(body?.division_rate),
+        active: toCurrencyFlag01(body?.active),
+        is_naira_greater: toCurrencyFlag01(body?.is_naira_greater),
+        payment_method_ids: paymentMethodIds(body?.payment_method_ids),
+    };
+}
+/**
+ * Wire body for `PUT /currency/update` (no name / short_code).
+ * @param body - Host update payload.
+ * @returns JSON body with `"1"` / `"0"` flags.
+ */
+function toCurrencyUpdateBody(body) {
+    return {
+        id: asNumber(body?.id),
+        multiplication_rate: asString(body?.multiplication_rate),
+        division_rate: asString(body?.division_rate),
+        active: toCurrencyFlag01(body?.active),
+        is_naira_greater: toCurrencyFlag01(body?.is_naira_greater),
+        payment_method_ids: paymentMethodIds(body?.payment_method_ids),
+    };
+}
+/**
+ * Wire body for `DELETE /currency/delete`.
+ * @param body - Currency id wrapper.
+ * @returns `{ id }`.
+ */
+function toCurrencyDeleteBody(body) {
+    if (typeof body === 'number') {
+        return { id: asNumber(body) };
+    }
+    return { id: asNumber(body?.id) };
+}
+
+/** In-memory GET cache TTL for currency reference dumps / by-id (5 minutes). */
+const CURRENCY_CACHE_TTL_MS = 5 * 60_000;
+/**
+ * Currency App Settings API (`GET /currency/read/{id?}` plus create / update / delete).
+ *
+ * Uses the AFRICANIES {@link ResourceId} convention for reads:
+ * - `null` (default) → paginated page
+ * - `'all'` → full list
+ * - `number` → single {@link CurrencyModel}
+ *
+ * Paginated responses embed a Laravel paginator in `data`; {@link ApiClient}
+ * flattens that to `data: CurrencyModel[]` plus `pagination`.
+ *
+ * Writes send `"1"` / `"0"` flags. Delete uses a JSON `{ id }` body (not query
+ * params). After each write, show `res.message` and call {@link readPage} again.
+ *
+ * @example
+ * ```ts
+ * const currencies = inject(CurrencyService);
+ *
+ * currencies.readPage({ page: 1, order: 'desc' }).subscribe((res) => {
+ *   console.log(res.data, res.pagination);
+ * });
+ * currencies.readAll().subscribe((res) => console.log(res.data?.[0]?.short_code));
+ * currencies.readById(5).subscribe((res) => console.log(res.data?.name));
+ * ```
+ */
+/**
+ * Currency App Settings API (`GET /currency/read/{id?}` plus create / update / delete).
+ */
+class CurrencyService {
+    api = inject(ApiClient);
+    read(id = null, params) {
+        return this.api
+            .get(buildResourcePath(CURRENCY_READ_PATH, id), {
+            toast: false,
+            params: buildResourceQueryParams(id, params),
+            cacheTtlMs: resourceCacheTtlMs(id, CURRENCY_CACHE_TTL_MS),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: mapResourcePayload(id, res.data, mapCurrency, mapCurrencyList),
+        })));
+    }
+    /**
+     * Paginated page — alias for {@link read}(`null`, params).
+     * @param params
+     */
+    readPage(params) {
+        return this.read(null, params);
+    }
+    /**
+     * Full list — alias for {@link read}(`'all'`).
+     * @param params
+     */
+    readAll(params) {
+        return this.read('all', params);
+    }
+    /**
+     * Single record — alias for {@link read}(id).
+     * @param id
+     * @param params
+     */
+    readById(id, params) {
+        return this.read(id, params);
+    }
+    /**
+     * Create a currency (`POST /currency/create`).
+     *
+     * `name` / `short_code` come from the host’s local currency list, not GET.
+     * Flags may be boolean or `"1"` / `"0"`; they are serialized to `"1"` / `"0"`.
+     *
+     * @param body - Create payload.
+     * @returns Normalized envelope — use {@link ApiResponseModel.message}.
+     */
+    create(body) {
+        return this.api
+            .post(CURRENCY_CREATE_PATH, toCurrencyCreateBody(body))
+            .pipe(tap$1(() => this.api.clearCache()));
+    }
+    /**
+     * Update rates, flags, and payment methods (`PUT /currency/update`).
+     *
+     * Name and short code are not sent. Before edit, copy the row into the form
+     * (`true` / `false` may stay booleans — this method serializes flags).
+     *
+     * @param body - Update payload including `id`.
+     * @returns Normalized envelope — use {@link ApiResponseModel.message}.
+     */
+    update(body) {
+        return this.api
+            .put(CURRENCY_UPDATE_PATH, toCurrencyUpdateBody(body))
+            .pipe(tap$1(() => this.api.clearCache()));
+    }
+    /**
+     * Delete a currency (`DELETE /currency/delete`) with JSON body `{ id }`.
+     *
+     * @param body - Currency id or `{ id }`.
+     * @returns Normalized envelope — use {@link ApiResponseModel.message}.
+     */
+    remove(body) {
+        return this.api
+            .delete(CURRENCY_DELETE_PATH, toCurrencyDeleteBody(body))
+            .pipe(tap$1(() => this.api.clearCache()));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: CurrencyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: CurrencyService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: CurrencyService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Currency utility exports.
+ */
+
+/** Payment-method read base path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const PAYMENT_METHOD_READ_PATH = '/payment_method/read';
+/** Payment-method update path (`PUT`). */
+const PAYMENT_METHOD_UPDATE_PATH = '/payment_method/update';
+/**
+ * Serialize a boolean / `"1"` / `"0"` flag for payment-method update.
+ * @param value - Host boolean or wire flag.
+ * @returns `"1"` or `"0"`.
+ */
+function toPaymentMethodFlag01(value) {
+    return toFlag01(value);
+}
+/**
+ * Build the wire body for `PUT /payment_method/update`.
+ *
+ * @param body - Host update payload (`active` may be boolean).
+ * @returns Body with `active` as `"1"` / `"0"`.
+ */
+function toPaymentMethodUpdateBody(body) {
+    return {
+        id: asNumber(body?.id),
+        name: asString(body?.name),
+        model: asString(body?.model),
+        active: toPaymentMethodFlag01(body?.active),
+    };
+}
+/**
+ * Map a currency nested on a payment method (rates + pivot, no processors).
+ * @param raw - Currency object from `currencies[]`.
+ * @returns Normalized {@link PaymentMethodCurrencyModel}.
+ */
+function mapPaymentMethodCurrency(raw) {
+    const mapped = mapCurrency(raw);
+    const record = asRecord(raw) ?? {};
+    return {
+        id: mapped.id,
+        name: mapped.name,
+        short_code: mapped.short_code,
+        division_rate: mapped.division_rate,
+        multiplication_rate: mapped.multiplication_rate,
+        is_local_currency_greater: mapped.is_local_currency_greater,
+        is_naira_greater: mapped.is_naira_greater,
+        active: mapped.active,
+        deleted_at: mapped.deleted_at,
+        created_at: mapped.created_at,
+        updated_at: mapped.updated_at,
+        pivot: mapCurrencyPaymentMethodPivot(record['pivot']),
+    };
+}
+/**
+ * Map a wire payment method into {@link PaymentMethodModel}.
+ * @param raw - Payment-method object from the API.
+ * @returns Normalized {@link PaymentMethodModel}.
+ */
+function mapPaymentMethod(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        name: asString(record['name']),
+        model: asString(record['model']),
+        active: asBoolean(record['active']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        currencies: mapList(record['currencies'], mapPaymentMethodCurrency),
+    };
+}
+/**
+ * Map a list (or single object) payload into {@link PaymentMethodModel}[].
+ *
+ * @param raw - `data` payload from `/payment_method/read/{id|all}`.
+ * @returns Mapped payment-method list (empty when `raw` is null/undefined).
+ */
+function mapPaymentMethodList(raw) {
+    return mapList(raw, mapPaymentMethod);
+}
+
+/** In-memory GET cache TTL for payment-method dumps / by-id (5 minutes). */
+const PAYMENT_METHOD_CACHE_TTL_MS = 5 * 60_000;
+/**
+ * Payment-method App Settings API (`GET /payment_method/read/{id?}` plus update).
+ *
+ * Uses the AFRICANIES {@link ResourceId} convention for reads:
+ * - `null` (default) → paginated page
+ * - `'all'` → full list
+ * - `number` → single {@link PaymentMethodModel}
+ *
+ * Paginated responses embed a Laravel paginator in `data`; {@link ApiClient}
+ * flattens that to `data: PaymentMethodModel[]` plus `pagination`.
+ *
+ * The only write is {@link update} (active toggle). There is no create or
+ * delete on this board — processors are linked from Currencies via
+ * `payment_method_ids`. After update, show `res.message` and patch the row’s
+ * local `updated_at` — do not reload the full list.
+ *
+ * @example
+ * ```ts
+ * const methods = inject(PaymentMethodService);
+ *
+ * methods.readPage({ page: 1, order: 'desc' }).subscribe((res) => {
+ *   console.log(res.data, res.pagination);
+ * });
+ * methods.readAll().subscribe((res) => console.log(res.data?.[0]?.name));
+ * methods.readById(4).subscribe((res) => console.log(res.data?.currencies));
+ *
+ * methods.update({
+ *   id: row.id,
+ *   name: row.name,
+ *   model: row.model,
+ *   active: nextActive,
+ * }).subscribe((res) => {
+ *   // toast res.message; patch row.updated_at locally
+ * });
+ * ```
+ */
+/**
+ * Payment-method App Settings API (`GET /payment_method/read/{id?}` plus update).
+ */
+class PaymentMethodService {
+    api = inject(ApiClient);
+    read(id = null, params) {
+        return this.api
+            .get(buildResourcePath(PAYMENT_METHOD_READ_PATH, id), {
+            toast: false,
+            params: buildResourceQueryParams(id, params),
+            cacheTtlMs: resourceCacheTtlMs(id, PAYMENT_METHOD_CACHE_TTL_MS),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: mapResourcePayload(id, res.data, mapPaymentMethod, mapPaymentMethodList),
+        })));
+    }
+    /**
+     * Paginated page — alias for {@link read}(`null`, params).
+     * @param params
+     */
+    readPage(params) {
+        return this.read(null, params);
+    }
+    /**
+     * Full list — alias for {@link read}(`'all'`).
+     * @param params
+     */
+    readAll(params) {
+        return this.read('all', params);
+    }
+    /**
+     * Single record — alias for {@link read}(id).
+     * @param id
+     * @param params
+     */
+    readById(id, params) {
+        return this.read(id, params);
+    }
+    /**
+     * Toggle / update a payment method (`PUT /payment_method/update`).
+     *
+     * App Settings only edits `active` (status switch). Resend `name` and
+     * `model` from the current row. `active` may be boolean or `"1"` / `"0"`;
+     * this method serializes to `"1"` / `"0"`.
+     *
+     * On success: show {@link ApiResponseModel.message}, patch that row’s
+     * local `updated_at`, and do **not** call {@link readPage} again.
+     *
+     * @param body - Update payload including `id`.
+     * @returns Normalized envelope — use {@link ApiResponseModel.message}.
+     */
+    update(body) {
+        return this.api
+            .put(PAYMENT_METHOD_UPDATE_PATH, toPaymentMethodUpdateBody(body))
+            .pipe(tap$1(() => this.api.clearCache()));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PaymentMethodService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PaymentMethodService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PaymentMethodService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Payment-method utility exports.
+ */
+
+/** Shipment-method read base path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const SHIPMENT_METHOD_READ_PATH = '/shipment_method/read';
+function asYesNo(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    return asString(value).trim().toLowerCase() === 'yes';
+}
+function asShippingMode(value) {
+    return value === 'stn' ? 'stn' : 'sfn';
+}
+/**
+ * Map a nested zone object into {@link ShipmentZoneModel}.
+ * @param raw
+ */
+function mapShipmentZone(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    return {
+        id: asNumber(record['id']),
+        name: asString(record['name']),
+        type: asString(record['type']),
+        active: asBoolean(record['active']),
+    };
+}
+/**
+ * Map a method↔zone link into {@link ShipmentMethodZoneLinkModel}.
+ * @param raw
+ */
+function mapShipmentMethodZoneLink(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        zone_id: asNumber(record['zone_id'] ?? record['zoneId']),
+        shipment_method_id: asNumber(record['shipment_method_id'] ?? record['shipmentMethodId']),
+        active: asBoolean(record['active']),
+        mode: asShippingMode(record['mode']),
+        zone: mapShipmentZone(record['zone']),
+    };
+}
+/**
+ * Map a Laravel-style `zone_values` page into {@link ShipmentMethodZonePageModel}.
+ * @param raw
+ */
+function mapShipmentMethodZonePage(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return {
+            data: [],
+            current_page: 0,
+            per_page: 0,
+            total: 0,
+            last_page: 0,
+        };
+    }
+    return {
+        data: mapArray(record['data'] ?? record['items'], mapShipmentMethodZoneLink),
+        current_page: asNumber(record['current_page'] ?? record['currentPage']),
+        per_page: asNumber(record['per_page'] ?? record['perPage']),
+        total: asNumber(record['total']),
+        last_page: asNumber(record['last_page'] ?? record['lastPage']),
+    };
+}
+/**
+ * Map a wire shipment method into {@link ShipmentMethodModel} (snake_case).
+ * @param raw
+ */
+function mapShipmentMethod(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        name: asString(record['name']),
+        slug: asString(record['slug']),
+        model: asString(record['model']),
+        min_delivery_business_day: asNumber(record['min_delivery_business_day'] ?? record['minDeliveryBusinessDay']),
+        max_delivery_business_day: asNumber(record['max_delivery_business_day'] ?? record['maxDeliveryBusinessDay']),
+        notes: asString(record['notes']),
+        blacklisted_words: asNullableString(record['blacklisted_words'] ?? record['blacklistedWords']),
+        position: asNumber(record['position']),
+        min_weight: asNumber(record['min_weight'] ?? record['minWeight']),
+        max_weight: asNumber(record['max_weight'] ?? record['maxWeight']),
+        max_length: asNumber(record['max_length'] ?? record['maxLength']),
+        max_width: asNumber(record['max_width'] ?? record['maxWidth']),
+        max_height: asNumber(record['max_height'] ?? record['maxHeight']),
+        markup: asNumber(record['markup']),
+        surcharge: asNumber(record['surcharge']),
+        insurance_benchmark: asNumber(record['insurance_benchmark'] ?? record['insuranceBenchmark']),
+        insurance: asNumber(record['insurance']),
+        clearing_handling: asNumber(record['clearing_handling'] ?? record['clearingHandling']),
+        destination: asString(record['destination']),
+        sea_only: asYesNo(record['sea_only'] ?? record['seaOnly']),
+        currency: asString(record['currency']),
+        type: asString(record['type']),
+        active: asBoolean(record['active']),
+        multiple_rates: asBoolean(record['multiple_rates'] ?? record['multipleRates']),
+        first_shipment_discount: asNumber(record['first_shipment_discount'] ?? record['firstShipmentDiscount']),
+        discount_type: asString(record['discount_type'] ?? record['discountType']),
+        discount_active: asBoolean(record['discount_active'] ?? record['discountActive']),
+        mode: asShippingMode(record['mode']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        markdown: asNumber(record['markdown']),
+        zone_values: mapShipmentMethodZonePage(record['zone_values'] ?? record['zoneValues']),
+    };
+}
+/**
+ * Map a list (or single object) payload into {@link ShipmentMethodModel}[].
+ * @param raw
+ */
+function mapShipmentMethodList(raw) {
+    return mapList(raw, mapShipmentMethod);
+}
+
+/** In-memory GET cache TTL for method reference dumps / by-id (5 minutes). */
+const SHIPMENT_METHOD_CACHE_TTL_MS = 5 * 60_000;
+/**
+ * Shipment method / carrier utility reads (`GET /shipment_method/read/{id?}`).
+ *
+ * Uses the AFRICANIES {@link ResourceId} convention:
+ * - `null` (default) → paginated page
+ * - `'all'` → full list
+ * - `number` → single {@link ShipmentMethodModel}
+ *
+ * @example
+ * ```ts
+ * const methods = inject(ShipmentMethodService);
+ *
+ * methods.readPage({ page: 1 }).subscribe((res) => {
+ *   console.log(res.data, res.pagination);
+ * });
+ * methods.readAll().subscribe((res) => console.log(res.data?.[0]?.name));
+ * methods.readById(12).subscribe((res) => console.log(res.data?.name));
+ * ```
+ */
+/**
+ * Shipment method / carrier utility reads (`GET /shipment_method/read/{id?}`).
+ */
+class ShipmentMethodService {
+    api = inject(ApiClient);
+    read(id = null, params) {
+        return this.api
+            .get(buildResourcePath(SHIPMENT_METHOD_READ_PATH, id), {
+            params: buildResourceQueryParams(id, params),
+            cacheTtlMs: resourceCacheTtlMs(id, SHIPMENT_METHOD_CACHE_TTL_MS),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: mapResourcePayload(id, res.data, mapShipmentMethod, mapShipmentMethodList),
+        })));
+    }
+    /**
+     * Paginated page — alias for {@link read}(`null`, params).
+     * @param params
+     */
+    readPage(params) {
+        return this.read(null, params);
+    }
+    /**
+     * Full list — alias for {@link read}(`'all'`).
+     * @param params
+     */
+    readAll(params) {
+        return this.read('all', params);
+    }
+    /**
+     * Single record — alias for {@link read}(id).
+     * @param id
+     * @param params
+     */
+    readById(id, params) {
+        return this.read(id, params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ShipmentMethodService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ShipmentMethodService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ShipmentMethodService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Shipment method / carrier utility exports.
+ */
+
+/** Warehouse read base path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const WAREHOUSE_READ_PATH = '/warehouse/read';
+/**
+ * Map warehouse state into {@link WarehouseStateModel} (snake_case).
+ * @param raw
+ */
+function mapWarehouseState(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    return {
+        id: asNumber(record['id']),
+        name: asString(record['name']),
+        state_code: asString(record['state_code'] ?? record['stateCode']),
+        country: asString(record['country']),
+        country_code: asString(record['country_code'] ?? record['countryCode']),
+    };
+}
+/**
+ * Map nested country (same shape as public country utility).
+ * @param raw
+ */
+function mapWarehouseCountry(raw) {
+    if (raw == null) {
+        return null;
+    }
+    return mapCountry(raw);
+}
+/**
+ * Map a wire warehouse into {@link WarehouseModel} (snake_case preserved).
+ * @param raw
+ */
+function mapWarehouse(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        partner_id: asNullableNumber(record['partner_id'] ?? record['partnerId']),
+        name: asString(record['name']),
+        phone: asString(record['phone']),
+        email: asString(record['email']),
+        country: mapWarehouseCountry(record['country']),
+        api_enabled: asBoolean(record['api_enabled'] ?? record['apiEnabled']),
+        state: mapWarehouseState(record['state']),
+        city: asString(record['city']),
+        address: asString(record['address']),
+        longitude: asNumber(record['longitude']),
+        latitude: asNumber(record['latitude']),
+        zip_code: asString(record['zip_code'] ?? record['zipCode']),
+        usage: asNumber(record['usage']),
+        active: asBoolean(record['active']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        storage_charge: asNumber(record['storage_charge'] ?? record['storageCharge']),
+        storage_period: asNumber(record['storage_period'] ?? record['storagePeriod']),
+        delivery_charge: asNumber(record['delivery_charge'] ?? record['deliveryCharge']),
+        delivery_count: asNumber(record['delivery_count'] ?? record['deliveryCount']),
+        currency: asString(record['currency']),
+        etw_shipment_available: asBoolean(record['etw_shipment_available'] ?? record['etwShipmentAvailable']),
+        local: asBoolean(record['local']),
+        no_shippo: asBoolean(record['no_shippo'] ?? record['noShippo']),
+        partner: mapApiJsonValue(record['partner']),
+    };
+}
+/**
+ * Map a list (or single object) payload into {@link WarehouseModel}[].
+ * @param raw
+ */
+function mapWarehouseList(raw) {
+    return mapList(raw, mapWarehouse);
+}
+
+/** In-memory GET cache TTL for warehouse reference dumps / by-id (5 minutes). */
+const WAREHOUSE_CACHE_TTL_MS = 5 * 60_000;
+/**
+ * Warehouse utility reads (`GET /warehouse/read/{id?}`).
+ *
+ * Uses the AFRICANIES {@link ResourceId} convention:
+ * - `null` (default) → paginated page
+ * - `'all'` → full list
+ * - `number` → single {@link WarehouseModel}
+ *
+ * @example
+ * ```ts
+ * const warehouses = inject(WarehouseService);
+ *
+ * warehouses.readPage({ page: 1 }).subscribe((res) => {
+ *   console.log(res.data, res.pagination);
+ * });
+ * warehouses.readAll().subscribe((res) => console.log(res.data?.length));
+ * warehouses.readById(37).subscribe((res) => console.log(res.data?.name));
+ * ```
+ */
+/**
+ * Warehouse utility reads (`GET /warehouse/read/{id?}`).
+ */
+class WarehouseService {
+    api = inject(ApiClient);
+    read(id = null, params) {
+        return this.api
+            .get(buildResourcePath(WAREHOUSE_READ_PATH, id), {
+            toast: false,
+            params: buildResourceQueryParams(id, params),
+            cacheTtlMs: resourceCacheTtlMs(id, WAREHOUSE_CACHE_TTL_MS),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: mapResourcePayload(id, res.data, mapWarehouse, mapWarehouseList),
+        })));
+    }
+    /**
+     * Paginated page — alias for {@link read}(`null`, params).
+     * @param params
+     */
+    readPage(params) {
+        return this.read(null, params);
+    }
+    /**
+     * Full list — alias for {@link read}(`'all'`).
+     * @param params
+     */
+    readAll(params) {
+        return this.read('all', params);
+    }
+    /**
+     * Single record — alias for {@link read}(id).
+     * @param id
+     * @param params
+     */
+    readById(id, params) {
+        return this.read(id, params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: WarehouseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: WarehouseService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: WarehouseService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Warehouse utility exports.
+ */
+
+/** Zone read base path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const ZONE_READ_PATH = '/zone/read/records';
+/**
+ * Map a wire zone into {@link ZoneModel} (snake_case preserved).
+ * @param raw
+ */
+function mapZone(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        name: asString(record['name']),
+        type: asString(record['type']),
+        active: asBoolean(record['active']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+    };
+}
+/**
+ * Map a list (or single object) payload into {@link ZoneModel}[].
+ * @param raw
+ */
+function mapZoneList(raw) {
+    return mapList(raw, mapZone);
+}
+
+/** In-memory GET cache TTL for zone reference dumps / by-id (5 minutes). */
+const ZONE_CACHE_TTL_MS = 5 * 60_000;
+/**
+ * Zone utility reads (`GET /zone/read/records/{id?}`).
+ *
+ * Uses the AFRICANIES {@link ResourceId} convention:
+ * - `null` (default) → paginated page
+ * - `'all'` → full list
+ * - `number` → single {@link ZoneModel}
+ *
+ * @example
+ * ```ts
+ * const zones = inject(ZoneService);
+ *
+ * zones.readPage({ page: 1 }).subscribe((res) => {
+ *   console.log(res.data, res.pagination);
+ * });
+ * zones.readAll().subscribe((res) => console.log(res.data?.length));
+ * zones.readById(1).subscribe((res) => console.log(res.data?.name));
+ * ```
+ */
+/**
+ * Zone utility reads (`GET /zone/read/records/{id?}`).
+ */
+class ZoneService {
+    api = inject(ApiClient);
+    read(id = null, params) {
+        return this.api
+            .get(buildResourcePath(ZONE_READ_PATH, id), {
+            params: buildResourceQueryParams(id, params),
+            cacheTtlMs: resourceCacheTtlMs(id, ZONE_CACHE_TTL_MS),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: mapResourcePayload(id, res.data, mapZone, mapZoneList),
+        })));
+    }
+    /**
+     * Paginated page — alias for {@link read}(`null`, params).
+     * @param params
+     */
+    readPage(params) {
+        return this.read(null, params);
+    }
+    /**
+     * Full list — alias for {@link read}(`'all'`).
+     * @param params
+     */
+    readAll(params) {
+        return this.read('all', params);
+    }
+    /**
+     * Single record — alias for {@link read}(id).
+     * @param id
+     * @param params
+     */
+    readById(id, params) {
+        return this.read(id, params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ZoneService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ZoneService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ZoneService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Zone utility exports.
+ */
+
+/** Current-user path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const USER_PATH = '/user';
+/** Change-password path after a default-password first login. */
+const USER_CHANGE_PASSWORD_PATH = '/user/change/password';
+/** Invalidate every session for the signed-in user. */
+const USER_LOGOUT_FROM_ALL_SESSIONS_PATH = '/user/logout-from-all-sessions';
+const ACCOUNT_TYPES = new Set(['business', 'individual']);
+const SHIPPING_TYPES = new Set(['instant', 'consolidation']);
+const PLAN_TYPES = new Set([
+    'monthly',
+    'quarterly',
+    'biannually',
+    'annually',
+]);
+const USER_MODEL_TYPES = new Set([
+    'App\\Models\\Customer',
+    'App\\Models\\Admin',
+]);
+/**
+ * @param value - Candidate union member.
+ * @param allowed - Allowed set.
+ * @returns Value when allowed; otherwise `null`.
+ */
+function asEnumMember(value, allowed) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    return allowed.has(value) ? value : null;
+}
+/**
+ * Map a state row under country.states.
+ * @param raw - State object from the wire.
+ * @returns {@link UserStateModel}, or `null`.
+ */
+function mapUserCountryState(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    return {
+        name: asNullableString(record['name']),
+        state_code: asNullableString(record['state_code'] ?? record['stateCode']),
+    };
+}
+/**
+ * Map nested country on the user profile.
+ * @param raw - Country object from the wire.
+ * @returns {@link UserCountryModel}, or `null`.
+ */
+function mapUserCountry(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    const states = Array.isArray(record['states'])
+        ? mapArray(record['states'], mapUserCountryState).filter((entry) => entry !== null)
+        : null;
+    return {
+        id: asNullableNumber(record['id']),
+        name: asNullableString(record['name']),
+        iso3: asNullableString(record['iso3']),
+        iso2: asNullableString(record['iso2']),
+        states,
+    };
+}
+/**
+ * Normalize `state` when the API returns a string (or an object with `name`).
+ * @param raw - Wire `state` field.
+ * @returns String label, or `null`.
+ */
+function mapUserStateLabel(raw) {
+    if (raw == null) {
+        return null;
+    }
+    if (typeof raw === 'string') {
+        return raw;
+    }
+    const record = asRecord(raw);
+    if (record !== null) {
+        return asNullableString(record['name'] ?? record['state']);
+    }
+    return null;
+}
+/**
+ * @param raw - Plan package object.
+ * @returns {@link UserPlanPackageModel}, or `null`.
+ */
+function mapUserPlanPackage(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    return {
+        id: asNullableNumber(record['id']),
+        plan_id: asNullableNumber(record['plan_id'] ?? record['planId']),
+        company_service_id: asNullableNumber(record['company_service_id'] ?? record['companyServiceId']),
+        name: asNullableString(record['name']),
+        metrics: asNullableString(record['metrics']),
+        volume: asNullableNumber(record['volume']),
+        discount: asNullableString(record['discount']),
+        model: asNullableString(record['model']),
+        monthly: asNullableString(record['monthly']),
+        quarterly: asNullableString(record['quarterly']),
+        biannually: asNullableString(record['biannually']),
+        annually: asNullableString(record['annually']),
+        active: asNullableBoolean(record['active']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+    };
+}
+/**
+ * @param raw - Plan object.
+ * @returns {@link UserPlanModel}, or `null`.
+ */
+function mapUserPlan(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    const packages = Array.isArray(record['packages'])
+        ? mapArray(record['packages'], mapUserPlanPackage).filter((entry) => entry !== null)
+        : null;
+    return {
+        id: asNullableNumber(record['id']),
+        name: asNullableString(record['name']),
+        active: asNullableBoolean(record['active']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        packages,
+    };
+}
+/**
+ * @param raw - Gateway payload object.
+ * @returns {@link UserGatewayPayloadModel}, or `null`.
+ */
+function mapUserGatewayPayload(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    return {
+        authorization_url: asNullableString(record['authorization_url'] ?? record['authorizationUrl']),
+        access_code: asNullableString(record['access_code'] ?? record['accessCode']),
+        reference: asNullableString(record['reference']),
+        redirect_url: asNullableString(record['redirect_url'] ?? record['redirectUrl']),
+    };
+}
+/**
+ * @param raw - Payment payload object (already parsed).
+ * @returns {@link UserPaymentPayloadModel}, or `null`.
+ */
+function mapUserPaymentPayload(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    return {
+        url: asNullableString(record['url']),
+        redirect_url: asNullableString(record['redirect_url'] ?? record['redirectUrl']),
+        gateway_payload: mapUserGatewayPayload(record['gateway_payload'] ?? record['gatewayPayload']),
+        reference: asNullableString(record['reference']),
+    };
+}
+/**
+ * @param raw - Subscription object.
+ * @returns {@link UserSubscriptionModel}, or `null`.
+ */
+function mapUserSubscription(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    return {
+        id: asNullableNumber(record['id']),
+        user_id: asNullableNumber(record['user_id'] ?? record['userId']),
+        plan_id: asNullableNumber(record['plan_id'] ?? record['planId']),
+        account_id: asNullableNumber(record['account_id'] ?? record['accountId']),
+        reference: asNullableString(record['reference']),
+        process_url: asNullableString(record['process_url'] ?? record['processUrl']),
+        reference_salt: asNullableString(record['reference_salt'] ?? record['referenceSalt']),
+        amount: asNullableString(record['amount']),
+        currency: asNullableString(record['currency']),
+        payment_amount: asNullableString(record['payment_amount'] ?? record['paymentAmount']),
+        payment_currency: asNullableString(record['payment_currency'] ?? record['paymentCurrency']),
+        coupon_id: asNullableNumber(record['coupon_id'] ?? record['couponId']),
+        coupon_discount: asNullableString(record['coupon_discount'] ?? record['couponDiscount']),
+        coupon_amount: asNullableString(record['coupon_amount'] ?? record['couponAmount']),
+        payment_payload: asNullableString(record['payment_payload'] ?? record['paymentPayload']),
+        plan_type: asEnumMember(record['plan_type'] ?? record['planType'], PLAN_TYPES),
+        used: asNullableBoolean(record['used']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+    };
+}
+/**
+ * @param raw - Business account object.
+ * @returns {@link UserBusinessAccountModel}, or `null`.
+ */
+function mapUserBusinessAccount(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    return {
+        id: asNullableNumber(record['id']),
+        user_id: asNullableNumber(record['user_id'] ?? record['userId']),
+        plan_id: asNullableNumber(record['plan_id'] ?? record['planId']),
+        name: asNullableString(record['name']),
+        account_email: asNullableString(record['account_email'] ?? record['accountEmail']),
+        plan_type: asEnumMember(record['plan_type'] ?? record['planType'], PLAN_TYPES),
+        first_payment: asNullableBoolean(record['first_payment'] ?? record['firstPayment']),
+        is_whitelisted: asNullableBoolean(record['is_whitelisted'] ?? record['isWhitelisted']),
+        no_state_validation: asNullableBoolean(record['no_state_validation'] ?? record['noStateValidation']),
+        show_waybill: asNullableBoolean(record['show_waybill'] ?? record['showWaybill']),
+        notify_api_shipment: asNullableBoolean(record['notify_api_shipment'] ?? record['notifyApiShipment']),
+        active: asNullableBoolean(record['active']),
+        expires_at: asNullableString(record['expires_at'] ?? record['expiresAt']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        type: asEnumMember(record['type'], ACCOUNT_TYPES),
+        days_left: asNullableNumber(record['days_left'] ?? record['daysLeft']),
+        plan: mapUserPlan(record['plan']),
+        subscription: mapUserSubscription(record['subscription']),
+    };
+}
+/**
+ * @param raw - Account manager object.
+ * @returns {@link UserAccountManagerModel}, or `null`.
+ */
+function mapUserAccountManager(raw) {
+    const record = asRecord(raw);
+    if (record === null) {
+        return null;
+    }
+    return {
+        id: asNullableNumber(record['id']),
+        user_id: asNullableNumber(record['user_id'] ?? record['userId']),
+        manager_id: asNullableNumber(record['manager_id'] ?? record['managerId']),
+        account_id: asNullableNumber(record['account_id'] ?? record['accountId']),
+        name: asNullableString(record['name']),
+        email: asNullableString(record['email']),
+        phone: asNullableString(record['phone']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+    };
+}
+/**
+ * Map a bare wire user object into {@link UserModel} (snake_case preserved).
+ * @param raw - User object from `GET /user` (unwrapped).
+ * @returns Normalized {@link UserModel}.
+ */
+function mapUser(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNullableNumber(record['id']),
+        central_id: asNullableString(record['central_id'] ?? record['centralId']),
+        name: asNullableString(record['name']),
+        first_name: asNullableString(record['first_name'] ?? record['firstName']),
+        middle_name: asNullableString(record['middle_name'] ?? record['middleName']),
+        last_name: asNullableString(record['last_name'] ?? record['lastName']),
+        email: asNullableString(record['email']),
+        phone: asNullableString(record['phone']),
+        unit_number: asNullableString(record['unit_number'] ?? record['unitNumber']),
+        referral_code: asNullableString(record['referral_code'] ?? record['referralCode']),
+        old_unit_number: asNullableString(record['old_unit_number'] ?? record['oldUnitNumber']),
+        account_email: asNullableString(record['account_email'] ?? record['accountEmail']),
+        two_factor: asNullableBoolean(record['two_factor'] ?? record['twoFactor']),
+        default_pin: asNullableBoolean(record['default_pin'] ?? record['defaultPin']),
+        model: asEnumMember(record['model'], USER_MODEL_TYPES),
+        country: mapUserCountry(record['country']),
+        state: mapUserStateLabel(record['state']),
+        email_verified_at: asNullableString(record['email_verified_at'] ?? record['emailVerifiedAt']),
+        phone_verified_at: asNullableString(record['phone_verified_at'] ?? record['phoneVerifiedAt']),
+        kyc_verified_at: asNullableString(record['kyc_verified_at'] ?? record['kycVerifiedAt']),
+        passport_verified_at: asNullableString(record['passport_verified_at'] ?? record['passportVerifiedAt']),
+        suspended_at: asNullableString(record['suspended_at'] ?? record['suspendedAt']),
+        deactivated_at: asNullableString(record['deactivated_at'] ?? record['deactivatedAt']),
+        active: asNullableBoolean(record['active']),
+        default_password: asNullableBoolean(record['default_password'] ?? record['defaultPassword']),
+        type: asEnumMember(record['type'], ACCOUNT_TYPES),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        last_login_at: asNullableString(record['last_login_at'] ?? record['lastLoginAt']),
+        socialite_signup: asNullableFlag01(record['socialite_signup'] ?? record['socialiteSignup']),
+        form_signup: asNullableFlag01(record['form_signup'] ?? record['formSignup']),
+        main_region: asNullableString(record['main_region'] ?? record['mainRegion']),
+        shipping_type: asEnumMember(record['shipping_type'] ?? record['shippingType'], SHIPPING_TYPES),
+        accounts: Array.isArray(record['accounts']) ? record['accounts'] : null,
+        business_account: mapUserBusinessAccount(record['business_account'] ?? record['businessAccount']),
+        account_manager: mapUserAccountManager(record['account_manager'] ?? record['accountManager']),
+    };
+}
+
+/**
+ * Current authenticated user (`GET /user`).
+ *
+ * The backend returns a **bare** user object (no `{ success, data }` wrapper).
+ * {@link ApiClient} normalizes that into {@link ApiResponseModel}; this service
+ * maps wire fields once into {@link UserModel} (snake_case preserved).
+ *
+ * Requires an access token via {@link AuthTokenService.set}. Not cached — profile
+ * data is auth-sensitive and can change per session.
+ *
+ * After login, if `user.default_password` is set, send the user to
+ * `/onboarding/reset-password` and call {@link changePassword} (current → new).
+ * That page is **not** the email-link forgot-password flow.
+ *
+ * On logout, call {@link logoutFromAllSessions} while the bearer token is still
+ * set, then {@link AuthTokenService.clear}.
+ *
+ * @example
+ * ```ts
+ * const users = inject(UserService);
+ *
+ * users.me().subscribe((res) => {
+ *   if (res.success) console.log(res.data?.email);
+ * });
+ * ```
+ */
+/**
+ * Current authenticated user (`GET /user`).
+ */
+class UserService {
+    api = inject(ApiClient);
+    /**
+     * Fetch the current user.
+     *
+     * @returns Normalized envelope with mapped {@link UserModel} (or `null` data).
+     */
+    me() {
+        return this.api.get(USER_PATH).pipe(map$1((res) => ({
+            ...res,
+            data: res.data == null ? null : mapUser(res.data),
+        })));
+    }
+    /**
+     * Change the signed-in user’s password (`POST /user/change/password`).
+     *
+     * Used on first login when {@link UserModel.default_password} is true —
+     * not the email-only {@link AuthService.forgot} flow.
+     *
+     * @param body - Current password plus new password and confirmation.
+     * @returns Normalized envelope (`data` is typically unused).
+     */
+    changePassword(body) {
+        return this.api.post(USER_CHANGE_PASSWORD_PATH, {
+            current_password: asString(body?.current_password),
+            password: asString(body?.password),
+            password_confirmation: asString(body?.password_confirmation),
+        });
+    }
+    /**
+     * Sign out of this device and every other session
+     * (`POST /user/logout-from-all-sessions`).
+     *
+     * Call while the bearer token is still set so the interceptor can attach
+     * `Authorization`. Then {@link AuthTokenService.clear} locally.
+     *
+     * @returns Normalized envelope (`data` is typically unused).
+     */
+    logoutFromAllSessions() {
+        return this.api.post(USER_LOGOUT_FROM_ALL_SESSIONS_PATH, {});
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: UserService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: UserService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/** User notifications read base path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const NOTIFICATION_READ_PATH = '/user/notifications/read';
+/** Mark read endpoint (single `{ id }` or `{}` for all). */
+const NOTIFICATION_UPDATE_PATH = '/user/notifications/update';
+/**
+ * Parse the Laravel `data` column (JSON string or object) into
+ * {@link NotificationPayloadModel}.
+ * @param raw
+ */
+function mapNotificationPayload(raw) {
+    let record = asRecord(raw);
+    if (typeof raw === 'string' && raw.trim()) {
+        try {
+            record = asRecord(JSON.parse(raw));
+        }
+        catch {
+            record = null;
+        }
+    }
+    const payload = record ?? {};
+    const userId = payload['user_id'] ?? payload['userId'];
+    return {
+        user_id: userId == null ? null : asNumber(userId),
+        title: asString(payload['title']),
+        body: asNullableString(payload['body']),
+        link: asNullableString(payload['link']),
+        image: asNullableString(payload['image']),
+        external_link: asNullableBoolean(payload['external_link'] ?? payload['externalLink']),
+    };
+}
+/**
+ * Map a wire notification row into {@link NotificationModel}.
+ * @param raw
+ */
+function mapNotification(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asString(record['id']),
+        type: asString(record['type']),
+        notifiable_type: asString(record['notifiable_type'] ?? record['notifiableType']),
+        notifiable_id: asNumber(record['notifiable_id'] ?? record['notifiableId']),
+        data: mapNotificationPayload(record['data']),
+        read_at: asNullableString(record['read_at'] ?? record['readAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+    };
+}
+/**
+ * Map wire list payloads into {@link NotificationModel}[].
+ * @param raw
+ */
+function mapNotificationList(raw) {
+    return mapList(raw, mapNotification).filter((row) => row.id !== '');
+}
+/**
+ * Derive a header/drawer inbox item from a mapped notification.
+ * @param notification
+ */
+function mapNotificationInboxItem(notification) {
+    const row = notification ?? mapNotification(null);
+    const data = row.data ?? mapNotificationPayload(null);
+    return {
+        id: asString(row.id),
+        title: asString(data.title),
+        body: data.body ?? undefined,
+        timestamp: row.created_at ?? undefined,
+        read: row.read_at != null && row.read_at !== '',
+        link: data.link ?? undefined,
+        external_link: data.external_link ?? undefined,
+        image: data.image,
+    };
+}
+
+/**
+ * Authenticated user notifications (`GET /user/notifications/read/{id?}`).
+ *
+ * Uses the AFRICANIES {@link ResourceId} convention for paginated / full-list reads.
+ * Notification primary keys are UUID strings — use {@link readOne} for a single row.
+ *
+ * Requires an access token via {@link AuthTokenService.set}. Not cached — inbox
+ * data is auth-sensitive and changes frequently.
+ *
+ * @example
+ * ```ts
+ * const notifications = inject(NotificationService);
+ *
+ * notifications.readAll().subscribe((res) => {
+ *   console.log(res.data?.length);
+ * });
+ * ```
+ */
+/**
+ * Authenticated user notifications (`GET /user/notifications/read/{id?}`).
+ */
+class NotificationService {
+    api = inject(ApiClient);
+    read(id = null, params) {
+        const query = id === null
+            ? { ...params, size: params?.size ?? NOTIFICATION_PAGE_SIZE }
+            : params;
+        return this.api
+            .get(buildResourcePath(NOTIFICATION_READ_PATH, id), {
+            params: buildResourceQueryParams(id, query),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: mapResourcePayload(id, res?.data, mapNotification, mapNotificationList),
+        })), catchError(() => of({
+            success: false,
+            message: null,
+            data: [],
+            errors: null,
+            pagination: null,
+            status_code: null,
+        })));
+    }
+    /**
+     * Paginated page — alias for {@link read}(`null`, params).
+     * Size defaults to {@link NOTIFICATION_PAGE_SIZE} (`30`).
+     * @param params
+     */
+    readPage(params) {
+        return this.read(null, params);
+    }
+    /**
+     * Full list — alias for {@link read}(`'all'`).
+     * @param params
+     */
+    readAll(params) {
+        return this.read('all', params);
+    }
+    /**
+     * Single notification by UUID (`GET /user/notifications/read/{uuid}`).
+     * @param id
+     */
+    readOne(id) {
+        const trimmed = asString(id).trim();
+        return this.api
+            .get(`${NOTIFICATION_READ_PATH}/${encodeURIComponent(trimmed)}`)
+            .pipe(map$1((res) => ({
+            ...res,
+            data: res.data == null
+                ? null
+                : mapNotification(Array.isArray(res.data) ? res.data[0] : res.data),
+        })));
+    }
+    /**
+     * Mark one or all notifications read (`PUT /user/notifications/update`).
+     *
+     * @param id - When set, marks that notification read; omit to mark all read.
+     */
+    markRead(id) {
+        const body = id ? { id: asString(id) } : {};
+        return this.api.put(NOTIFICATION_UPDATE_PATH, body);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: NotificationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: NotificationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const SHIPMENT_APP_BY_MODE = {
+    stn: 'shiptonaija',
+    sfn: 'shipfromnaija',
+};
+const QUERY_SHIPMENT_APP = 'shipment_app';
+const LEGACY_PORTAL_HOST = /^(?:test-)?(?:admin|customer)-(?:export|import)\.africaniestest\.com$/i;
+/**
+ * Signed export downloads and other hosts that must not be rewritten in-app.
+ * @param link
+ */
+function isNotificationExternalLink(link) {
+    const trimmed = decodeNotificationLink(link).trim();
+    if (!trimmed) {
+        return false;
+    }
+    try {
+        const url = new URL(trimmed);
+        if (/\.(xlsx|xls|csv)(\?|$)/i.test(url.pathname)) {
+            return true;
+        }
+        if (/\.amazonaws\.com$/i.test(url.hostname)) {
+            return true;
+        }
+        return !isLegacyPortalHost(url.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Rewrite a notification href for the active {@link ShippingMode}.
+ *
+ * - Export / download URLs (S3, spreadsheets) pass through unchanged (no `shipment_app`).
+ * - Legacy portal hosts become relative `/portal/...` paths with query preserved.
+ * - When the notification already includes `shipment_app`, it is kept as-is.
+ * - Otherwise classic host / `shipment_app` rewriting applies for portal URLs.
+ * @param link
+ * @param mode
+ */
+function resolveNotificationLinkForMode(link, mode) {
+    const trimmed = decodeNotificationLink(asString(link)).trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    if (isNotificationExternalLink(trimmed)) {
+        return stripShipmentAppFromLink(trimmed);
+    }
+    const relativePortal = toRelativePortalNotificationLink(trimmed);
+    if (relativePortal && hasShipmentAppQuery(relativePortal)) {
+        return relativePortal;
+    }
+    const relative = normalizeRelativePortalLink(trimmed);
+    if (relative && hasShipmentAppQuery(relative)) {
+        return relative;
+    }
+    try {
+        const url = new URL(trimmed);
+        if (url.searchParams.has(QUERY_SHIPMENT_APP)) {
+            return trimmed;
+        }
+        url.searchParams.set(QUERY_SHIPMENT_APP, SHIPMENT_APP_BY_MODE[mode]);
+        url.hostname = rewriteNotificationHostForMode(url.hostname, mode);
+        return url.toString();
+    }
+    catch {
+        return rewriteNotificationLinkFallback(trimmed, mode);
+    }
+}
+function rewriteNotificationHostForMode(hostname, mode) {
+    if (mode === 'stn') {
+        return hostname.replace(/-export/i, '-import');
+    }
+    return hostname.replace(/-import/i, '-export');
+}
+function rewriteNotificationLinkFallback(link, mode) {
+    if (hasShipmentAppQuery(link)) {
+        return link;
+    }
+    let out = link.replace(/shipment_app=(?:shipfromnaija|shiptonaija)/gi, `shipment_app=${SHIPMENT_APP_BY_MODE[mode]}`);
+    if (!/shipment_app=/i.test(out)) {
+        const joiner = out.includes('?') ? '&' : '?';
+        out = `${out}${joiner}shipment_app=${SHIPMENT_APP_BY_MODE[mode]}`;
+    }
+    if (mode === 'stn') {
+        return out.replace(/-export/gi, '-import');
+    }
+    return out.replace(/-import/gi, '-export');
+}
+function toRelativePortalNotificationLink(link) {
+    try {
+        const url = new URL(link);
+        if (!isLegacyPortalHost(url.hostname)) {
+            return null;
+        }
+        let path = url.pathname.replace(/^\/+/, '');
+        if (path.startsWith('ng/portal/')) {
+            path = path.slice('ng/'.length);
+        }
+        if (!path.startsWith('portal/') && path !== 'portal') {
+            return null;
+        }
+        const query = url.searchParams.toString();
+        return `/${path}${query ? `?${query}` : ''}`;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeRelativePortalLink(link) {
+    let path = link.split('?')[0]?.split('#')[0] ?? '';
+    const query = link.includes('?') ? link.slice(link.indexOf('?')) : '';
+    path = path.replace(/^\/+/, '');
+    if (path.startsWith('ng/portal/')) {
+        path = path.slice('ng/'.length);
+    }
+    if (!path.startsWith('portal/') && path !== 'portal') {
+        return null;
+    }
+    return `/${path}${query}`;
+}
+function stripShipmentAppFromLink(link) {
+    const trimmed = link.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    try {
+        const url = new URL(trimmed);
+        if (!url.searchParams.has(QUERY_SHIPMENT_APP)) {
+            return trimmed;
+        }
+        url.searchParams.delete(QUERY_SHIPMENT_APP);
+        return url.toString();
+    }
+    catch {
+        const params = new URLSearchParams(trimmed.includes('?') ? trimmed.slice(trimmed.indexOf('?') + 1) : '');
+        if (!params.has(QUERY_SHIPMENT_APP)) {
+            return trimmed;
+        }
+        params.delete(QUERY_SHIPMENT_APP);
+        const query = params.toString();
+        const base = trimmed.split('?')[0] ?? trimmed;
+        return query ? `${base}?${query}` : base;
+    }
+}
+function hasShipmentAppQuery(link) {
+    try {
+        const query = link.includes('?') ? link.slice(link.indexOf('?') + 1) : '';
+        return new URLSearchParams(query).has(QUERY_SHIPMENT_APP);
+    }
+    catch {
+        return /(?:^|[?&])shipment_app=/i.test(link);
+    }
+}
+function decodeNotificationLink(link) {
+    let value = (link ?? '').trim();
+    if (!value.includes('%')) {
+        return value;
+    }
+    try {
+        const decoded = decodeURIComponent(value);
+        if (decoded !== value) {
+            value = decoded;
+        }
+    }
+    catch {
+        // Keep original when not valid URI encoding.
+    }
+    return value;
+}
+function isLegacyPortalHost(hostname) {
+    return LEGACY_PORTAL_HOST.test(hostname);
+}
+
+/**
+ * File utility reads (`POST /file/read`).
+ *
+ * Primary preview path when a record stores a `file_ref` string (shipments,
+ * tracking items, waybills, KYC, etc.). Body `{ ref }` → `data` with
+ * `mime_type` and `base_64` for `<img>` / PDF viewers.
+ *
+ * Document catalog previews use {@link DocumentService.readById} instead
+ * (`GET /public/document/read/{id}` → `data.file_ref.base_64`).
+ *
+ * @example
+ * ```ts
+ * const files = inject(FileService);
+ *
+ * files.read(item.file_ref).subscribe((res) => {
+ *   if (res.success) console.log(res.data?.base_64);
+ * });
+ *
+ * files.readMultiple(waybillRef).subscribe((res) => {
+ *   console.log(res.data?.map((f) => f.mime_type));
+ * });
+ * ```
+ */
+/**
+ * File utility reads (`POST /file/read`).
+ */
+class FileService {
+    api = inject(ApiClient);
+    /**
+     * Resolve one file reference (`POST /file/read`, body `{ ref }`).
+     *
+     * @param ref - Storage / document UUID from `file_ref` on a record.
+     * @returns Normalized envelope with mapped {@link FileReadModel}.
+     */
+    read(ref) {
+        return this.readByBody({ ref: asString(ref) });
+    }
+    /**
+     * Resolve multiple files for one ref (`POST /file/read?multiple=yes`).
+     *
+     * E-commerce waybill flows may return several pages in `data[]`.
+     *
+     * @param ref - Storage reference token.
+     * @returns Normalized envelope with mapped {@link FileReadModel}[].
+     */
+    readMultiple(ref) {
+        return this.readByBodyMultiple({ ref: asString(ref) });
+    }
+    /**
+     * Resolve a file from an explicit request body.
+     *
+     * @param body - Wire body (`{ ref }`).
+     * @returns Normalized envelope with mapped {@link FileReadModel}.
+     */
+    readByBody(body) {
+        return this.api
+            .post(FILE_READ_PATH, {
+            ref: asString(body?.ref),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: res.data == null ? null : mapFileRead(res.data),
+        })));
+    }
+    /**
+     * Multi-file variant of {@link readByBody}.
+     *
+     * @param body - Wire body (`{ ref }`).
+     * @returns Normalized envelope with mapped {@link FileReadModel}[].
+     */
+    readByBodyMultiple(body) {
+        return this.api
+            .post(FILE_READ_PATH, { ref: asString(body?.ref) }, { params: { multiple: FILE_READ_MULTIPLE_PARAM } })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: res.data == null ? null : mapFileReadList(res.data),
+        })));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: FileService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: FileService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: FileService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * File utility exports.
+ */
+
+/** Product read base path (relative to {@link AfricaniesSdkConfig.baseUrl}). */
+const PRODUCT_READ_PATH = '/product/read';
+function asNullableNumberArray(value) {
+    if (value == null || !Array.isArray(value)) {
+        return null;
+    }
+    return mapArray(value, (entry) => asNumber(entry));
+}
+/**
+ * Map a wire product into {@link ProductModel} (snake_case preserved).
+ * @param raw - Single product object from the API.
+ * @returns Normalized {@link ProductModel}.
+ */
+function mapProduct(raw) {
+    const record = asRecord(raw) ?? {};
+    return {
+        id: asNumber(record['id']),
+        account_id: asNullableNumber(record['account_id'] ?? record['accountId']),
+        product_category_id: asNullableNumber(record['product_category_id'] ?? record['productCategoryId']),
+        hs_code: asString(record['hs_code'] ?? record['hsCode']),
+        hs_code_10: asNullableString(record['hs_code_10'] ?? record['hsCode10']),
+        hs_code_8: asNullableString(record['hs_code_8'] ?? record['hsCode8']),
+        hs_code_6: asNullableString(record['hs_code_6'] ?? record['hsCode6']),
+        name: asString(record['name']),
+        value: asNumber(record['value']),
+        usage: asNumber(record['usage']),
+        document_ids: asNullableNumberArray(record['document_ids'] ?? record['documentIds']),
+        etw_ids: asNullableNumberArray(record['etw_ids'] ?? record['etwIds']),
+        active: asBoolean(record['active']),
+        is_external: asBoolean(record['is_external'] ?? record['isExternal']),
+        deleted_at: asNullableString(record['deleted_at'] ?? record['deletedAt']),
+        created_at: asNullableString(record['created_at'] ?? record['createdAt']),
+        updated_at: asNullableString(record['updated_at'] ?? record['updatedAt']),
+        document_details: mapArray(record['document_details'] ?? record['documentDetails'], (entry) => asString(entry)),
+        etw_document_details: mapArray(record['etw_document_details'] ?? record['etwDocumentDetails'], (entry) => asString(entry)),
+        zone_product_required_documents: mapApiJsonList(record['zone_product_required_documents'] ??
+            record['zoneProductRequiredDocuments']),
+    };
+}
+/**
+ * Map a list (or single object) payload into {@link ProductModel}[].
+ * @param raw - `data` payload from `/product/read/{id|all}`.
+ * @returns Mapped product list.
+ */
+function mapProductList(raw) {
+    return mapList(raw, mapProduct);
+}
+
+/** In-memory GET cache TTL for product reference dumps / by-id (5 minutes). */
+const PRODUCT_CACHE_TTL_MS = 5 * 60_000;
+/**
+ * Product utility reads (`GET /product/read/{id?}`).
+ *
+ * Uses the AFRICANIES {@link ResourceId} convention:
+ * - `null` (default) → paginated page
+ * - `'all'` → full list
+ * - `number` → single {@link ProductModel}
+ *
+ * @example
+ * ```ts
+ * const products = inject(ProductService);
+ *
+ * products.readPage({ page: 1 }).subscribe((res) => {
+ *   console.log(res.data, res.pagination);
+ * });
+ * products.readAll().subscribe((res) => console.log(res.data?.[0]?.hs_code));
+ * products.readById(6280).subscribe((res) => console.log(res.data?.name));
+ * ```
+ */
+/**
+ * Product utility reads (`GET /product/read/{id?}`).
+ */
+class ProductService {
+    api = inject(ApiClient);
+    read(id = null, params) {
+        return this.api
+            .get(buildResourcePath(PRODUCT_READ_PATH, id), {
+            toast: false,
+            params: buildResourceQueryParams(id, params),
+            cacheTtlMs: resourceCacheTtlMs(id, PRODUCT_CACHE_TTL_MS),
+        })
+            .pipe(map$1((res) => ({
+            ...res,
+            data: mapResourcePayload(id, res.data, mapProduct, mapProductList),
+        })));
+    }
+    /**
+     * Paginated page — alias for {@link read}(`null`, params).
+     * @param params
+     */
+    readPage(params) {
+        return this.read(null, params);
+    }
+    /**
+     * Full list — alias for {@link read}(`'all'`).
+     * @param params
+     */
+    readAll(params) {
+        return this.read('all', params);
+    }
+    /**
+     * Single record — alias for {@link read}(id).
+     * @param id
+     * @param params
+     */
+    readById(id, params) {
+        return this.read(id, params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ProductService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ProductService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ProductService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Product utility exports.
+ */
+
+/**
+ * Select fields that declare a non-static {@link FilterOptionsSource}.
+ *
+ * @param config - Module filter schema.
+ * @returns Fields that need async option resolution.
+ */
+function collectResolvableSelectFields(config) {
+    return asArray(config?.fields).filter((field) => field.type === 'select' &&
+        field.optionsSource != null &&
+        field.optionsSource !== 'static');
+}
+/**
+ * Unique {@link FilterOptionsSource} values referenced by a config (excluding static).
+ *
+ * @param config - Module filter schema.
+ */
+function collectFilterOptionsSources(config) {
+    const sources = new Set();
+    for (const field of collectResolvableSelectFields(config)) {
+        sources.add(field.optionsSource);
+    }
+    return [...sources];
+}
+/**
+ * Map {@link WarehouseModel}[] into filter select options (`value` = id string).
+ *
+ * @param rows - Warehouses from {@link WarehouseService.readAll}.
+ */
+function mapWarehouseFilterOptions(rows) {
+    if (!rows?.length) {
+        return [];
+    }
+    return rows.map((row) => ({
+        value: String(row.id),
+        label: row.name,
+    }));
+}
+/**
+ * Map {@link ShipmentMethodModel}[] into filter select options.
+ *
+ * @param rows - Methods from {@link ShipmentMethodService.readAll}.
+ */
+function mapShipmentMethodFilterOptions(rows) {
+    if (!rows?.length) {
+        return [];
+    }
+    return rows.map((row) => ({
+        value: String(row.id),
+        label: row.name,
+    }));
+}
+/**
+ * Merge SDK-resolved lists with host overrides (host wins per field key).
+ *
+ * @param resolved - Output from {@link FilterOptionsResolver.resolve}.
+ * @param overrides - Host catalogs (e.g. manifests without a built-in service).
+ */
+function mergeFilterOptionLists(resolved, overrides) {
+    if (!overrides) {
+        return { ...resolved };
+    }
+    return { ...resolved, ...overrides };
+}
+
+/**
+ * Built-in {@link FilterOptionsSource} keys wired to SDK catalog services.
+ *
+ * `shipmentManifests` has no built-in service yet — resolve to `[]` and pass
+ * host `optionLists` for those field keys.
+ */
+const SDK_FILTER_OPTIONS_SOURCES = new Set([
+    'warehouses',
+    'shipmentMethods',
+]);
+/**
+ * Resolves filter drawer select options from built-in SDK catalog services.
+ *
+ * Prefer opening {@link FilterDrawerService} immediately — the drawer lazy-loads
+ * per field via {@link resolveField}. {@link resolve} remains for bulk prefetch.
+ *
+ * @example
+ * ```ts
+ * const resolver = inject(FilterOptionsResolver);
+ *
+ * filterDrawer.open({
+ *   config: updateShipmentsFilterConfig,
+ *   optionLists: { shipment_manifest_id: hostManifests },
+ * });
+ * ```
+ */
+/**
+ * Resolves filter drawer select options from built-in SDK catalog services.
+ */
+class FilterOptionsResolver {
+    warehouses = inject(WarehouseService);
+    shipmentMethods = inject(ShipmentMethodService);
+    /**
+     * Resolve SDK-backed options for one select field (lazy drawer load).
+     *
+     * @param field - Filter schema field with `optionsSource`.
+     * @returns Select rows or an error when the catalog HTTP call fails.
+     */
+    resolveField(field) {
+        if (field.type !== 'select' ||
+            field.optionsSource == null ||
+            field.optionsSource === 'static') {
+            return of(this.staticFieldOptions(field));
+        }
+        if (!SDK_FILTER_OPTIONS_SOURCES.has(field.optionsSource)) {
+            return of([]);
+        }
+        return this.fetchSource(field.optionsSource);
+    }
+    /**
+     * Resolve all SDK-backed select options for a module config (bulk prefetch).
+     *
+     * @param config - Module filter schema.
+     * @returns `optionLists` keyed by field.key.
+     */
+    resolve(config) {
+        const fields = collectResolvableSelectFields(config);
+        if (fields.length === 0) {
+            return of({});
+        }
+        const fetched = new Set();
+        const fetches = {};
+        for (const field of fields) {
+            const source = field.optionsSource;
+            if (!SDK_FILTER_OPTIONS_SOURCES.has(source) || fetched.has(source)) {
+                continue;
+            }
+            fetched.add(source);
+            fetches[source] = this.fetchSource(source).pipe(map$1((options) => {
+                const lists = {};
+                for (const f of fields) {
+                    if (f.optionsSource === source) {
+                        lists[f.key] = options;
+                    }
+                }
+                return lists;
+            }));
+        }
+        const keys = Object.keys(fetches);
+        if (keys.length === 0) {
+            return of({});
+        }
+        return forkJoin(keys.reduce((acc, key) => {
+            acc[key] = fetches[key];
+            return acc;
+        }, {})).pipe(map$1((parts) => keys.reduce((merged, key) => {
+            Object.assign(merged, parts[key]);
+            return merged;
+        }, {})));
+    }
+    staticFieldOptions(field) {
+        return (field.options ?? []).map((o) => ({
+            value: o.value,
+            label: o.label,
+        }));
+    }
+    fetchSource(source) {
+        switch (source) {
+            case 'warehouses':
+                return this.warehouses.readAll().pipe(map$1((res) => res.success ? mapWarehouseFilterOptions(res.data) : []));
+            case 'shipmentMethods':
+                return this.shipmentMethods.readAll().pipe(map$1((res) => res.success ? mapShipmentMethodFilterOptions(res.data) : []));
+            default:
+                return of([]);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: FilterOptionsResolver, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: FilterOptionsResolver, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: FilterOptionsResolver, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Optional token for the app's modal opener (provided by `@africanies/africanies-ui`).
+ *
+ * {@link RouteOverlayService} injects this with `{ optional: true }` so apps
+ * can register route overlays before UI is wired — opens are skipped until
+ * a provider exists.
+ */
+const MODAL_SERVICE = new InjectionToken('AFRICANIES_MODAL_SERVICE');
+/**
+ * Optional token for the app's drawer opener (provided by `@africanies/africanies-ui`).
+ *
+ * Same optional pattern as {@link MODAL_SERVICE}.
+ */
+const DRAWER_SERVICE = new InjectionToken('AFRICANIES_DRAWER_SERVICE');
+/**
+ * DI token for the list of {@link OverlayRouteConfig} registered via
+ * {@link provideOverlayRoutes}.
+ */
+const OVERLAY_ROUTE_CONFIGS = new InjectionToken('AFRICANIES_OVERLAY_ROUTE_CONFIGS');
+
+/**
+ * Keeps query-param state in sync with modal/drawer overlays.
+ *
+ * Instantiated eagerly via {@link provideOverlayRoutes}'s `provideAppInitializer`
+ * so a hard refresh with `?modal=…` already present reopens the overlay.
+ *
+ * Bidirectional sync:
+ * - Param appears / matches a route → open (passing sibling query params as data)
+ * - Param removed (e.g. browser back) → close without navigating again
+ * - Overlay closed by UI → strip the trigger param with `queryParamsHandling: 'merge'`
+ *
+ * Modal/drawer implementations live in `@africanies/africanies-ui` and are injected through
+ * {@link MODAL_SERVICE} / {@link DRAWER_SERVICE} to avoid a circular dependency.
+ */
+/**
+ * Keeps query-param state in sync with modal/drawer overlays.
+ */
+class RouteOverlayService {
+    route = inject(ActivatedRoute);
+    router = inject(Router);
+    configs = inject(OVERLAY_ROUTE_CONFIGS);
+    modal = inject(MODAL_SERVICE, { optional: true });
+    drawer = inject(DRAWER_SERVICE, { optional: true });
+    openByKey = new Map();
+    constructor() {
+        // Start immediately — provideAppInitializer only forces construction.
+        this.route.queryParamMap.subscribe((params) => this.onQueryParams(params));
+    }
+    onQueryParams(params) {
+        for (const config of this.configs) {
+            this.syncConfig(config, params);
+        }
+    }
+    syncConfig(config, params) {
+        const value = params.get(config.paramKey);
+        const current = this.openByKey.get(config.paramKey);
+        if (value === null || value === '') {
+            if (current) {
+                current.closingFromUrl = true;
+                current.handle.close();
+                this.teardown(config.paramKey);
+            }
+            return;
+        }
+        const entry = config.routes[value];
+        if (!entry) {
+            return;
+        }
+        // Already showing the same route value — leave it alone.
+        if (current?.value === value) {
+            return;
+        }
+        if (current) {
+            current.closingFromUrl = true;
+            current.handle.close();
+            this.teardown(config.paramKey);
+        }
+        const opener = entry.overlay === 'modal' ? this.modal : this.drawer;
+        if (!opener) {
+            // UI package has not provided the opener yet — skip until it does.
+            return;
+        }
+        // Sibling query params (e.g. id=123) become OVERLAY_DATA in africanies-ui.
+        const data = this.siblingParams(params, config.paramKey);
+        const handle = opener.open(entry.component, { data });
+        const state = {
+            value,
+            handle,
+            closingFromUrl: false,
+            afterClosedSub: handle.afterClosed().subscribe(() => {
+                const open = this.openByKey.get(config.paramKey);
+                if (!open || open.handle !== handle) {
+                    return;
+                }
+                const fromUrl = open.closingFromUrl;
+                this.teardown(config.paramKey);
+                if (!fromUrl) {
+                    // Manual / UI close — drop the trigger param, keep other params.
+                    void this.router.navigate([], {
+                        queryParams: { [config.paramKey]: null },
+                        queryParamsHandling: 'merge',
+                        replaceUrl: true,
+                    });
+                }
+            }),
+        };
+        this.openByKey.set(config.paramKey, state);
+    }
+    siblingParams(params, excludeKey) {
+        const data = {};
+        params.keys.forEach((key) => {
+            if (key === excludeKey) {
+                return;
+            }
+            const value = params.get(key);
+            if (value !== null) {
+                data[key] = value;
+            }
+        });
+        return data;
+    }
+    teardown(paramKey) {
+        const current = this.openByKey.get(paramKey);
+        if (!current) {
+            return;
+        }
+        current.afterClosedSub.unsubscribe();
+        this.openByKey.delete(paramKey);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: RouteOverlayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: RouteOverlayService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: RouteOverlayService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+/**
+ * Registers query-param → overlay maps and eagerly starts {@link RouteOverlayService}.
+ *
+ * Call beside {@link provideAfricaniesSdk} in `app.config.ts`. Modal/drawer openers
+ * must still be provided by `@africanies/africanies-ui` (`MODAL_SERVICE` / `DRAWER_SERVICE`).
+ *
+ * @param configs - One or more param-key namespaces (e.g. `modal` and `drawer`).
+ * @returns Environment providers including an app initializer.
+ *
+ * @example
+ * ```ts
+ * // app.config.ts
+ * import { provideRouter, Routes } from '@angular/router';
+ * import {
+ *   provideAfricaniesSdk,
+ *   provideOverlayRoutes,
+ * } from '@africanies/africanies-core';
+ * import { EditShipmentModal } from './edit-shipment.modal';
+ *
+ * export const appConfig = {
+ *   providers: [
+ *     provideAfricaniesSdk({ baseUrl: 'https://api.example.com' }),
+ *     provideRouter(routes),
+ *     provideOverlayRoutes([
+ *       {
+ *         paramKey: 'modal',
+ *         routes: {
+ *           'edit-shipment': {
+ *             component: EditShipmentModal,
+ *             overlay: 'modal',
+ *           },
+ *         },
+ *       },
+ *     ]),
+ *     // From @africanies/africanies-ui — binds MODAL_SERVICE / DRAWER_SERVICE
+ *     // provideAfricaniesOverlays(),
+ *   ],
+ * };
+ *
+ * // Template — open via query params (refresh with the same URL reopens):
+ * // <a routerLink="." [queryParams]="{ modal: 'edit-shipment', id: row.id }">
+ * //   Edit
+ * // </a>
+ * ```
+ */
+function provideOverlayRoutes(configs) {
+    return makeEnvironmentProviders([
+        { provide: OVERLAY_ROUTE_CONFIGS, useValue: configs },
+        RouteOverlayService,
+        provideAppInitializer(() => {
+            // Force construction so queryParamMap subscription starts at bootstrap
+            // (including hard refresh when the param is already present).
+            inject(RouteOverlayService);
+        }),
+    ]);
+}
+
+/**
+ * Copy plain text to the system clipboard.
+ *
+ * Prefers `navigator.clipboard.writeText`. Falls back to a temporary
+ * `textarea` + `document.execCommand('copy')` when the Clipboard API is
+ * missing or throws (older browsers, some embedded / non-secure contexts).
+ *
+ * Safe to call during SSR — returns `false` when `document` is unavailable.
+ *
+ * @param value - Text to place on the clipboard.
+ * @returns `true` when the write succeeded; `false` otherwise.
+ *
+ * @example
+ * ```ts
+ * const ok = await copyToClipboard(iconName);
+ * if (ok) {
+ *   toast.success(`Copied “${iconName}”`);
+ * }
+ * ```
+ */
+async function copyToClipboard(value) {
+    if (typeof document === 'undefined') {
+        return false;
+    }
+    try {
+        if (typeof navigator !== 'undefined' && navigator.clipboard?.writeText) {
+            await navigator.clipboard.writeText(value);
+            return true;
+        }
+    }
+    catch {
+        // Fall through to the legacy execCommand path.
+    }
+    try {
+        const el = document.createElement('textarea');
+        el.value = value;
+        el.setAttribute('readonly', '');
+        el.style.position = 'fixed';
+        el.style.left = '-9999px';
+        document.body.appendChild(el);
+        el.select();
+        const ok = document.execCommand('copy');
+        document.body.removeChild(el);
+        return ok;
+    }
+    catch {
+        return false;
+    }
+}
+
+/**
+ * Escape a single CSV field (RFC 4180).
+ *
+ * Quotes fields that contain commas, quotes, or line breaks. `null` /
+ * `undefined` become an empty cell.
+ *
+ * @param value - Cell value.
+ */
+function csvCell(value) {
+    const text = value == null ? '' : String(value);
+    if (/[",\n\r]/.test(text)) {
+        return `"${text.replace(/"/g, '""')}"`;
+    }
+    return text;
+}
+/**
+ * Build a CSV document string (optional BOM + header + rows).
+ *
+ * @param options - Headers, rows, and BOM flag (filename is ignored).
+ */
+function toCsvString(options) {
+    const lines = [];
+    if (options.headers?.length) {
+        lines.push(options.headers.map(csvCell).join(','));
+    }
+    for (const row of options.rows) {
+        lines.push(row.map(csvCell).join(','));
+    }
+    const body = lines.length ? `${lines.join('\n')}\n` : '';
+    const bom = options.bom === false ? '' : '\uFEFF';
+    return `${bom}${body}`;
+}
+/**
+ * Download a CSV file in the browser.
+ *
+ * Hosts supply filename, headers, and already-mapped row values. Safe during
+ * SSR — returns `false` when `document` is unavailable.
+ *
+ * @param options - Filename, headers, and row cells.
+ * @returns `true` when the download was triggered.
+ *
+ * @example
+ * ```ts
+ * downloadCsv({
+ *   filename: 'warehouses.csv',
+ *   headers: ['Name', 'Status'],
+ *   rows: warehouses.map((row) => [
+ *     row.name,
+ *     row.active ? 'Active' : 'In-Active',
+ *   ]),
+ * });
+ * ```
+ */
+function downloadCsv(options) {
+    if (typeof document === 'undefined' || typeof URL === 'undefined') {
+        return false;
+    }
+    const blob = new Blob([toCsvString(options)], {
+        type: 'text/csv;charset=utf-8',
+    });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = options.filename;
+    link.rel = 'noopener';
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+    return true;
+}
+
+/**
+ * Browser helpers (clipboard, CSV download, etc.) shared across host apps.
+ */
+
+// Config
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AFRICANIES_HTTP_TOAST, AFRICANIES_SDK_CONFIG, AUTH_FORGOT_PASSWORD_PATH, ApiClient, AuthService, AuthTokenService, COUNTRY_FLAG_CDN_BASE, COUNTRY_READ_PATH, CURRENCY_CREATE_PATH, CURRENCY_DELETE_PATH, CURRENCY_READ_PATH, CURRENCY_UPDATE_PATH, CountryService, CurrencyService, DOCUMENT_READ_PATH, DRAWER_SERVICE, DocumentService, FILE_READ_MULTIPLE_PARAM, FILE_READ_PATH, FileService, FilterOptionsResolver, HttpResponseCache, MODAL_SERVICE, MODE_CONFIG_PATH, ModeConfigService, NOTIFICATION_READ_PATH, NOTIFICATION_UPDATE_PATH, NotificationService, OVERLAY_ROUTE_CONFIGS, PAYMENT_METHOD_READ_PATH, PAYMENT_METHOD_UPDATE_PATH, PLAN_READ_PATH, PRODUCT_READ_PATH, PaymentMethodService, PlanService, ProductService, RouteOverlayService, SERVICE_READ_PATH, SHIPMENT_METHOD_READ_PATH, SHIPPING_MODE_OVERRIDE, ServiceService, ShipmentMethodService, ShippingModeService, TOAST_HTTP_OPTIONS, USER_CHANGE_PASSWORD_PATH, USER_LOGOUT_FROM_ALL_SESSIONS_PATH, USER_PATH, UserService, WAREHOUSE_READ_PATH, WarehouseService, ZONE_READ_PATH, ZoneService, asArray, asBoolean, asNullableBoolean, asNullableFlag01, asNullableNumber, asNullableString, asNumber, asRecord, asShippingMode$1 as asShippingMode, asString, authInterceptor, buildResourcePath, buildResourceQueryParams, collectFilterOptionsSources, collectResolvableSelectFields, copyToClipboard, countryFlagUrl, createAfricaniesQueryClientDefaults, csvCell, downloadCsv, fieldErrorsMap, formatApiErrorMessage, httpToastInterceptor, isLaravelValidationBag, isNotificationExternalLink, isValidEmail, joinApiErrorMessages, listFetchKind, mapApiJsonList, mapApiJsonValue, mapArray, mapCountry, mapCountryList, mapCountrySelectOptions, mapCountryState, mapCurrency, mapCurrencyList, mapCurrencyPaymentMethod, mapCurrencyPaymentMethodPivot, mapDocument, mapDocumentList, mapFileRead, mapFileReadList, mapLaravelValidationBag, mapList, mapModeConfigData, mapNotification, mapNotificationInboxItem, mapNotificationList, mapNotificationPayload, mapPaymentMethod, mapPaymentMethodCurrency, mapPaymentMethodList, mapPlan, mapPlanList, mapPlanPackage, mapProduct, mapProductList, mapResourcePayload, mapService, mapServiceList, mapShipmentMethod, mapShipmentMethodFilterOptions, mapShipmentMethodList, mapShipmentMethodZoneLink, mapShipmentMethodZonePage, mapShipmentZone, mapUser, mapUserAccountManager, mapUserBusinessAccount, mapUserCountry, mapUserCountryState, mapUserGatewayPayload, mapUserPaymentPayload, mapUserPlan, mapUserPlanPackage, mapUserStateLabel, mapUserSubscription, mapWarehouse, mapWarehouseCountry, mapWarehouseFilterOptions, mapWarehouseList, mapWarehouseState, mapZone, mapZoneList, mergeFilterOptionLists, normalize, normalizePagination, provideAfricaniesHttpClient, provideAfricaniesQueryDefaults, provideAfricaniesSdk, provideModeConfig, provideOverlayRoutes, resolveModeRegionConfig, resolveNotificationLinkForMode, resourceCacheTtlMs, shipmentModeInterceptor, toCsvString, toCurrencyCreateBody, toCurrencyDeleteBody, toCurrencyFlag01, toCurrencyUpdateBody, toFlag01, toPaymentMethodFlag01, toPaymentMethodUpdateBody, unwrapLaravelPaginator, withShippingMode, withToast };
+//# sourceMappingURL=africanies-africanies-core.mjs.map