@webority/mobile-core 0.1.0 → 0.2.0

package/lib/typescript/commonjs/formatters/house.d.ts

@@ -0,0 +1,143 @@
+/**
+ * The house formatters: DD-MMM-YYYY dates, IST by default or the viewer's own
+ * zone with a label, Indian digit grouping by default, money in minor units,
+ * and one empty placeholder. Byte-identical in @webority/mobile-core and
+ * @webority/web-core.
+ *
+ * Same output on Hermes and in every browser is the design constraint, so the
+ * text is assembled here rather than by Intl. Engines disagree on month
+ * abbreviations ("Sep" or "Sept"), on the space before AM/PM (a plain or a
+ * narrow no-break space), on zone names ("IST" or "GMT+5:30") and on which
+ * Intl options exist at all (Hermes has no RelativeTimeFormat and no
+ * trailingZeroDisplay). IST and the viewer's zone are therefore computed with
+ * plain Date arithmetic; Intl is used only to read the wall clock of an
+ * explicitly named IANA zone, through formatToParts with numeric fields, to
+ * read the locale's 12- or 24-hour clock, and where a caller asks for Intl
+ * output itself (Intl number options, `formatRelative({ intl: true })`).
+ *
+ * Called with no options (house defaults: zone IST, locale en-IN, empty "-"):
+ * - formatDate(v) "08-Apr-2026"; formatTime(v) "8:05 PM"; formatDateTime(v) "08-Apr-2026, 8:05 PM";
+ * - formatRelative(v) "5 minutes ago", "in 3 days", "just now";
+ * - formatNumber(v) "1,23,456.789" (Indian grouping, up to 3 decimals);
+ * - formatPercent(0.42) "42%"; formatMinor(15000000) "₹1,50,000.00";
+ * - a missing or unreadable value "-".
+ *
+ * With a configured locale (`configureFormatters({ locale })`), the words and separators come
+ * from Intl for that locale and the date order stays DD-MMM-YYYY. For en-IN in the viewer zone:
+ * "08-Sept-2026", "08:05 pm", "08-Sept-2026, 08:05 pm IST", "yesterday", "12,34,567.891",
+ * "₹1,50,000". For de-DE: "08-Sept-2026", "20:05", "1.234.567,891".
+ */
+import { type NumberGrouping, type ZoneMode } from './formatConfig';
+/** A date the house formatters accept; null, undefined and "" read as missing. */
+export type DateValue = Date | string | number | null | undefined;
+/** A zone mode, `'UTC'`, or any IANA zone name such as `'America/New_York'`. */
+export type ZoneOption = ZoneMode | 'UTC' | (string & {});
+export interface FormatDateOptions {
+    /** Overrides the configured zone mode for this call. */
+    zone?: ZoneOption;
+    /** Overrides the configured empty placeholder for this call. */
+    empty?: string;
+}
+export interface FormatTimeOptions extends FormatDateOptions {
+    /**
+     * 12 gives "8:05 PM", 24 gives "20:05". Defaults to 12 for the house text, and to the
+     * configured locale's own clock once a locale is configured (12 for en-IN and en-US,
+     * 24 for en-GB, de-DE and most of Europe).
+     */
+    hourCycle?: 12 | 24;
+    /**
+     * Append the zone label ("IST", "UTC", "GMT-4"; Intl's short zone name for a
+     * configured locale). Defaults to on for every zone except IST, so the viewer
+     * mode always says which clock it shows.
+     */
+    zoneLabel?: boolean;
+}
+export type FormatDateTimeOptions = FormatTimeOptions;
+export interface FormatRelativeOptions {
+    /** The instant to measure from. Defaults to now. */
+    now?: Date | string | number;
+    empty?: string;
+    /**
+     * Intl's own phrasing ("yesterday", "in 2 days", "now") instead of the house phrase
+     * ("1 day ago"). Always on once a locale is configured. Intl phrases count in rounded
+     * years, months, days, hours, minutes and seconds, with no week unit, so 36 hours ahead reads
+     * "in 2 days". An engine without Intl.RelativeTimeFormat (older Hermes) prints the house phrase.
+     */
+    intl?: boolean;
+}
+/**
+ * The house keys, plus any `Intl.NumberFormatOptions`. With house keys only, the text is
+ * assembled here (same on every engine). With any other Intl key (`style`, `unit`,
+ * `notation`, `signDisplay`, `useGrouping`, ...), the number goes to `Intl.NumberFormat` in
+ * `locale` with every option passed through, so it reads as that engine's Intl reads it.
+ */
+export interface FormatNumberOptions extends Intl.NumberFormatOptions {
+    /**
+     * Defaults to the locale's grouping (Indian for en-IN). An explicit `'indian'` or
+     * `'international'` prints the house text even with a configured locale; `'none'` drops
+     * the separators either way.
+     */
+    grouping?: NumberGrouping;
+    /** Defaults to 0. */
+    minimumFractionDigits?: number;
+    /** Defaults to 3 for formatNumber and 0 for formatPercent. */
+    maximumFractionDigits?: number;
+    /** Overrides the configured locale for this call. */
+    locale?: string;
+    empty?: string;
+}
+export interface FormatPercentOptions extends FormatNumberOptions {
+    /** `'ratio'` (the default) reads 0.42 as 42%; `'percent'` reads 42 as 42%. */
+    scale?: 'ratio' | 'percent';
+}
+export interface FormatMinorOptions {
+    /** ISO 4217 code. Defaults to `'INR'`. */
+    currency?: string;
+    /** Defaults to Indian grouping for INR and international grouping for every other currency. */
+    grouping?: NumberGrouping;
+    /** Print a whole amount without its zero decimals: "₹1,500" instead of "₹1,500.00". */
+    dropZeroDecimals?: boolean;
+    /** `false` prints the digits alone, for a field that draws the symbol itself. */
+    symbol?: boolean;
+    empty?: string;
+}
+/**
+ * "08-Apr-2026". A bare calendar date ("2026-04-08") always shows as that day;
+ * an instant shows its day in the configured zone.
+ */
+export declare const formatDate: (value: DateValue, options?: FormatDateOptions) => string;
+/** "8:05 PM" in IST, "8:05 PM GMT-4" in the viewer's zone; "20:05" for a configured locale with a 24-hour clock. */
+export declare const formatTime: (value: DateValue, options?: FormatTimeOptions) => string;
+/** "08-Apr-2026, 8:05 PM" in IST, "08-Apr-2026, 10:35 AM GMT-4" in the viewer's zone. */
+export declare const formatDateTime: (value: DateValue, options?: FormatDateTimeOptions) => string;
+/**
+ * "just now", "5 minutes ago", "in 3 days". English on every engine: Hermes
+ * has no Intl.RelativeTimeFormat. Counts are whole units, rounded down, so
+ * 59 minutes never reads as "60 minutes". With a configured locale, or
+ * `{ intl: true }`, the phrase is Intl's in that locale instead, with numeric
+ * "auto" and rounded counts: "yesterday", "in 2 days" at 36 hours ahead, "10 days ago",
+ * "30 seconds ago", "now".
+ */
+export declare const formatRelative: (value: DateValue, options?: FormatRelativeOptions) => string;
+/**
+ * "1,23,456.79" by default; a string holding a number is read as that number. Any Intl option
+ * beyond the house keys (`{ style: 'unit', unit: 'meter' }`, `{ notation: 'compact' }`) hands
+ * the number to Intl.NumberFormat with every option passed through. With a configured locale,
+ * the separators are that locale's ("1.234,5" for de-DE).
+ */
+export declare const formatNumber: (value: number | string | null | undefined, options?: FormatNumberOptions) => string;
+/**
+ * "42%" from 0.42, or from 42 with `scale: 'percent'`. Whole percent unless fraction digits are asked for.
+ * Any Intl option beyond the house keys goes to Intl.NumberFormat with `style: 'percent'`.
+ */
+export declare const formatPercent: (value: number | string | null | undefined, options?: FormatPercentOptions) => string;
+/**
+ * Money held in minor units (paise, cents), which is how every API carries
+ * it: formatMinor(15000000) gives "₹1,50,000.00". The split into whole and
+ * fractional units is done on the integer's digits, so no floating-point
+ * division can shift a paisa. A fractional input is rounded to the nearest
+ * minor unit. A currency without a known symbol prints its code: "AED 1,000.00".
+ * With a configured locale, Intl writes it in that locale ("150.000,00 €" for de-DE).
+ */
+export declare const formatMinor: (amountMinor: number | string | null | undefined, options?: FormatMinorOptions) => string;
+//# sourceMappingURL=house.d.ts.map

