@symbiote-native/cellular 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,232 @@
+# @symbiote-native/cellular
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-cellular`](https://docs.expo.dev/versions/latest/sdk/cellular/) — cellular connection
+generation, carrier/SIM info, and VoIP-support detection — reachable from **every** adapter,
+React, Vue, and Angular, not just React. Like [`@symbiote-native/sensors`](../sensors) and
+unlike this repo's plain-RN-module/view wrappers ([`@symbiote-native/slider`](../slider),
+[`@symbiote-native/splash-screen`](../splash-screen)), `expo-cellular` is built on
+`expo-modules-core`, so its native code autolinks straight out of `node_modules` via
+`expo-modules-autolinking` — no proxy `react-native.config.cjs`/podspec to ship. `expo-cellular`'s
+own JS is never imported (it hard-imports the full `expo` meta-package, which this project never
+depends on) — every function is hand-ported into this package's own `core/`.
+
+## Install
+
+```bash
+npm install @symbiote-native/cellular
+```
+
+Depends on `expo-cellular` 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-cellular` yourself, and never add the `expo` meta-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-cellular`'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 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) |
+| Android | `AndroidManifest.xml` — the `READ_PHONE_STATE` permission, needed to read carrier/SIM info |
+
+Full mechanics — the Podfile pieces that normally ship inside the `expo` package, the `expo`
+peer-dependency exclusion list, per-module permission strings — live in the
+`symbiote-expo-native-module` project skill. This wiring is already done for all four
+`examples/expo-*` canary apps (React, Vue SFC, Vue TSX, Angular).
+
+## Shape
+
+```
+src/core/              cellular.ts (the free functions) + types.ts (CellularGeneration enum) +
+                        native-module.ts, which resolves the native module by name through
+                        expo-modules-core's requireNativeModule.
+src/react/hooks/        @symbiote-native/cellular/react   — usePermissions
+src/vue/composables/    @symbiote-native/cellular/vue     — usePermissions
+src/angular/services/   @symbiote-native/cellular/angular — PermissionsService
+```
+
+Each adapter's `usePermissions` hook/composable/service is a thin lifecycle wrapper (fetch on
+mount, expose `request`/`get` to re-check imperatively) over the same `core` functions — the
+permission-fetch logic is written once and shared by all three.
+
+## Use it
+
+```tsx
+// React
+import { useEffect, useState } from 'react';
+import { CellularGeneration, getCarrierNameAsync, getCellularGenerationAsync } from '@symbiote-native/cellular';
+import { usePermissions } from '@symbiote-native/cellular/react';
+
+function CellularScreen() {
+  const [generation, setGeneration] = useState<CellularGeneration | null>(null);
+  const [carrierName, setCarrierName] = useState<string | null>(null);
+  const [status, requestPermission] = usePermissions();
+
+  useEffect(() => {
+    Promise.all([getCellularGenerationAsync(), getCarrierNameAsync()]).then(([gen, carrier]) => {
+      setGeneration(gen);
+      setCarrierName(carrier);
+    });
+  }, []);
+
+  return (
+    <>
+      <Text>{generation === null ? 'checking…' : CellularGeneration[generation]}</Text>
+      <Text>{carrierName ?? 'checking…'}</Text>
+      <Text>{status === null ? 'checking…' : status.status}</Text>
+      <Button title="Request permission" onPress={() => requestPermission()} />
+    </>
+  );
+}
+```
+
+```vue
+<!-- Vue -->
+<script setup lang="ts">
+import { onMounted, ref } from 'vue';
+import { CellularGeneration, getCarrierNameAsync, getCellularGenerationAsync } from '@symbiote-native/cellular';
+import { usePermissions } from '@symbiote-native/cellular/vue';
+
+const generation = ref<CellularGeneration | null>(null);
+const carrierName = ref<string | null>(null);
+const { status, request: requestPermission } = usePermissions();
+
+onMounted(() => {
+  Promise.all([getCellularGenerationAsync(), getCarrierNameAsync()]).then(([gen, carrier]) => {
+    generation.value = gen;
+    carrierName.value = carrier;
+  });
+});
+</script>
+<template>
+  <Text>{{ generation === null ? 'checking…' : CellularGeneration[generation] }}</Text>
+  <Text>{{ carrierName ?? 'checking…' }}</Text>
+  <Text>{{ status === null ? 'checking…' : status.status }}</Text>
+  <Button title="Request permission" :onPress="() => requestPermission()" />
+</template>
+```
+
+```ts
+// Angular
+import { Component, inject, signal } from '@angular/core';
+import { CellularGeneration, PermissionsService, getCarrierNameAsync, getCellularGenerationAsync } from '@symbiote-native/cellular/angular';
+
+@Component({
+  selector: 'CellularScreen',
+  template: `
+    <Text>{{ generation() === null ? 'checking…' : CellularGeneration[generation()!] }}</Text>
+    <Text>{{ carrierName() ?? 'checking…' }}</Text>
+    <Text>{{ permissionStatus()?.status ?? 'checking…' }}</Text>
+    <Button title="Request permission" (press)="permissionsService.request()"></Button>
+  `,
+})
+export class CellularScreen {
+  readonly CellularGeneration = CellularGeneration;
+  private readonly permissionsService = inject(PermissionsService);
+  readonly permissionStatus = this.permissionsService.connect();
+
+  readonly generation = signal<CellularGeneration | null>(null);
+  readonly carrierName = signal<string | null>(null);
+
+  constructor() {
+    Promise.all([getCellularGenerationAsync(), getCarrierNameAsync()]).then(([generation, carrier]) => {
+      this.generation.set(generation);
+      this.carrierName.set(carrier);
+    });
+  }
+}
+```
+
+Trimmed from the real demo screens — `examples/expo-react/screens/CellularScreen.tsx` and its
+Vue SFC, Vue TSX, and Angular twins (`examples/expo-vue-sfc/screens/CellularScreen.vue`,
+`examples/expo-vue-tsx/screens/CellularScreen.tsx`, `examples/expo-angular/src/screens/CellularScreen.ts`),
+which also cover `allowsVoipAsync`/`getIsoCountryCodeAsync`/`getMobileCountryCodeAsync`/
+`getMobileNetworkCodeAsync` and gate the Android-only fields behind `Platform.OS === 'android'`.
+
+## API
+
+Mostly stateless async functions, no event stream — plus one stateful pair,
+`getPermissionsAsync`/`requestPermissionsAsync`, which gets its own lifecycle
+hook/composable/service (`usePermissions`) so a component can re-check permission status
+imperatively without re-wiring the fetch itself.
+
+Carrier/SIM info and VoIP support are **Android only** — every one of those functions resolves
+`null` on iOS without touching the native module at all, since iOS doesn't expose this
+information. `getPermissionsAsync`/`requestPermissionsAsync` need no real permission grant on
+iOS either (cellular info requires none there), so they resolve a plain `GRANTED` response
+without a native call.
+
+```ts
+getCellularGenerationAsync(): Promise<CellularGeneration>
+// UNKNOWN/CELLULAR_2G/CELLULAR_3G/CELLULAR_4G/CELLULAR_5G. Delegates to the native module on
+// every platform — no iOS gate, unlike every other function below.
+
+allowsVoipAsync(): Promise<boolean | null>
+// @deprecated (upstream is deprecating this). null on iOS, native call on Android.
+
+getIsoCountryCodeAsync(): Promise<string | null>       // Android only — null on iOS.
+getCarrierNameAsync(): Promise<string | null>           // Android only — null on iOS.
+getMobileCountryCodeAsync(): Promise<string | null>     // Android only — null on iOS.
+getMobileNetworkCodeAsync(): Promise<string | null>     // Android only — null on iOS.
+
+getPermissionsAsync(): Promise<PermissionResponse>
+// Android delegates to the native module; every other platform resolves a plain GRANTED
+// literal — no permission is needed there for cellular info.
+
+requestPermissionsAsync(): Promise<PermissionResponse>
+// Same split as getPermissionsAsync.
+```
+
+Plus `CellularGeneration` (enum) and `PermissionResponse`/`PermissionStatus`/
+`PermissionExpiration` — the latter three re-exported straight from `expo-modules-core`, not
+ported by hand.
+
+```ts
+import { getCellularGenerationAsync, getCarrierNameAsync } from '@symbiote-native/cellular';
+
+// framework-scoped entry points re-export the same free functions, plus usePermissions:
+import { usePermissions } from '@symbiote-native/cellular/react';
+import { usePermissions } from '@symbiote-native/cellular/vue';
+import { PermissionsService } from '@symbiote-native/cellular/angular';
+```
+
+### `usePermissions`
+
+Fetches the current permission status on mount, then exposes `request`/`get` to re-check it
+imperatively — every adapter follows the same shape as its sibling `PermissionsService`/
+composable in `@symbiote-native/brightness`, the other package in this repo needing the same
+get/request permission pair.
+
+```tsx
+// React — a [status, request, get] tuple, mirroring upstream's own usePermissions hooks
+const [status, requestPermission, getPermission] = usePermissions();
+```
+
+```ts
+// Vue — a { status, request, get } object; status is a Ref
+const { status, request, get } = usePermissions();
+```
+
+```ts
+// Angular — connect() returns a readonly Signal; request()/get() live on the service itself
+readonly status = inject(PermissionsService).connect();
+// later: inject(PermissionsService).request()
+```
+
+## Test it
+
+No Fabric/Descriptor angle at all — cellular info is a pure async-function + permission surface,
+never a view. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution (`src/core/cellular.test.ts`,
+`src/{react,vue,angular}/**/*.test.{ts,tsx}`, run via `vitest`) — no `installFabric()`, no
+ViewConfig. Native rendering itself is verified on-device (see the parent
+[README](../../README.md)).

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { PermissionsService } from './services/permissions.service';
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/cellular/angular: the Angular entry over the framework-agnostic core, plus
+// PermissionsService — the only stateful surface this package needs a lifecycle wrapper for.
+export { PermissionsService } from './services/permissions.service/index.js';
+export * from '../core/index.js';

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

@@ -0,0 +1,8 @@
+import { type Signal } from '@angular/core';
+import { type PermissionResponse } from '../../../core';
+export declare class PermissionsService {
+    private readonly status;
+    connect(): Signal<PermissionResponse | null>;
+    get(): Promise<PermissionResponse>;
+    request(): Promise<PermissionResponse>;
+}

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

@@ -0,0 +1,76 @@
+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;
+};
+// Angular twin of React's `usePermissions` hook and Vue's `usePermissions` composable —
+// see BatteryStateService's connect() pattern for the shape rationale.
+//
+//   readonly status = inject(PermissionsService).connect();
+//   // template: {{ status()?.granted }}
+import { Injectable, signal } from '@angular/core';
+import { getPermissionsAsync, requestPermissionsAsync, } from '../../../core';
+let PermissionsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var PermissionsService = 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);
+            PermissionsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        status = signal(null);
+        connect() {
+            if (this.status() === null) {
+                void this.get();
+            }
+            return this.status.asReadonly();
+        }
+        async get() {
+            const response = await getPermissionsAsync();
+            this.status.set(response);
+            return response;
+        }
+        async request() {
+            const response = await requestPermissionsAsync();
+            this.status.set(response);
+            return response;
+        }
+    };
+    return PermissionsService = _classThis;
+})();
+export { PermissionsService };

package/build/core/cellular.d.ts

@@ -0,0 +1,40 @@
+import { type PermissionResponse } from 'expo-modules-core';
+import { CellularGeneration } from './types';
+/** Gets the generation of the device's current connection. */
+export declare function getCellularGenerationAsync(): Promise<CellularGeneration>;
+/**
+ * Tells if the carrier of the SIM card allows to make VoIP calls on its network.
+ * @deprecated This method is deprecated and will be removed in a future SDK version.
+ * @platform android
+ */
+export declare function allowsVoipAsync(): Promise<boolean | null>;
+/**
+ * Gets the ISO country code of the current registered operator's MCC (Mobile Country Code).
+ * @platform android
+ */
+export declare function getIsoCountryCodeAsync(): Promise<string | null>;
+/**
+ * Gets the name of the user's cellular service provider.
+ * @platform android
+ */
+export declare function getCarrierNameAsync(): Promise<string | null>;
+/**
+ * Gets the mobile country code (MCC) of the device's current registered operator.
+ * @platform android
+ */
+export declare function getMobileCountryCodeAsync(): Promise<string | null>;
+/**
+ * Gets the mobile network code (MNC) of the device's current registered operator.
+ * @platform android
+ */
+export declare function getMobileNetworkCodeAsync(): Promise<string | null>;
+/**
+ * Checks user's permissions for accessing cellular information. Android only — iOS/web need no
+ * permission for cellular info, so this always resolves granted there.
+ */
+export declare function getPermissionsAsync(): Promise<PermissionResponse>;
+/**
+ * Asks the user to grant permissions for accessing cellular information. Android only — iOS/web
+ * need no permission for cellular info, so this always resolves granted there.
+ */
+export declare function requestPermissionsAsync(): Promise<PermissionResponse>;

package/build/core/cellular.js

@@ -0,0 +1,116 @@
+// Hand-ported from .vendors/expo/packages/expo-cellular/src/Cellular.ts (sdk-57). Carrier/SIM
+// info (ISO country code, carrier name, MCC/MNC) and allowsVoipAsync are Android-only upstream —
+// each short-circuits to `null` on iOS before ever reaching the native module, since iOS exposes
+// none of this. getPermissionsAsync/requestPermissionsAsync mirror that same split: Android
+// delegates to the native module, every other platform needs no permission for cellular info at
+// all and resolves a plain GRANTED literal. Upstream's web branch (navigator.connection) is out
+// of scope — this repo has no web target for this package's native-module resolution path.
+import { Platform, PermissionStatus, UnavailabilityError, } from 'expo-modules-core';
+import { expoCellular } from './native-module';
+import { CellularGeneration } from './types';
+const NATIVE_MODULE_NAME = 'expo-cellular';
+const GRANTED_PERMISSION_RESPONSE = {
+    status: PermissionStatus.GRANTED,
+    expires: 'never',
+    granted: true,
+    canAskAgain: true,
+};
+/** Gets the generation of the device's current connection. */
+export async function getCellularGenerationAsync() {
+    if (!expoCellular.getCellularGenerationAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getCellularGenerationAsync');
+    }
+    return expoCellular.getCellularGenerationAsync();
+}
+/**
+ * Tells if the carrier of the SIM card allows to make VoIP calls on its network.
+ * @deprecated This method is deprecated and will be removed in a future SDK version.
+ * @platform android
+ */
+export async function allowsVoipAsync() {
+    if (Platform.OS === 'ios') {
+        return null;
+    }
+    if (!expoCellular.allowsVoipAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'allowsVoipAsync');
+    }
+    return expoCellular.allowsVoipAsync();
+}
+/**
+ * Gets the ISO country code of the current registered operator's MCC (Mobile Country Code).
+ * @platform android
+ */
+export async function getIsoCountryCodeAsync() {
+    if (Platform.OS === 'ios') {
+        return null;
+    }
+    if (!expoCellular.getIsoCountryCodeAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getIsoCountryCodeAsync');
+    }
+    return expoCellular.getIsoCountryCodeAsync();
+}
+/**
+ * Gets the name of the user's cellular service provider.
+ * @platform android
+ */
+export async function getCarrierNameAsync() {
+    if (Platform.OS === 'ios') {
+        return null;
+    }
+    if (!expoCellular.getCarrierNameAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getCarrierNameAsync');
+    }
+    return expoCellular.getCarrierNameAsync();
+}
+/**
+ * Gets the mobile country code (MCC) of the device's current registered operator.
+ * @platform android
+ */
+export async function getMobileCountryCodeAsync() {
+    if (Platform.OS === 'ios') {
+        return null;
+    }
+    if (!expoCellular.getMobileCountryCodeAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getMobileCountryCodeAsync');
+    }
+    return expoCellular.getMobileCountryCodeAsync();
+}
+/**
+ * Gets the mobile network code (MNC) of the device's current registered operator.
+ * @platform android
+ */
+export async function getMobileNetworkCodeAsync() {
+    if (Platform.OS === 'ios') {
+        return null;
+    }
+    if (!expoCellular.getMobileNetworkCodeAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getMobileNetworkCodeAsync');
+    }
+    return expoCellular.getMobileNetworkCodeAsync();
+}
+/**
+ * Checks user's permissions for accessing cellular information. Android only — iOS/web need no
+ * permission for cellular info, so this always resolves granted there.
+ */
+export async function getPermissionsAsync() {
+    if (Platform.OS === 'android') {
+        if (!expoCellular.getPermissionsAsync) {
+            throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getPermissionsAsync');
+        }
+        return expoCellular.getPermissionsAsync();
+    }
+    return GRANTED_PERMISSION_RESPONSE;
+}
+/**
+ * Asks the user to grant permissions for accessing cellular information. Android only — iOS/web
+ * need no permission for cellular info, so this always resolves granted there.
+ */
+export async function requestPermissionsAsync() {
+    if (Platform.OS === 'android') {
+        if (!expoCellular.requestPermissionsAsync) {
+            throw new UnavailabilityError(NATIVE_MODULE_NAME, 'requestPermissionsAsync');
+        }
+        return expoCellular.requestPermissionsAsync();
+    }
+    return GRANTED_PERMISSION_RESPONSE;
+}

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export { getCellularGenerationAsync, allowsVoipAsync, getIsoCountryCodeAsync, getCarrierNameAsync, getMobileCountryCodeAsync, getMobileNetworkCodeAsync, getPermissionsAsync, requestPermissionsAsync, } from './cellular';
+export { CellularGeneration, PermissionStatus, type PermissionResponse, type PermissionExpiration, } from './types';

package/build/core/index.js

@@ -0,0 +1,2 @@
+export { getCellularGenerationAsync, allowsVoipAsync, getIsoCountryCodeAsync, getCarrierNameAsync, getMobileCountryCodeAsync, getMobileNetworkCodeAsync, getPermissionsAsync, requestPermissionsAsync, } from './cellular.js';
+export { CellularGeneration, PermissionStatus, } from './types.js';

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

@@ -0,0 +1,13 @@
+import type { PermissionResponse } from 'expo-modules-core';
+import type { CellularGeneration } from './types';
+export type INativeCellularModule = {
+    getCellularGenerationAsync?(): Promise<CellularGeneration>;
+    allowsVoipAsync?(): Promise<boolean>;
+    getIsoCountryCodeAsync?(): Promise<string | null>;
+    getCarrierNameAsync?(): Promise<string | null>;
+    getMobileCountryCodeAsync?(): Promise<string | null>;
+    getMobileNetworkCodeAsync?(): Promise<string | null>;
+    getPermissionsAsync?(): Promise<PermissionResponse>;
+    requestPermissionsAsync?(): Promise<PermissionResponse>;
+};
+export declare const expoCellular: INativeCellularModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_CELLULAR_MODULE_NAME = 'ExpoCellular';
+export const expoCellular = requireNativeModule(EXPO_CELLULAR_MODULE_NAME);

package/build/core/types.d.ts

@@ -0,0 +1,14 @@
+export { PermissionStatus, type PermissionResponse, type PermissionExpiration, } from 'expo-modules-core';
+/** Telecommunication technology used to establish a cellular connection. */
+export declare enum CellularGeneration {
+    /** The device's connection generation could not be determined. */
+    UNKNOWN = 0,
+    /** 2nd generation (GPRS/EDGE-class) connection. */
+    CELLULAR_2G = 1,
+    /** 3rd generation (UMTS/HSPA-class) connection. */
+    CELLULAR_3G = 2,
+    /** 4th generation (LTE-class) connection. */
+    CELLULAR_4G = 3,
+    /** 5th generation (NR-class) connection. */
+    CELLULAR_5G = 4
+}

package/build/core/types.js

@@ -0,0 +1,19 @@
+// Hand-ported from .vendors/expo/packages/expo-cellular/src/Cellular.types.ts (sdk-57).
+// PermissionResponse/PermissionStatus/PermissionExpiration come straight from
+// expo-modules-core (which re-exports PermissionsInterface) — never from the `expo`
+// meta-package, unlike upstream's own Cellular.ts.
+export { PermissionStatus, } from 'expo-modules-core';
+/** Telecommunication technology used to establish a cellular connection. */
+export var CellularGeneration;
+(function (CellularGeneration) {
+    /** The device's connection generation could not be determined. */
+    CellularGeneration[CellularGeneration["UNKNOWN"] = 0] = "UNKNOWN";
+    /** 2nd generation (GPRS/EDGE-class) connection. */
+    CellularGeneration[CellularGeneration["CELLULAR_2G"] = 1] = "CELLULAR_2G";
+    /** 3rd generation (UMTS/HSPA-class) connection. */
+    CellularGeneration[CellularGeneration["CELLULAR_3G"] = 2] = "CELLULAR_3G";
+    /** 4th generation (LTE-class) connection. */
+    CellularGeneration[CellularGeneration["CELLULAR_4G"] = 3] = "CELLULAR_4G";
+    /** 5th generation (NR-class) connection. */
+    CellularGeneration[CellularGeneration["CELLULAR_5G"] = 4] = "CELLULAR_5G";
+})(CellularGeneration || (CellularGeneration = {}));

package/build/react/hooks/use-permissions/index.d.ts

@@ -0,0 +1,6 @@
+import { type PermissionResponse } from '../../../core';
+export declare function usePermissions(): [
+    PermissionResponse | null,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];

package/build/react/hooks/use-permissions/index.js

@@ -0,0 +1,28 @@
+// React lifecycle wiring over the framework-agnostic core (core/cellular.ts) — fetches the
+// current permission status on mount, then exposes request/get to re-check imperatively.
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { getPermissionsAsync, requestPermissionsAsync, } from '../../../core';
+export function usePermissions() {
+    const isMounted = useRef(true);
+    const [status, setStatus] = useState(null);
+    const getPermission = useCallback(async () => {
+        const response = await getPermissionsAsync();
+        if (isMounted.current)
+            setStatus(response);
+        return response;
+    }, []);
+    const requestPermission = useCallback(async () => {
+        const response = await requestPermissionsAsync();
+        if (isMounted.current)
+            setStatus(response);
+        return response;
+    }, []);
+    useEffect(() => {
+        isMounted.current = true;
+        void getPermission();
+        return () => {
+            isMounted.current = false;
+        };
+    }, [getPermission]);
+    return [status, requestPermission, getPermission];
+}

package/build/react/index.d.ts

@@ -0,0 +1,2 @@
+export { usePermissions } from './hooks/use-permissions';
+export * from '../core';

package/build/react/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/cellular/react: the React entry over the framework-agnostic core, plus
+// usePermissions — the only stateful surface this package needs a lifecycle wrapper for.
+export { usePermissions } from './hooks/use-permissions/index.js';
+export * from '../core/index.js';

package/build/vue/composables/use-permissions/index.d.ts

@@ -0,0 +1,7 @@
+import { type Ref } from '@vue/runtime-core';
+import { type PermissionResponse } from '../../../core';
+export declare function usePermissions(): {
+    status: Ref<PermissionResponse | null>;
+    request: () => Promise<PermissionResponse>;
+    get: () => Promise<PermissionResponse>;
+};

package/build/vue/composables/use-permissions/index.js

@@ -0,0 +1,21 @@
+// Vue lifecycle wiring over the framework-agnostic core (core/cellular.ts) — fetches the
+// current permission status on mount, then exposes request/get to re-check imperatively.
+import { onMounted, ref } from '@vue/runtime-core';
+import { getPermissionsAsync, requestPermissionsAsync, } from '../../../core';
+export function usePermissions() {
+    const status = ref(null);
+    const get = async () => {
+        const response = await getPermissionsAsync();
+        status.value = response;
+        return response;
+    };
+    const request = async () => {
+        const response = await requestPermissionsAsync();
+        status.value = response;
+        return response;
+    };
+    onMounted(() => {
+        void get();
+    });
+    return { status, request, get };
+}

package/build/vue/index.d.ts

@@ -0,0 +1,2 @@
+export { usePermissions } from './composables/use-permissions';
+export * from '../core';