@symbiote-native/localization 0.0.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,153 @@
+# @symbiote-native/localization
+
+Port of [`expo-localization`](https://docs.expo.dev/versions/latest/sdk/localization/) for
+[SymbioteNative](../../README.md) — the device's locale list and preferred calendar settings,
+reachable from every adapter (React, Vue, Angular), not just React.
+
+Built the same way as [`@symbiote-native/battery`](../battery) and
+[`@symbiote-native/device`](../device), an `expo-modules-core`-based wrapper (see the
+`symbiote-expo-native-module` project skill for the full mechanism: why `expo-modules-core` is
+depended on directly and never the `expo` meta-package, why the upstream JS is hand-ported into
+`core/` rather than imported, and how autolinking picks up the native module).
+
+## Install
+
+```bash
+npm install @symbiote-native/localization
+```
+
+Depends on `expo-localization` and `expo-modules-core` directly (regular dependencies, pinned to
+exact versions — never a caret range, since this package's `core/` is hand-ported against one
+specific native API shape and a newer resolve could silently drift the two apart). Never install
+`expo-localization` yourself, and never add the `expo` package to this project — it bundles its
+own Metro/Babel pipeline that conflicts with this project's own.
+
+### Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-localization`'s native code is discovered by
+`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism — this needs wiring
+into the native host app **once**, covering this package and every other `expo-modules-core`
+package (`@symbiote-native/battery`, `@symbiote-native/device`, ...) with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+
+Full mechanics — the Podfile pieces that normally ship inside the `expo` package, the `expo`
+peer-dependency exclusion list — live in the `symbiote-expo-native-module` skill. Reference
+implementation: `.examples/expo-react/ios/Podfile` and
+`.examples/expo-react/android/app/src/main/java/com/canary/MainApplication.kt`.
+
+No platform permission string is needed — locale and calendar settings are read-only system
+state with no runtime permission prompt on either platform.
+
+## Shape
+
+```
+src/core/               types.ts — Locale, Weekday, CalendarIdentifier, Calendar, hand-ported
+                        verbatim from Localization.types.ts. native-module.ts resolves the
+                        native module through expo-modules-core's requireNativeModule and
+                        exposes addLocaleListener/addCalendarListener. localization.ts —
+                        getLocales/getCalendars, synchronous getters delegating straight to the
+                        native module.
+src/react/hooks/        @symbiote-native/localization/react   — useLocales, useCalendars
+src/vue/composables/    @symbiote-native/localization/vue     — same two names, Vue lifecycle
+src/angular/services/   @symbiote-native/localization/angular — LocalesService, CalendarsService
+                        (`.connect()` returns a Signal)
+```
+
+Two independent getters, each with its own native change listener and its own reactive hook per
+adapter — mirroring `@symbiote-native/battery`'s shape of shipping several distinct hooks in one
+package, not one combined hook. Each hook/composable/service seeds its return value from the
+matching synchronous `get*()` call (no initial "loading" state needed — the native call is
+sync, not async) and recomputes it whenever the matching listener fires.
+
+## Use it
+
+```tsx
+// React — examples/expo-react/screens/LocalizationScreen.tsx
+import { useLocales, useCalendars } from '@symbiote-native/localization/react';
+
+function LocalizationScreen() {
+  const locales = useLocales();       // Locale[], guaranteed at least 1 element
+  const calendars = useCalendars();   // Calendar[], guaranteed at least 1 element
+
+  return (
+    <>
+      <Text>{locales[0].languageTag}</Text>
+      <Text>{calendars[0].timeZone}</Text>
+    </>
+  );
+}
+```
+
+```vue
+<!-- Vue — examples/expo-vue-sfc/screens/LocalizationScreen.vue -->
+<script setup lang="ts">
+import { useLocales, useCalendars } from '@symbiote-native/localization/vue';
+
+const locales = useLocales();     // Ref<Locale[]>
+const calendars = useCalendars(); // Ref<Calendar[]>
+</script>
+<template>
+  <Text>{{ locales[0].languageTag }}</Text>
+  <Text>{{ calendars[0].timeZone }}</Text>
+</template>
+```
+
+```ts
+// Angular — examples/expo-angular/src/screens/LocalizationScreen.ts
+import { Component, inject } from '@angular/core';
+import { LocalesService, CalendarsService } from '@symbiote-native/localization/angular';
+
+@Component({ /* ... */ })
+export class LocalizationScreen {
+  readonly locales = inject(LocalesService).connect();     // Signal<Locale[]>
+  readonly calendars = inject(CalendarsService).connect();  // Signal<Calendar[]>
+}
+```
+
+## API
+
+Two independent synchronous getters (`getLocales`, `getCalendars`), each with its own
+listener-based subscription (`addLocaleListener`/`addCalendarListener`) and its own adapter-level
+lifecycle hook — one hook/composable/service per getter, matching upstream's own `useLocales`/
+`useCalendars` being two separate hooks, not one combined hook.
+
+```ts
+getLocales(): Locale[]                                        // user's locales, in device-settings order
+getCalendars(): Calendar[]                                    // user's preferred calendars
+addLocaleListener(listener): EventSubscription                 // fires when locale settings change
+addCalendarListener(listener): EventSubscription                // fires when calendar settings change
+```
+
+Plus `Locale`, `Weekday` (enum), `CalendarIdentifier` (enum), `Calendar` — ported from upstream's
+`Localization.types.ts`.
+
+```ts
+import { getLocales, getCalendars } from '@symbiote-native/localization';
+
+// framework-scoped entry points re-export the same free functions, plus a lifecycle
+// hook/composable/service per getter:
+import { useLocales, useCalendars } from '@symbiote-native/localization/react';
+import { useLocales, useCalendars } from '@symbiote-native/localization/vue';
+import { LocalesService, CalendarsService } from '@symbiote-native/localization/angular';
+```
+
+Each hook/composable/service seeds its initial value from the matching synchronous `get*()`
+call, then subscribes to the matching listener for updates, and unsubscribes on unmount —
+mirroring upstream's own `useLocales`/`useCalendars`.
+
+## Test it
+
+No Fabric/Descriptor angle at all — localization is a pure synchronous-function + `EventEmitter`
+listener surface, never a view. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution (`src/core/localization.test.ts`,
+`src/{react,vue,angular}/**/*.test.{ts,tsx}`, `vitest`), the same pattern
+`@symbiote-native/battery` and `@symbiote-native/device` use — no `installFabric()`, no
+ViewConfig for the core test; the adapter hook/composable/service tests do use `installFabric()`
+purely to mount a host component, same as every other sibling package. Native rendering itself is
+verified on-device — see the parent [README](../../README.md).

package/build/angular/index.d.ts

@@ -0,0 +1,3 @@
+export { LocalesService } from './services/locales.service';
+export { CalendarsService } from './services/calendars.service';
+export { getLocales, getCalendars, addLocaleListener, addCalendarListener, Weekday, CalendarIdentifier, type Locale, type Calendar, type EventSubscription, } from '../core';

package/build/angular/index.js

@@ -0,0 +1,7 @@
+// LocalesService/CalendarsService are the Angular-only lifecycle half; the free functions and
+// event subscription plumbing all live in core, shared with React/Vue. Two separate services
+// (not one combined service), matching upstream's own useLocales/useCalendars being two separate
+// hooks.
+export { LocalesService } from './services/locales.service';
+export { CalendarsService } from './services/calendars.service';
+export { getLocales, getCalendars, addLocaleListener, addCalendarListener, Weekday, CalendarIdentifier, } from '../core';

package/build/angular/services/calendars.service/index.d.ts

@@ -0,0 +1,6 @@
+import { type Signal } from '@angular/core';
+import { type Calendar } from '../../../core';
+export declare class CalendarsService {
+    private readonly injector;
+    connect(): Signal<Calendar[]>;
+}

package/build/angular/services/calendars.service/index.js

@@ -0,0 +1,68 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addCalendarListener, getCalendars } from '../../../core';
+// Angular twin of React's `useCalendars` hook and Vue's `useCalendars` composable — mirrors
+// LocalesService's shape exactly.
+//
+//   readonly calendars = inject(CalendarsService).connect();
+//   // template: {{ calendars() }}
+let CalendarsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var CalendarsService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            CalendarsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        injector = inject(Injector);
+        connect() {
+            const calendars = signal(getCalendars());
+            effect(onCleanup => {
+                const subscription = addCalendarListener(() => calendars.set(getCalendars()));
+                onCleanup(() => subscription.remove());
+            }, { injector: this.injector });
+            return calendars.asReadonly();
+        }
+    };
+    return CalendarsService = _classThis;
+})();
+export { CalendarsService };

package/build/angular/services/locales.service/index.d.ts

@@ -0,0 +1,6 @@
+import { type Signal } from '@angular/core';
+import { type Locale } from '../../../core';
+export declare class LocalesService {
+    private readonly injector;
+    connect(): Signal<Locale[]>;
+}

package/build/angular/services/locales.service/index.js

@@ -0,0 +1,69 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addLocaleListener, getLocales } from '../../../core';
+// Angular twin of React's `useLocales` hook and Vue's `useLocales` composable. See
+// packages/battery's BatteryStateService for the `connect()` pattern rationale. getLocales() is
+// synchronous, so the signal seeds from it directly rather than an async `.then()` fetch.
+//
+//   readonly locales = inject(LocalesService).connect();
+//   // template: {{ locales() }}
+let LocalesService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var LocalesService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            LocalesService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        injector = inject(Injector);
+        connect() {
+            const locales = signal(getLocales());
+            effect(onCleanup => {
+                const subscription = addLocaleListener(() => locales.set(getLocales()));
+                onCleanup(() => subscription.remove());
+            }, { injector: this.injector });
+            return locales.asReadonly();
+        }
+    };
+    return LocalesService = _classThis;
+})();
+export { LocalesService };

package/build/core/index.d.ts

@@ -0,0 +1,4 @@
+export { getLocales, getCalendars } from './localization';
+export { addLocaleListener, addCalendarListener } from './native-module';
+export { Weekday, CalendarIdentifier, type Locale, type Calendar } from './types';
+export type { EventSubscription } from 'expo-modules-core';

package/build/core/index.js

@@ -0,0 +1,3 @@
+export { getLocales, getCalendars } from './localization';
+export { addLocaleListener, addCalendarListener } from './native-module';
+export { Weekday, CalendarIdentifier } from './types';

package/build/core/localization.d.ts

@@ -0,0 +1,39 @@
+import type { Calendar, Locale } from './types';
+/**
+ * List of user's locales, returned as an array of objects of type `Locale`.
+ * Guaranteed to contain at least 1 element.
+ * These are returned in the order the user defines in their device settings.
+ * On the web currency and measurements systems are not provided, instead returned as null.
+ * If needed, you can infer them from the current region using a lookup table.
+ * @example
+ * ```js
+ * [{
+ *   "languageTag": "pl-PL",
+ *   "languageCode": "pl",
+ *   "textDirection": "ltr",
+ *   "digitGroupingSeparator": " ",
+ *   "decimalSeparator": ",",
+ *   "measurementSystem": "metric",
+ *   "currencyCode": "PLN",
+ *   "currencySymbol": "zł",
+ *   "regionCode": "PL",
+ *   "temperatureUnit": "celsius"
+ * }]
+ * ```
+ */
+export declare const getLocales: () => Locale[];
+/**
+ * List of user's preferred calendars, returned as an array of objects of type `Calendar`.
+ * Guaranteed to contain at least 1 element.
+ * For now always returns a single element, but it's likely to return a user preference list on some platforms in the future.
+ * @example
+ * ```js
+ * [{
+ *   "calendar": "gregory",
+ *   "timeZone": "Europe/Warsaw",
+ *   "uses24hourClock": true,
+ *   "firstWeekday": 1
+ * }]
+ * ```
+ */
+export declare const getCalendars: () => Calendar[];

package/build/core/localization.js

@@ -0,0 +1,42 @@
+// Hand-ported from .vendors/expo/packages/expo-localization/src/Localization.ts (sdk-57) —
+// both functions delegate straight to the native module, no extra wrapping needed beyond typing
+// them as synchronous getters.
+import ExpoLocalizationModule from './native-module';
+/**
+ * List of user's locales, returned as an array of objects of type `Locale`.
+ * Guaranteed to contain at least 1 element.
+ * These are returned in the order the user defines in their device settings.
+ * On the web currency and measurements systems are not provided, instead returned as null.
+ * If needed, you can infer them from the current region using a lookup table.
+ * @example
+ * ```js
+ * [{
+ *   "languageTag": "pl-PL",
+ *   "languageCode": "pl",
+ *   "textDirection": "ltr",
+ *   "digitGroupingSeparator": " ",
+ *   "decimalSeparator": ",",
+ *   "measurementSystem": "metric",
+ *   "currencyCode": "PLN",
+ *   "currencySymbol": "zł",
+ *   "regionCode": "PL",
+ *   "temperatureUnit": "celsius"
+ * }]
+ * ```
+ */
+export const getLocales = ExpoLocalizationModule.getLocales;
+/**
+ * List of user's preferred calendars, returned as an array of objects of type `Calendar`.
+ * Guaranteed to contain at least 1 element.
+ * For now always returns a single element, but it's likely to return a user preference list on some platforms in the future.
+ * @example
+ * ```js
+ * [{
+ *   "calendar": "gregory",
+ *   "timeZone": "Europe/Warsaw",
+ *   "uses24hourClock": true,
+ *   "firstWeekday": 1
+ * }]
+ * ```
+ */
+export const getCalendars = ExpoLocalizationModule.getCalendars;

package/build/core/native-module.d.ts

@@ -0,0 +1,12 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { Calendar, Locale } from './types';
+export type INativeLocalizationModule = {
+    getLocales(): Locale[];
+    getCalendars(): Calendar[];
+    addListener(eventName: 'onLocaleSettingsChanged', listener: (event?: unknown) => void): EventSubscription;
+    addListener(eventName: 'onCalendarSettingsChanged', listener: (event?: unknown) => void): EventSubscription;
+};
+declare const ExpoLocalizationModule: INativeLocalizationModule;
+export declare function addLocaleListener(listener: (event?: unknown) => void): EventSubscription;
+export declare function addCalendarListener(listener: (event?: unknown) => void): EventSubscription;
+export default ExpoLocalizationModule;

package/build/core/native-module.js

@@ -0,0 +1,21 @@
+// Hand-ported from .vendors/expo/packages/expo-localization/src/ExpoLocalization.native.ts
+// (sdk-57). getLocales()/getCalendars() are synchronous, JSI-bridged native calls (no await) —
+// the native module itself implements them as sync-bridged functions, the same constants-style
+// read pattern this repo already uses for expo-device's eagerly-resolved fields
+// (packages/device/src/core/native-module.ts). One native module fans out two independent event
+// streams (locale settings vs calendar settings) through the same addListener, keyed by event
+// name — mirrors the three-event-names-on-one-addListener overload trick in
+// packages/battery/src/core/native-module.ts.
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_LOCALIZATION_MODULE_NAME = 'ExpoLocalization';
+const ExpoLocalizationModule = requireNativeModule(EXPO_LOCALIZATION_MODULE_NAME);
+export function addLocaleListener(
+// NOTE: upstream never uses the event's data — the listener is invoked purely as an
+// invalidate signal for useLocales/the Vue composable/the Angular service below.
+listener) {
+    return ExpoLocalizationModule.addListener('onLocaleSettingsChanged', listener);
+}
+export function addCalendarListener(listener) {
+    return ExpoLocalizationModule.addListener('onCalendarSettingsChanged', listener);
+}
+export default ExpoLocalizationModule;

package/build/core/types.d.ts

@@ -0,0 +1,174 @@
+export type Locale = {
+    /**
+     * An [IETF BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) with a region code.
+     * @example
+     * `'en-US'`, `'es-419'`, `'pl-PL'`.
+     */
+    languageTag: string;
+    /**
+     * An [IETF BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) without the region code.
+     * @example
+     * `'en'`, `'es'`, `'pl'`.
+     */
+    languageCode: string | null;
+    /**
+     * An [ISO 15924](https://en.wikipedia.org/wiki/ISO_15924) 4-letter script code. On Android and Web, it may be `null` if none is defined.
+     * @example
+     * `'Latn'`, `'Hans'`, `'Hebr'`.
+     */
+    languageScriptCode: string | null;
+    /**
+     * The region code for your device that comes from the Region setting under Language & Region on iOS, Region settings on Android and is parsed from locale on Web (can be `null` on Web).
+     * @example
+     * `'US'`.
+     */
+    regionCode: string | null;
+    /**
+     * The region code for the preferred language. When the language is not region-specific, it returns the same value as `regionCode`. When the language is region-specific, it returns the region code for the language (`en-CA` -> `CA`).
+     * Prefer using `regionCode` for any internalization purposes.
+     * @example
+     * `'US'`.
+     */
+    languageRegionCode: string | null;
+    /**
+     * Currency code for the locale.
+     * On iOS, it's the currency code from the `Region` setting under Language & Region, not for the current locale.
+     * On Android, it's the currency specifc to the locale in the list, as there are no separate settings for selecting a region.
+     * Is `null` on Web, use a table lookup based on region instead.
+     * @example
+     * `'USD'`, `'EUR'`, `'PLN'`.
+     */
+    currencyCode: string | null;
+    /**
+     * Currency symbol for the currency specified by `currencyCode`.
+     * @example
+     * `'$'`, `'€'`, `'zł'`.
+     */
+    currencySymbol: string | null;
+    /**
+     * Currency code for the locale.
+     * On iOS, it's the currency code for the current locale in the list, not the device region.
+     * On Android, it's equal to `currencyCode`.
+     * Is `null` on Web.
+     * Prefer using `currencyCode` for any internalization purposes.
+     * @example
+     * `'USD'`, `'EUR'`, `'PLN'`.
+     */
+    languageCurrencyCode: string | null;
+    /**
+     * Currency symbol for the currency specified by `languageCurrencyCode`.
+     * Prefer using `currencySymbol` for any internalization purposes.
+     * @example
+     * `'$'`, `'€'`, `'zł'`.
+     */
+    languageCurrencySymbol: string | null;
+    /**
+     * Decimal separator used for formatting numbers with fractional parts.
+     * @example
+     * `'.'`, `','`.
+     */
+    decimalSeparator: string | null;
+    /**
+     * Digit grouping separator used for formatting large numbers.
+     * @example
+     * `'.'`, `','`.
+     */
+    digitGroupingSeparator: string | null;
+    /**
+     * Text direction for the locale. One of: `'ltr'`, `'rtl'`.
+     */
+    textDirection: 'ltr' | 'rtl';
+    /**
+     * The measurement system used in the locale.
+     * Is `null` on Web, as user chosen measurement system is not exposed on the web and using locale to determine measurement systems is unreliable.
+     * Ask for user preferences if possible.
+     */
+    measurementSystem: `metric` | `us` | `uk` | null;
+    /**
+     * The temperature unit used in the locale.
+     * Returns `null` if the region code is unknown.
+     */
+    temperatureUnit: 'celsius' | 'fahrenheit' | null;
+};
+/**
+ * An enum mapping days of the week in Gregorian calendar to their index as returned by the `firstWeekday` property.
+ */
+export declare enum Weekday {
+    SUNDAY = 1,
+    MONDAY = 2,
+    TUESDAY = 3,
+    WEDNESDAY = 4,
+    THURSDAY = 5,
+    FRIDAY = 6,
+    SATURDAY = 7
+}
+/**
+ * The calendar identifier, one of [Unicode calendar types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendar).
+ */
+export declare enum CalendarIdentifier {
+    /** Thai Buddhist calendar */
+    BUDDHIST = "buddhist",
+    /** Traditional Chinese calendar */
+    CHINESE = "chinese",
+    /** Coptic calendar */
+    COPTIC = "coptic",
+    /** Traditional Korean calendar */
+    DANGI = "dangi",
+    /** Ethiopic calendar, Amete Alem (epoch approx. 5493 B.C.E) */
+    ETHIOAA = "ethioaa",
+    /** Ethiopic calendar, Amete Mihret (epoch approx, 8 C.E.) */
+    ETHIOPIC = "ethiopic",
+    /** Gregorian calendar (also referred to upstream as "gregorian" — dropped as a separate
+     * member here since this repo's lint bans duplicate enum values). */
+    GREGORY = "gregory",
+    /** Traditional Hebrew calendar */
+    HEBREW = "hebrew",
+    /** Indian calendar */
+    INDIAN = "indian",
+    /** Islamic calendar */
+    ISLAMIC = "islamic",
+    /** Islamic calendar, tabular (intercalary years [2,5,7,10,13,16,18,21,24,26,29] - civil epoch) */
+    ISLAMIC_CIVIL = "islamic-civil",
+    /** Islamic calendar, Saudi Arabia sighting */
+    ISLAMIC_RGSA = "islamic-rgsa",
+    /**Islamic calendar, tabular (intercalary years [2,5,7,10,13,16,18,21,24,26,29] - astronomical epoch) */
+    ISLAMIC_TBLA = "islamic-tbla",
+    /** Islamic calendar, Umm al-Qura */
+    ISLAMIC_UMALQURA = "islamic-umalqura",
+    /** ISO calendar (Gregorian calendar using the ISO 8601 calendar week rules) */
+    ISO8601 = "iso8601",
+    /** Japanese imperial calendar */
+    JAPANESE = "japanese",
+    /** Persian calendar */
+    PERSIAN = "persian",
+    /** Civil (algorithmic) Arabic calendar */
+    ROC = "roc"
+}
+export type Calendar = {
+    /**
+     * The calendar identifier, one of [Unicode calendar types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendar).
+     *
+     * On Android is limited to one of device's [available calendar types](https://developer.android.com/reference/java/util/Calendar#getAvailableCalendarTypes()).
+     *
+     * On iOS uses [calendar identifiers](https://developer.apple.com/documentation/foundation/calendar/identifier), but maps them to the corresponding Unicode types, will also never contain `'dangi'` or `'islamic-rgsa'` due to it not being implemented on iOS.
+     */
+    calendar: CalendarIdentifier | null;
+    /**
+     * True when current device settings use 24-hour time format.
+     * Can be null on some browsers that don't support the [hourCycle](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycle) property in [Intl](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl) API.
+     */
+    uses24hourClock: boolean | null;
+    /**
+     * The first day of the week. For most calendars Sunday is numbered `1`, with Saturday being number `7`.
+     * Can be null on some browsers that don't support the [weekInfo](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/weekInfo) property in [Intl](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl) API.
+     * @example
+     * `1`, `7`.
+     */
+    firstWeekday: Weekday | null;
+    /**
+     * Time zone for the calendar. Can be `null` on Web.
+     * @example
+     * `'America/Los_Angeles'`, `'Europe/Warsaw'`, `'GMT+1'`.
+     */
+    timeZone: string | null;
+};