package/lib/typescript/commonjs/formatters/index.d.ts

@@ -3,6 +3,10 @@ export { formatCurrency } from './currency';
 export type { DateInput, DateStyle, TimeStyle } from './date';
 export { formatDate, formatDateTime, formatRelativeTime, formatTime } from './date';
 export { addDays, diffMs, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, isDateAfter, isDateBefore, isSameDay, startOfDay } from './dateMath';
+export type { FormatterConfig, NumberGrouping, ZoneMode } from './formatConfig';
+export { configureFormatters, getFormatterConfig } from './formatConfig';
+export type { DateValue, FormatDateOptions, FormatDateTimeOptions, FormatMinorOptions, FormatNumberOptions, FormatPercentOptions, FormatRelativeOptions, FormatTimeOptions, ZoneOption } from './house';
+export { formatMinor, formatRelative } from './house';
 export { getInitials } from './initials';
 export { formatCompactNumber, formatNumber, formatPercent } from './number';
 export type { FormatPhoneOptions, PhoneCountry, PhoneCountryEntry, PhoneNumber, PhoneNumberType, PhoneParts, PhoneValidationKind } from './phone';

package/lib/typescript/commonjs/formatters/number.d.ts

@@ -1,12 +1,22 @@
+import { type FormatNumberOptions, type FormatPercentOptions } from './house';
 /**
- * Locale-aware number formatter. Defaults to `'en-IN'` (Indian grouping).
+ * Two forms share each name. With an options object, or nothing, the house
+ * formatter runs (`./house`: no Intl, the configured grouping and empty
+ * placeholder, a numeric string read as its number). With positional
+ * arguments the original Intl formatter runs, unchanged, returning '' for
+ * missing input.
  */
-export declare const formatNumber: (value: number | null | undefined, fractionDigits?: number, locale?: string) => string;
+/** "1,23,456.79": the configured grouping, up to three decimals by default. */
+export declare function formatNumber(value: number | string | null | undefined, options?: FormatNumberOptions): string;
+/** Intl output for `locale` (default `'en-IN'`), with exactly `fractionDigits` decimals when given. */
+export declare function formatNumber(value: number | null | undefined, fractionDigits: number | undefined, locale?: string): string;
+/** "42%" from 0.42 (or from 42 with `scale: 'percent'`), whole percent by default. */
+export declare function formatPercent(value: number | string | null | undefined, options?: FormatPercentOptions): string;
 /**
- * Format a 0–1 ratio (or 0–100 percent) as a percent string.
- * Pass `asRatio: false` if your input is already on the 0–100 scale.
+ * Intl percent output. Pass `asRatio: false` if the input is already on the
+ * 0–100 scale.
  */
-export declare const formatPercent: (value: number | null | undefined, fractionDigits?: number, asRatio?: boolean, locale?: string) => string;
+export declare function formatPercent(value: number | null | undefined, fractionDigits: number | undefined, asRatio?: boolean, locale?: string): string;
 /**
  * Format a number compactly (1.2K, 3.4M, 1.5L, 2.3Cr).
  * Defaults to Indian compact notation via `'en-IN'` locale (lakh / crore).

package/lib/typescript/commonjs/index.d.ts

@@ -13,6 +13,12 @@
  *   @webority/mobile-core/share        expo-sharing
  *   @webority/mobile-core/secureScreen expo-screen-capture
  *   @webority/mobile-core/smsRetriever Android only, own TurboModule
+ *   @webority/mobile-core/query        RTK Query base query and createApi preset
+ *                                      (@reduxjs/toolkit and react-redux)
+ *
+ * `@webority/mobile-core/redux` (errorToastMiddleware, createRootReducer, resetState,
+ * SERIALIZABLE_IGNORED_ACTION_PATHS) is separate too: it needs @reduxjs/toolkit, an optional
+ * peer.
  *
  * One more path is separate for size, not for a native package:
  *
@@ -22,28 +28,35 @@
  * client reads the bearer token. It needs no optional peer: the backend is
  * expo-secure-store, and `expo` is required anyway.
  */
+export type { AccountIdProvider, ClientKind } from './api/clientHeaders';
+export { ACCOUNT_ID_HEADER, CLIENT_BUILD_HEADER, CLIENT_KIND, CLIENT_KIND_HEADER, getClientBuild } from './api/clientHeaders';
 export { buildCurl, logCurl } from './api/curl';
+export type { MinAppVersionListener } from './api/minAppVersion';
+export { addMinAppVersionListener, getMinAppVersion, MIN_APP_VERSION_HEADER } from './api/minAppVersion';
 export { default as publicClient } from './api/publicClient';
+export { applyRequestDefaults, newCorrelationId } from './api/requestDefaults';
 export type { RetryPolicy } from './api/retry';
-export { attachRetry, isRetryableStatus } from './api/retry';
+export { attachRetry, IDEMPOTENCY_KEY_HEADER, isNeverSentError, isRetryableFailure, isRetryableStatus, retryAfterMs } from './api/retry';
 export { refreshAccessToken } from './api/tokenRefresh';
 export type { RefreshableStore, SessionTerminationCode } from './api/userClient';
-export { default as userClient, injectStore, injectUserAuth, RequestOfflineError, resetRefreshState, SESSION_TERMINATION_CODES } from './api/userClient';
-export type { KeychainLike, SecureCredentials, StoredToken } from './auth/authStore';
-export { ACCESS_TOKEN_KEY, getToken, REFRESH_TOKEN_KEY, removeToken, setKeychainImplementation, storeToken } from './auth/authStore';
+export { default as userClient, injectStore, injectUserAuth, RequestOfflineError, resetRefreshState, SESSION_TERMINATION_CODES, SIGN_OUT_REASON_HEADER } from './api/userClient';
+export type { KeychainLike, LegacyTokenKeys, SecureCredentials, SessionEndDetail, SessionEndedListener, SessionEndReason, StoredToken } from './auth/authStore';
+export { ACCESS_TOKEN_KEY, addSessionEndedListener, clearSession, getSessionUser, getToken, LEGACY_REFRESH_TOKEN_LIFETIME_MS, REFRESH_TOKEN_KEY, removeSessionUser, removeToken, SESSION_USER_KEY, setKeychainImplementation, setLegacyTokenKeys, storeSessionUser, storeToken } from './auth/authStore';
 export type { JwtClaims } from './auth/jwt';
 export { decodeJWT, getJWTExpiry, isJWTExpired } from './auth/jwt';
 export type { Config, Environment, LogLevel } from './config';
 export { getConfig, getConfigValue, resetConfig, setConfig } from './config';
 export type { DeepLinkConfig, DeepLinkRoute, ParsedLink } from './deepLink';
 export { DeepLink, parseDeepLink, useDeepLink } from './deepLink';
-export type { DateInput, DateStyle, FormatCurrencyOptions, FormatPhoneOptions, PhoneCountry, PhoneCountryEntry, PhoneNumber, PhoneNumberType, PhoneParts, PhoneValidationKind, TimeStyle } from './formatters';
-export { AsYouType, addDays, clampNationalNumber, countryFlagEmoji, detectPhoneCountry, diffMs, formatCompactNumber, formatCurrency, formatDate, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatDateTime, formatNumber, formatPercent, formatPhone, formatPhoneAsTyped, formatRelativeTime, formatTime, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, getCountries, getCountryCallingCode, getInitials, getPhoneCountries, isDateAfter, isDateBefore, isSameDay, isSupportedCountry, isValidNationalNumber, isValidPhoneNumber, maxNationalNumberLength, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString, splitPhoneNumber, startOfDay, validatePhoneNumberLength } from './formatters';
+export type { ApiError } from './errors';
+export { apiErrorMessage, CONTRACT_ERROR_CODE, extractApiError, isApiError, isNoResponse, NETWORK_CODE, OFFLINE_MESSAGE, REQUEST_CANCELED_CODE, SERVER_FAILURE_MESSAGE, TIMEOUT_CODE, TIMEOUT_MESSAGE, toFieldPath, UNEXPECTED_MESSAGE } from './errors';
+export type { DateInput, DateStyle, DateValue, FormatCurrencyOptions, FormatDateOptions, FormatDateTimeOptions, FormatMinorOptions, FormatNumberOptions, FormatPercentOptions, FormatPhoneOptions, FormatRelativeOptions, FormatTimeOptions, FormatterConfig, NumberGrouping, PhoneCountry, PhoneCountryEntry, PhoneNumber, PhoneNumberType, PhoneParts, PhoneValidationKind, TimeStyle, ZoneMode, ZoneOption } from './formatters';
+export { AsYouType, addDays, clampNationalNumber, configureFormatters, countryFlagEmoji, detectPhoneCountry, diffMs, formatCompactNumber, formatCurrency, formatDate, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatDateTime, formatMinor, formatNumber, formatPercent, formatPhone, formatPhoneAsTyped, formatRelative, formatRelativeTime, formatTime, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, getCountries, getCountryCallingCode, getFormatterConfig, getInitials, getPhoneCountries, isDateAfter, isDateBefore, isSameDay, isSupportedCountry, isValidNationalNumber, isValidPhoneNumber, maxNationalNumberLength, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString, splitPhoneNumber, startOfDay, validatePhoneNumberLength } from './formatters';
 export type { InitConfig } from './initSDK';
 export { initWebority } from './initSDK';
 export type { TokenRefreshConfig, TokenRefreshResult, UserAuthOptions } from './initUserAuth';
 export { initUserAuth } from './initUserAuth';
-export type { DeviceContext, LoggerOptions, LoggerType, RemoteLogger } from './logger';
+export type { DeviceContext, LoggerOptions, LoggerType, RemoteLogger, RequestFailedContext } from './logger';
 export { configureLogger, getDeviceContext, Logger, setDeviceContext, setRemoteLogger } from './logger';
 export type { CrashlyticsModule } from './logger/crashlytics';
 export { crashlyticsRemoteLogger } from './logger/crashlytics';
@@ -57,5 +70,5 @@ export { encodeBase64 } from './utils/base64';
 export type { PasswordRules } from './validators';
 export { isAadhaar, isAlphanumeric, isBetween, isEmail, isGstin, isHexColor, isIfsc, isIndianMobile, isIndianPincode, isInteger, isNonEmpty, isNumeric, isPan, isPhone, isStrongPassword, isUrl, maxLength, minLength } from './validators';
 export type { DeviceInfoLike, ParsedVersion, Platform, UpdateInfo, UpdateType, VersionCheckResult, VersionCheckType, VersionComparison, VersionData } from './versionCheck';
-export { setDeviceInfoImplementation, useVersionCheck, VersionCheck } from './versionCheck';
+export { isBuildBelowMinimum, parseBuildNumber, setDeviceInfoImplementation, useVersionCheck, VersionCheck } from './versionCheck';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/initSDK.d.ts

@@ -16,23 +16,35 @@ export interface InitConfig {
     /** Environment. Defaults to `'Development'`. */
     environment?: Environment;
     /**
-     * ISO 3166-1 alpha-2 country code (lowercase) used for App Store / Play Store
-     * version checks. Defaults to `'in'`.
+     * ISO 3166-1 alpha-2 country code (lowercase) used in the App Store / Play
+     * Store link of the update prompt. Defaults to `'in'`.
      */
     country?: string;
     /**
-     * The app's store identifier (Android package name / iOS bundle id) and its
-     * user-visible version, both needed by the version-check module. Every
-     * Webority app already has them in `appsettings.Compiled.json`, which is why
-     * they come from config rather than across the native bridge.
+     * The app's store identifier (Android package name / iOS bundle id), its
+     * user-visible version and its internal build number (`VERSION_INTERNAL`).
+     * Every Webority app already has them in `appsettings.Compiled.json`, which
+     * is why they come from config rather than across the native bridge. The
+     * version check compares `appBuild` with the API's `X-Min-App-Version`.
      */
     appId?: string;
     appVersion?: string;
+    appBuild?: number;
+    /** The numeric Apple App Store id; the iOS update button needs it. */
+    appStoreId?: string;
+    /** The build's short git sha (`COMMIT` in appsettings); sent as `X-Client-Build: <appVersion>+<commit>`. */
+    commit?: string;
     /**
      * Log a redacted curl line per request. Off by default; it is a debugging
      * aid, not something to leave on.
      */
     logCurl?: boolean;
+    /** Request timeout in milliseconds. Defaults to 30000; a request's own `timeout` wins. */
+    timeoutMs?: number;
+    /** Retries under the retry rule. Defaults to 3; 0 turns retrying off. */
+    retries?: number;
+    /** Header for the per-request correlation id. Defaults to `'X-Correlation-Id'`; `null` sends none. */
+    correlationIdHeader?: string | null;
     /**
      * The native modules that fill the seams the library does not import.
      *

package/lib/typescript/commonjs/initUserAuth.d.ts

@@ -1,3 +1,5 @@
+import type { AccountIdProvider } from './api/clientHeaders';
+import { type LegacyTokenKeys } from './auth/authStore';
 /** The tokens a refresh response carries, with their expiry timestamps. */
 export interface TokenRefreshResult {
     accessToken: string;
@@ -17,6 +19,12 @@ export interface TokenRefreshConfig {
         accessToken: string | null;
         refreshToken: string;
     }) => unknown;
+    /**
+     * Extra headers for the refresh call, read on every refresh; may return a promise. For a
+     * value the API must see as a header, such as `X-Installation-Id` for a rate limiter that
+     * cannot read the body.
+     */
+    headers?: () => Record<string, string> | Promise<Record<string, string>>;
     /**
      * Reads the new tokens from the response body. Defaults to the Webority API's
      * `{ accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration }`.
@@ -27,12 +35,33 @@ export interface UserAuthOptions {
     /** Action creator dispatched when the session is over. */
     logout: () => unknown;
     refresh: TokenRefreshConfig;
+    /**
+     * The account the signed-in user is working in, sent as `X-Account-Id` on
+     * every userClient request. Read on every send, so a switch applies at once.
+     * Omit it in a product whose API takes the account from the token alone.
+     */
+    accountId?: AccountIdProvider;
+    /**
+     * The response header in which the API names why it ended a session. A 401 carrying it is a
+     * revoked session: no refresh is tried, the session is cleared as `terminated`, and the
+     * value reaches every `addSessionEndedListener` listener as `detail.signOutReason`. It is
+     * read from a refused refresh too. Default `'X-Sign-Out-Reason'`; `null` turns it off.
+     */
+    signOutReasonHeader?: string | null;
+    /**
+     * The secure-store keys the app kept its session under before this library. The first token
+     * read that finds the library's keys empty moves a session found there and deletes the old
+     * keys, so the release that adopts the library signs nobody out.
+     */
+    legacyKeys?: LegacyTokenKeys;
 }
 /**
  * Wire the user client to the app: the Redux store it dispatches `logout` to,
  * and the refresh endpoint it calls when an access token expires or a request
  * answers 401. Only a 400 or 401 from that endpoint, or a missing or expired
  * refresh token, logs out; a network error, timeout or 5xx keeps the session.
+ * Logging out clears the session first (`clearSession('rejected' | 'terminated')`),
+ * so the tokens are gone and the session-ended listeners hear it, then dispatches `logout`.
  *
  * @example
  * initUserAuth(store, { logout, refresh: { path: '/Account/RefreshToken' } });

package/lib/typescript/commonjs/logger/index.d.ts

@@ -6,6 +6,7 @@ type LogFn = (message: string, ...optionalParams: unknown[]) => void;
  * library depend on any of them.
  *
  * Every method is optional; the library calls only what the adapter implements.
+ * `log` receives `info`, `warn` and `error` lines; `debug` never leaves the console.
  */
 export interface RemoteLogger {
     /** Append a breadcrumb (small, non-error event) for crash context. */
@@ -57,7 +58,21 @@ export interface LoggerOptions {
 }
 /** Configure dedupe window/threshold and screen history size. Merges with current options. */
 export declare const configureLogger: (options: LoggerOptions) => void;
+/** What `Logger.requestFailed` is told about the call beside the error itself. */
+export interface RequestFailedContext {
+    /** What the call was, in words: `'Load projects'`. Names the log line; defaults to the method and path. */
+    label?: string;
+    /**
+     * Statuses this call answers as part of its work (a 409 the screen explains, a 404 that
+     * means "none yet"): logged as a warning, never recorded as an error.
+     */
+    expectedStatuses?: readonly number[];
+    /** Anything else worth carrying to the remote sink. Never a token or a request body. */
+    [key: string]: unknown;
+}
 export interface LoggerType {
+    /** Console only, never forwarded to the remote sink. */
+    debug: LogFn;
     info: LogFn;
     warn: LogFn;
     error: LogFn;
@@ -65,6 +80,8 @@ export interface LoggerType {
     breadcrumb: (message: string, data?: Record<string, unknown>) => void;
     /** Record a non-fatal error with optional context. */
     recordError: (error: unknown, context?: Record<string, unknown>) => void;
+    /** Log a failed service call: cancel as info, an expected status as a warning, anything else as a recorded error. */
+    requestFailed: (error: unknown, context?: RequestFailedContext) => void;
     /** Bind a user identity for subsequent crash reports. */
     setUser: (id: string | null, attrs?: Record<string, unknown>) => void;
     /** Attach a custom attribute (release, build, env, role, etc.). */

package/lib/typescript/commonjs/query/apiBaseQuery.d.ts

@@ -0,0 +1,55 @@
+import type { BaseQueryFn } from '@reduxjs/toolkit/query';
+import { type AxiosInstance, type Method, type ResponseType } from 'axios';
+import { type ApiError } from '../errors';
+/**
+ * What an endpoint's `query` returns. A bare string is a GET of that URL.
+ *
+ * `silent` opts this call out of the error toast (decision 42); an endpoint can
+ * instead set it once for every call with `extraOptions: { silent: true }`.
+ * `public` sends the call through the anonymous client (sign-in, sign-up, a
+ * public lookup), so one `createApi` serves both clients.
+ */
+export interface ApiRequest {
+    url: string;
+    method?: Method;
+    /** The request body. FormData is sent as multipart by the client. */
+    data?: unknown;
+    /** Query string values; build list queries with `buildListQuery`. */
+    params?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    /** Only JSON-safe types belong in the store; a blob download stays a service call. */
+    responseType?: Extract<ResponseType, 'json' | 'text'>;
+    timeout?: number;
+    silent?: boolean;
+    public?: boolean;
+}
+export type ApiQueryArgs = string | ApiRequest;
+/** Per-endpoint options, set as the endpoint's `extraOptions`. */
+export interface ApiExtraOptions {
+    silent?: boolean;
+}
+/**
+ * Returned as the base query's `meta`, which RTK Query copies onto the
+ * fulfilled and rejected actions as `action.meta.baseQueryMeta`. The toast
+ * middleware reads `silent` there. Plain values only, so the store stays
+ * serializable.
+ */
+export interface ApiBaseQueryMeta {
+    silent: boolean;
+    /** The HTTP status, or 0 when no response arrived. */
+    status: number;
+}
+export interface ApiBaseQueryOptions {
+    /** The signed-in client every call uses by default (`userClient`). */
+    client: AxiosInstance;
+    /** The anonymous client for calls marked `public: true` (`publicClient`). */
+    publicClient?: AxiosInstance;
+}
+export type ApiBaseQuery = BaseQueryFn<ApiQueryArgs, unknown, ApiError, ApiExtraOptions, ApiBaseQueryMeta>;
+/**
+ * The fleet RTK Query base query: every call goes through our axios clients,
+ * so refresh, retry, the offline check and logging stay in one place, and a
+ * failure comes back as the same `ApiError` a thunk rejects with.
+ */
+export declare const createApiBaseQuery: ({ client, publicClient }: ApiBaseQueryOptions) => ApiBaseQuery;
+//# sourceMappingURL=apiBaseQuery.d.ts.map

package/lib/typescript/commonjs/query/createAppApi.d.ts

@@ -0,0 +1,21 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+/**
+ * The fleet `createApi` defaults. Unused data is kept a minute, and active
+ * queries refetch when the connection returns and when the user comes back to
+ * the app. Both flags only act once the app calls `setupApiListeners` on its
+ * store: window focus and online events on the web, `AppState` and the
+ * network status on a device.
+ */
+export declare const APP_API_DEFAULTS: {
+    readonly keepUnusedDataFor: 60;
+    readonly refetchOnReconnect: true;
+    readonly refetchOnFocus: true;
+};
+/**
+ * `createApi` with the fleet defaults; anything the app passes wins. One per
+ * app, in `services/api/apiSlice`, with `baseQuery: createApiBaseQuery(...)`
+ * and the app's `tagTypes`. Imported from the React entry so endpoints get
+ * their hooks; that entry needs `react-redux`, which every app has.
+ */
+export declare const createAppApi: typeof createApi;
+//# sourceMappingURL=createAppApi.d.ts.map

package/lib/typescript/commonjs/query/index.d.ts

@@ -0,0 +1,9 @@
+export type { ApiBaseQuery, ApiBaseQueryMeta, ApiBaseQueryOptions, ApiExtraOptions, ApiQueryArgs, ApiRequest } from './apiBaseQuery';
+export { createApiBaseQuery } from './apiBaseQuery';
+export { APP_API_DEFAULTS, createAppApi } from './createAppApi';
+export { setupApiListeners } from './listeners';
+export type { ListFilterValue, ListQuery, PagedDataObject, PagedListRequest, SortOrder } from './paging';
+export { buildListQuery, getNextPageParam, getPreviousPageParam, hasNextPage, hasPreviousPage } from './paging';
+export type { ApiTag, TagId } from './tags';
+export { itemTag, LIST_TAG_ID, listTag, providesList, providesPagedList } from './tags';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/query/listeners.d.ts

@@ -0,0 +1,11 @@
+import type { ThunkDispatch, UnknownAction } from '@reduxjs/toolkit';
+/**
+ * Wires `refetchOnFocus` and `refetchOnReconnect` to the device. RTK's default
+ * handlers listen to `window` focus and online events, which never fire in
+ * React Native, so the app returning to the foreground counts as focus and
+ * mobile-core's network status drives online and offline (the same status the
+ * user client checks before every request). Call once after the store is
+ * created; it returns the unsubscribe.
+ */
+export declare const setupApiListeners: (dispatch: ThunkDispatch<unknown, unknown, UnknownAction>) => (() => void);
+//# sourceMappingURL=listeners.d.ts.map

package/lib/typescript/commonjs/query/paging.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The fleet list contract, matching Webority.Delivery: the request is
+ * `PagedListRequest` (`page` 1-based, `pageSize`, `sortBy`, `sortOrder`) plus the
+ * endpoint's filters, and the response is `PagedDataObject<T>`. The server
+ * defaults a missing page to 1 and a missing size to 20, and cuts a size over
+ * 100 to 100.
+ */
+export interface PagedDataObject<T> {
+    items: T[];
+    page: number;
+    pageSize: number;
+    totalCount: number;
+    totalPages: number;
+}
+export type SortOrder = 'asc' | 'desc';
+export interface PagedListRequest {
+    page?: number;
+    pageSize?: number;
+    sortBy?: string;
+    sortOrder?: SortOrder;
+}
+export type ListFilterValue = string | number | boolean | null | undefined;
+export interface ListQuery extends PagedListRequest {
+    filters?: Record<string, ListFilterValue>;
+}
+/**
+ * The `params` for a list endpoint. Filters sit beside the paging keys, as the
+ * API's request type derives from `PagedListRequest`. Unset values and empty
+ * strings are dropped, so a cleared filter never sends `?status=`. A filter
+ * named like a paging key is refused rather than silently overriding it.
+ */
+export declare const buildListQuery: ({ page, pageSize, sortBy, sortOrder, filters }: ListQuery) => Record<string, string | number | boolean>;
+export declare const hasNextPage: (page: PagedDataObject<unknown>) => boolean;
+export declare const hasPreviousPage: (page: PagedDataObject<unknown>) => boolean;
+/**
+ * `getNextPageParam` for an RTK Query infinite query over a paged endpoint
+ * (pull-to-load lists): the next page number, or `undefined` on the last page.
+ */
+export declare const getNextPageParam: (lastPage: PagedDataObject<unknown>) => number | undefined;
+/** `getPreviousPageParam` for the same infinite query. */
+export declare const getPreviousPageParam: (firstPage: PagedDataObject<unknown>) => number | undefined;
+//# sourceMappingURL=paging.d.ts.map

package/lib/typescript/commonjs/query/tags.d.ts

@@ -0,0 +1,31 @@
+import type { PagedDataObject } from './paging';
+/**
+ * The fleet tag convention. A list read provides `{ type, id: 'LIST' }` plus one
+ * tag per row; a create invalidates `LIST`, an update or delete invalidates the
+ * row's tag (and `LIST` when it changes membership or order). Row ids are the
+ * public ids the API returns (D-039), never an internal key.
+ */
+export declare const LIST_TAG_ID = "LIST";
+export type TagId = string | number;
+export interface ApiTag<TagType extends string> {
+    type: TagType;
+    id: TagId;
+}
+type IdSelector<T> = (item: T) => TagId;
+export declare const listTag: <TagType extends string>(type: TagType) => ApiTag<TagType>;
+export declare const itemTag: <TagType extends string>(type: TagType, id: TagId) => ApiTag<TagType>;
+/** Tags for a list response. A failed read still provides `LIST`, so the next write refetches it. */
+export declare function providesList<TagType extends string, T extends {
+    publicId: string;
+}>(type: TagType, items: readonly T[] | undefined): ApiTag<TagType>[];
+export declare function providesList<TagType extends string, T>(type: TagType, items: readonly T[] | undefined, selectId: IdSelector<T>): ApiTag<TagType>[];
+/**
+ * `providesTags` for an endpoint returning `PagedDataObject<T>`:
+ * `providesTags: providesPagedList('Project')`.
+ */
+export declare function providesPagedList<TagType extends string, T extends {
+    publicId: string;
+}>(type: TagType): (result: PagedDataObject<T> | undefined) => ApiTag<TagType>[];
+export declare function providesPagedList<TagType extends string, T>(type: TagType, selectId: IdSelector<T>): (result: PagedDataObject<T> | undefined) => ApiTag<TagType>[];
+export {};
+//# sourceMappingURL=tags.d.ts.map

package/lib/typescript/commonjs/redux/errorToastMiddleware.d.ts

@@ -0,0 +1,51 @@
+import type { Middleware, MiddlewareAPI, UnknownAction } from '@reduxjs/toolkit';
+import { type ApiError } from '../errors/extractApiError';
+/**
+ * Toasts every rejected thunk and every failed RTK Query call, so no screen has to remember
+ * to surface a failure and none words it differently. Identical source in web-core and
+ * mobile-core; the toast itself comes in through `showToast`, so there is no UI dependency.
+ *
+ * Opt out with `silent: true` (decision 42), wherever the caller can put it:
+ *   - a thunk: `rejectWithValue(extractApiError(e), { silent: true })`, or `{ silent: true }`
+ *     in the thunk's object argument;
+ *   - an RTK Query call: `{ silent: true }` in the call's argument object;
+ *   - an RTK Query endpoint: `extraOptions: { silent: true }`, which the base query copies
+ *     onto its meta.
+ *
+ * Never toasted: an aborted thunk or a cancelled request (a screen unmounting), an RTK Query
+ * condition skip (the data is already cached), a 401 by default (the auth layer owns a dead
+ * session). Identical messages are de-duplicated for `dedupeMs`, because a screen that fires
+ * four fetches and loses the network would otherwise stack four copies of one sentence.
+ *
+ * `onRejected` is the product's say over one rejection, run before the default rules:
+ * `'toast'` shows it even where `ignoreCodes` or `ignoreStatuses` would not (a 401 that names a
+ * code is a refused sign-in, not a dead session), `'silent'` drops it, and nothing at all leaves
+ * the default rules to decide. It runs for silent rejections too, so a side effect (a
+ * read-only workspace notice, a profile refetch) fires whichever screen asked; `silent: true`
+ * still keeps the default toast off, because the screen said it answers the failure itself.
+ */
+export type ShowErrorToast = (message: string, error: ApiError) => void;
+/** What `onRejected` decides for one rejection: `'toast'`, `'silent'`, or nothing for the default rules. */
+export type RejectionDecision = 'toast' | 'silent' | undefined;
+/**
+ * The product's hook into every rejection the middleware sees. `api` is the store's
+ * `dispatch` and `getState`, for a side effect that reads or updates state.
+ */
+export type OnRejected = (action: UnknownAction, error: ApiError, api: MiddlewareAPI) => RejectionDecision;
+export interface ErrorToastOptions {
+    showToast: ShowErrorToast;
+    /** Server `code` values a screen answers in its own way (a paywall, a terms gate). */
+    ignoreCodes?: readonly string[];
+    /** HTTP statuses never toasted. Default `[401]`. */
+    ignoreStatuses?: readonly number[];
+    /** Window in which an identical message is shown once. Default 4000 ms; 0 disables. */
+    dedupeMs?: number;
+    /** Decides one rejection before the default rules; see the module comment. */
+    onRejected?: OnRejected;
+}
+type Dict = Record<string, unknown>;
+/** Is this a rejected createAsyncThunk or RTK Query action that asked not to be toasted? */
+export declare const isSilentRejection: (meta: Dict) => boolean;
+export declare function errorToastMiddleware(options: ErrorToastOptions): Middleware;
+export {};
+//# sourceMappingURL=errorToastMiddleware.d.ts.map

package/lib/typescript/commonjs/redux/index.d.ts

@@ -0,0 +1,6 @@
+export type { ErrorToastOptions, OnRejected, RejectionDecision, ShowErrorToast } from './errorToastMiddleware';
+export { errorToastMiddleware, isSilentRejection } from './errorToastMiddleware';
+export type { RootReducerOptions } from './rootReducer';
+export { createRootReducer, resetState } from './rootReducer';
+export { SERIALIZABLE_IGNORED_ACTION_PATHS } from './serializableCheck';
+//# sourceMappingURL=index.d.ts.map