react-native-local-network-info 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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,158 @@
+# react-native-local-network-info
+
+Read a React Native device's **own local IPv4 address** and whether it's **connected to WiFi** or **acting as a hotspot host** — with **live network-change events**.
+
+> ℹ️ This library only reads **your own device's** network interfaces. It does **not** scan, probe, or connect to any other device on the network, and it needs no location permission.
+
+Built with the [Expo Modules API](https://docs.expo.dev/modules/overview/), so it works in **both bare React Native and Expo** apps and supports the New Architecture out of the box.
+
+## Why
+
+`expo-network` / `WifiManager.getConnectionInfo()` only return the **WiFi station** IP — they report `0.0.0.0` when the device is the hotspot host. This module reads the device's network interfaces directly, so it returns a usable LAN IP whether the device is a WiFi client **or** the hotspot, and tells you which.
+
+## Features
+
+- ✅ Device's own **local IPv4** on the active LAN interface.
+- ✅ **Role**: `wifi`, `hotspot`, or `none`.
+- ✅ **WiFi takes precedence** when both WiFi and hotspot are active at once.
+- ✅ **Hotspot host** detection that handles Android 11+'s **randomized** SoftAP subnet (reads the real interface IP — never hardcodes `192.168.43.1`).
+- ✅ **Predicted client IP range** when the device is a hotspot (iOS: fixed `172.20.10.2–.14`; Android: derived from the live subnet).
+- ✅ **Live listener** that re-fires on every connectivity / WiFi / hotspot change.
+- ✅ A `useLocalIp()` React hook.
+- ✅ No location permission required.
+
+## Installation
+
+```sh
+npm install react-native-local-network-info
+```
+
+> **Bare React Native:** you must also have the `expo` package installed so Expo Modules autolinking works. If you don't yet:
+> ```sh
+> npx install-expo-modules@latest
+> ```
+> Then `cd ios && pod install`. Expo apps need no extra steps.
+
+### Requirements
+
+| | Minimum |
+| --- | --- |
+| Expo SDK | 54+ (New Architecture) |
+| iOS | 15.1 |
+| Android | API 24 (Android 7.0) |
+
+### Permissions
+
+Android permissions are merged automatically via the module's manifest:
+
+- `ACCESS_NETWORK_STATE` — for the change listener & station gateway.
+- `ACCESS_WIFI_STATE` — for the DHCP gateway fallback.
+
+No `ACCESS_FINE_LOCATION` and no iOS `Info.plist` keys are needed — the module only reads its **own** interfaces (it never connects to or scans other devices).
+
+## Usage
+
+```ts
+import {
+  getLocalIp,
+  addNetworkChangeListener,
+  useLocalIp,
+} from 'react-native-local-network-info';
+
+// One-shot read
+const info = await getLocalIp();
+console.log(info.ip, info.role); // e.g. "192.168.1.42" "wifi"
+
+// Live updates
+const sub = addNetworkChangeListener((info) => {
+  console.log('network changed →', info.role, info.ip);
+});
+// later: sub.remove();
+```
+
+### React hook
+
+```tsx
+import { useLocalIp } from 'react-native-local-network-info';
+
+function Status() {
+  const info = useLocalIp(); // null until first snapshot, then live
+  if (!info) return <Text>Detecting…</Text>;
+  return (
+    <Text>
+      {info.role === 'hotspot' ? 'Hosting hotspot at' : 'Local IP'}: {info.ip}
+    </Text>
+  );
+}
+```
+
+## API
+
+### `getLocalIp(): Promise<LocalIpInfo>`
+
+Captures the current snapshot.
+
+### `addNetworkChangeListener(cb): EventSubscription`
+
+Subscribes to changes. Call `.remove()` on the returned subscription to unsubscribe.
+
+### `getAllInterfaces(): Promise<NetworkInterfaceInfo[]>`
+
+Every up, non-loopback IPv4 interface with a best-effort role — handy for debugging unusual devices.
+
+### `useLocalIp(): LocalIpInfo | null`
+
+Hook returning the latest snapshot, kept live and auto-cleaned on unmount.
+
+### `LocalIpInfo`
+
+```ts
+interface LocalIpInfo {
+  ip: string | null;                 // device's own local IPv4 (wifi first, then hotspot)
+  role: 'wifi' | 'hotspot' | 'none'; // wifi wins when both are active
+  isWifiConnected: boolean;
+  isHotspotHost: boolean;
+  interfaceName: string | null;      // "en0" | "wlan0" | "bridge100" | "ap0" | ...
+  netmask: string | null;            // "255.255.255.0"
+  gateway: string | null;            // see notes below
+  predictedClientRange: { first: string; last: string } | null; // hotspot only
+  platform: 'ios' | 'android' | 'web';
+  timestamp: number;                 // epoch ms
+}
+```
+
+## How detection works
+
+| | iOS | Android |
+| --- | --- | --- |
+| Enumeration | `getifaddrs(3)` | `java.net.NetworkInterface` |
+| WiFi station | `en0` | the interface `ConnectivityManager` reports for the `TRANSPORT_WIFI` network (usually `wlan0`) |
+| Hotspot host | `bridge*` @ `172.20.10.1/28` | any WiFi-family interface (`wlan*`/`ap*`/`swlan*`/`softap*`) that is **not** the confirmed station — reads its live IP |
+| Cellular (ignored for LAN IP) | `pdp_ip0` | `rmnet*` / `ccmni*` |
+| Change events | `NWPathMonitor` | `registerDefaultNetworkCallback` + `WIFI_AP_STATE_CHANGED` |
+| Station gateway | derived from subnet (heuristic) | `LinkProperties` default route (real) |
+
+**Precedence:** if a WiFi-station IP exists it is returned with `role: 'wifi'`; otherwise the hotspot-host IP is returned with `role: 'hotspot'`; otherwise `role: 'none'` with `ip: null`.
+
+## Platform notes & limitations
+
+- **iOS station gateway is a heuristic** (first host of the subnet). Apple exposes no public default-gateway API; the WiFi IP, netmask, and role are accurate.
+- **iOS hotspot change events:** `NWPathMonitor` reliably reports WiFi/cellular changes, but toggling Personal Hotspot while the default path is unchanged may not fire an event. Call `getLocalIp()` to force a fresh read when you need certainty.
+- **Android hotspot vs. station** is resolved by asking `ConnectivityManager` which interface carries the real `TRANSPORT_WIFI` (station) network, then treating any *other* WiFi-family interface with an IP as the hotspot. This correctly handles phones that host the SoftAP on `wlan0` itself (not just `ap0`/`swlan0`), and devices running WiFi + hotspot concurrently. Use `getAllInterfaces()` to inspect an unusual device.
+- **Web** returns `role: 'none'` / `ip: null` — browsers don't expose the LAN IP.
+- iOS interface-name → role mapping is a documented **heuristic** (Apple exposes no public role API); the hotspot-host `172.20.10.1`/`255.255.255.240` fingerprint and `NetworkInterface` reads are the reliable signals.
+
+## Example app
+
+```sh
+cd example
+npm install
+npx expo prebuild        # generates ios/ and android/
+npx expo run:ios         # or: npx expo run:android
+```
+
+Then toggle WiFi / your hotspot in Settings and watch the values update live.
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,20 @@
+plugins {
+  id 'com.android.library'
+  id 'expo-module-gradle-plugin'
+}
+
+group = 'com.localnetworkinfo'
+version = '0.1.0'
+
+// compileSdk (36), minSdk (24), targetSdk (36), Kotlin (2.0.21) and the
+// JVM toolchain (17) are supplied by the `expo-module-gradle-plugin`.
+android {
+  namespace 'com.localnetworkinfo'
+  defaultConfig {
+    versionCode 1
+    versionName '0.1.0'
+  }
+  lintOptions {
+    abortOnError false
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <!-- Required for ConnectivityManager (network callbacks, LinkProperties). -->
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <!-- Required for WifiManager (DHCP gateway fallback). -->
+  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+  <!-- NOTE: ACCESS_FINE_LOCATION is intentionally NOT requested: IP/role/gateway
+       detection does not need it (only WiFi scanning / reading SSID would). -->
+</manifest>

package/android/src/main/java/com/localnetworkinfo/LocalNetworkInfoModule.kt

@@ -0,0 +1,371 @@
+package com.localnetworkinfo
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.net.ConnectivityManager
+import android.net.LinkProperties
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.os.Build
+import android.os.Handler
+import android.os.HandlerThread
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.net.Inet4Address
+import java.net.NetworkInterface
+
+class LocalNetworkInfoModule : Module() {
+
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+  private val connectivityManager: ConnectivityManager
+    get() = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+  private var networkCallback: ConnectivityManager.NetworkCallback? = null
+  private var apStateReceiver: BroadcastReceiver? = null
+  private var handlerThread: HandlerThread? = null
+  private var handler: Handler? = null
+  private val resampleRunnable = Runnable { doEmit() }
+
+  override fun definition() = ModuleDefinition {
+    Name("LocalNetworkInfo")
+
+    Events("onNetworkChange")
+
+    AsyncFunction("getLocalIpAsync") {
+      return@AsyncFunction buildInfo()
+    }
+
+    AsyncFunction("getAllInterfacesAsync") {
+      return@AsyncFunction enumerateInterfaces().map { it.toMap() }
+    }
+
+    OnStartObserving {
+      startMonitoring()
+    }
+
+    OnStopObserving {
+      stopMonitoring()
+    }
+
+    OnDestroy {
+      stopMonitoring()
+    }
+  }
+
+  // region Network change monitoring
+
+  private fun startMonitoring() {
+    if (handlerThread == null) {
+      val thread = HandlerThread("expo.localnetworkinfo.emit").apply { start() }
+      handler = Handler(thread.looper)
+      handlerThread = thread
+    }
+
+    if (networkCallback == null) {
+      val callback = object : ConnectivityManager.NetworkCallback() {
+        override fun onAvailable(network: Network) = emitChange()
+        override fun onLost(network: Network) = emitChange()
+        override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) = emitChange()
+        override fun onLinkPropertiesChanged(network: Network, lp: LinkProperties) = emitChange()
+      }
+      try {
+        // registerDefaultNetworkCallback is API 24+ (our minSdk is 24).
+        connectivityManager.registerDefaultNetworkCallback(callback)
+        networkCallback = callback
+      } catch (_: Exception) {
+        // Leave networkCallback null; the AP receiver below may still work.
+      }
+    }
+
+    if (apStateReceiver == null) {
+      val receiver = object : BroadcastReceiver() {
+        override fun onReceive(receivedContext: Context?, intent: Intent?) = emitChange()
+      }
+      try {
+        // Fired by the system whenever the WiFi hotspot is enabled/disabled.
+        // NetworkCallback does NOT cover the device's own SoftAP, so we need this.
+        val filter = IntentFilter("android.net.wifi.WIFI_AP_STATE_CHANGED")
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+          context.applicationContext.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)
+        } else {
+          @Suppress("UnspecifiedRegisterReceiverFlag")
+          context.applicationContext.registerReceiver(receiver, filter)
+        }
+        apStateReceiver = receiver
+      } catch (_: Exception) {
+        // Hotspot-toggle events will be missed, but everything else still works.
+      }
+    }
+  }
+
+  private fun stopMonitoring() {
+    handler?.removeCallbacks(resampleRunnable)
+    handlerThread?.quitSafely()
+    handlerThread = null
+    handler = null
+
+    networkCallback?.let {
+      try {
+        connectivityManager.unregisterNetworkCallback(it)
+      } catch (_: Exception) {
+      }
+    }
+    networkCallback = null
+
+    apStateReceiver?.let {
+      try {
+        context.applicationContext.unregisterReceiver(it)
+      } catch (_: Exception) {
+      }
+    }
+    apStateReceiver = null
+  }
+
+  private fun doEmit() {
+    try {
+      sendEvent("onNetworkChange", buildInfo())
+    } catch (_: Exception) {
+    }
+  }
+
+  private fun emitChange() {
+    // Emit an immediate snapshot, then re-sample over the next few seconds. On
+    // Android the hotspot/station interface frequently receives its IPv4 a beat
+    // AFTER the change event fires, and no further event follows — so a single
+    // immediate snapshot can report "no connection" until the next manual
+    // refresh. The trailing re-samples catch the late address assignment.
+    doEmit()
+    handler?.let { h ->
+      h.removeCallbacks(resampleRunnable)
+      h.postDelayed(resampleRunnable, 700)
+      h.postDelayed(resampleRunnable, 1800)
+      h.postDelayed(resampleRunnable, 3500)
+    }
+  }
+
+  // endregion
+
+  // region Interface model
+
+  private enum class Role(val value: String) {
+    WIFI("wifi"),
+    HOTSPOT("hotspot"),
+    CELLULAR("cellular"),
+    ETHERNET("ethernet"),
+    OTHER("other")
+  }
+
+  private data class Iface(
+    val name: String,
+    val ip: String,
+    val netmask: String?,
+    val prefixLength: Int,
+    val role: Role
+  ) {
+    fun toMap(): Map<String, Any?> = mapOf(
+      "name" to name,
+      "ip" to ip,
+      "netmask" to netmask,
+      "role" to role.value
+    )
+  }
+
+  /**
+   * Classify an interface, using ConnectivityManager to confirm which interface
+   * actually carries a WiFi *station* network. This is what lets us tell a
+   * hotspot apart from a station even when the device hosts its SoftAP on
+   * `wlan0` itself (common on single-radio phones) instead of a separate
+   * `ap0` / `wlan1` / `swlan0` / `softap0` interface.
+   */
+  private fun classify(name: String, stationInterfaces: Set<String>): Role = when {
+    // Confirmed by the system to be a real WiFi station (client) connection.
+    name in stationInterfaces -> Role.WIFI
+    name.startsWith("rmnet") || name.startsWith("ccmni") -> Role.CELLULAR
+    name.startsWith("eth") -> Role.ETHERNET
+    // Any WiFi-family interface that is NOT a confirmed station is the hotspot/SoftAP.
+    name.startsWith("wlan") ||
+      name.startsWith("ap") ||
+      name.startsWith("swlan") ||
+      name.startsWith("softap") -> Role.HOTSPOT
+    else -> Role.OTHER
+  }
+
+  /** Interface names ConnectivityManager reports as carrying a WiFi station network. */
+  private fun wifiStationInterfaceNames(): Set<String> {
+    val names = mutableSetOf<String>()
+    try {
+      @Suppress("DEPRECATION")
+      val networks = connectivityManager.allNetworks
+      for (network in networks) {
+        val capabilities = connectivityManager.getNetworkCapabilities(network) ?: continue
+        if (!capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) continue
+        connectivityManager.getLinkProperties(network)?.interfaceName?.let { names.add(it) }
+      }
+    } catch (_: Exception) {
+    }
+    return names
+  }
+
+  // endregion
+
+  // region Detection
+
+  private fun enumerateInterfaces(): List<Iface> {
+    val result = mutableListOf<Iface>()
+    val stationInterfaces = wifiStationInterfaceNames()
+
+    val interfaces = try {
+      NetworkInterface.getNetworkInterfaces() ?: return result
+    } catch (_: Exception) {
+      return result
+    }
+
+    for (nif in interfaces) {
+      try {
+        if (!nif.isUp || nif.isLoopback) continue
+      } catch (_: Exception) {
+        continue
+      }
+
+      // interfaceAddresses gives us the prefix length (for netmask + prediction).
+      for (interfaceAddress in nif.interfaceAddresses) {
+        val address = interfaceAddress.address
+        if (address !is Inet4Address) continue
+        if (address.isLoopbackAddress || address.isLinkLocalAddress) continue
+
+        val ip = address.hostAddress ?: continue
+        val prefix = interfaceAddress.networkPrefixLength.toInt()
+        result.add(Iface(nif.name, ip, prefixToNetmask(prefix), prefix, classify(nif.name, stationInterfaces)))
+      }
+    }
+
+    return result
+  }
+
+  private fun buildInfo(): Map<String, Any?> {
+    val interfaces = enumerateInterfaces()
+
+    val station = interfaces.firstOrNull { it.role == Role.WIFI }
+    val host = interfaces.firstOrNull { it.role == Role.HOTSPOT }
+
+    val isWifiConnected = station != null
+    val isHotspotHost = host != null
+
+    var ip: String? = null
+    var role = "none"
+    var interfaceName: String? = null
+    var netmask: String? = null
+    var gateway: String? = null
+    var predicted: Map<String, String>? = null
+
+    if (station != null) {
+      ip = station.ip
+      role = "wifi"
+      interfaceName = station.name
+      netmask = station.netmask
+      // Prefer the real default-route gateway; fall back to a subnet guess.
+      gateway = stationGateway() ?: deriveGateway(station.ip, station.prefixLength)
+    } else if (host != null) {
+      ip = host.ip
+      role = "hotspot"
+      interfaceName = host.name
+      netmask = host.netmask
+      gateway = host.ip // the hotspot host is its own gateway
+      predicted = predictClientRange(host.ip, host.prefixLength)
+    }
+
+    return mapOf(
+      "ip" to ip,
+      "role" to role,
+      "isWifiConnected" to isWifiConnected,
+      "isHotspotHost" to isHotspotHost,
+      "interfaceName" to interfaceName,
+      "netmask" to netmask,
+      "gateway" to gateway,
+      "predictedClientRange" to predicted,
+      "platform" to "android",
+      "timestamp" to System.currentTimeMillis().toDouble()
+    )
+  }
+
+  /** Real station gateway via LinkProperties (default route), with a DHCP fallback. */
+  private fun stationGateway(): String? {
+    return try {
+      val network = connectivityManager.activeNetwork ?: return null
+      val linkProperties = connectivityManager.getLinkProperties(network) ?: return null
+      // Ignore the 0.0.0.0 wildcard (appears as the "gateway" of a directly-connected
+      // default route, e.g. when the device is tethering rather than a real station).
+      val routeGateway = linkProperties.routes
+        .firstOrNull { it.isDefaultRoute && it.gateway?.isAnyLocalAddress == false }
+        ?.gateway
+        ?.hostAddress
+      if (routeGateway != null) return routeGateway
+      val dhcpServer = if (Build.VERSION.SDK_INT >= 30) linkProperties.dhcpServerAddress else null
+      if (dhcpServer != null && !dhcpServer.isAnyLocalAddress) dhcpServer.hostAddress else null
+    } catch (_: Exception) {
+      null
+    }
+  }
+
+  // endregion
+
+  // region IPv4 math
+
+  private fun prefixToNetmask(prefix: Int): String? {
+    if (prefix < 0 || prefix > 32) return null
+    val mask = if (prefix == 0) 0 else (-1 shl (32 - prefix))
+    return "${(mask ushr 24) and 0xff}.${(mask ushr 16) and 0xff}.${(mask ushr 8) and 0xff}.${mask and 0xff}"
+  }
+
+  private fun ipToInt(ip: String): Int? {
+    val parts = ip.split(".")
+    if (parts.size != 4) return null
+    var value = 0
+    for (part in parts) {
+      val octet = part.toIntOrNull() ?: return null
+      if (octet < 0 || octet > 255) return null
+      value = (value shl 8) or octet
+    }
+    return value
+  }
+
+  private fun intToIp(value: Int): String =
+    "${(value ushr 24) and 0xff}.${(value ushr 16) and 0xff}.${(value ushr 8) and 0xff}.${value and 0xff}"
+
+  /** Subnet-guess gateway (first host) — only used as an Android station fallback. */
+  private fun deriveGateway(ip: String, prefix: Int): String? {
+    val ipInt = ipToInt(ip) ?: return null
+    if (prefix <= 0 || prefix >= 32) return null
+    val mask = -1 shl (32 - prefix)
+    val network = ipInt and mask
+    return intToIp(network + 1)
+  }
+
+  /**
+   * Predict the usable client IPv4 range of a hotspot subnet (network+1 ..
+   * broadcast-1). The host occupies one address within this range unless it is
+   * the first host, in which case the range starts at the next address.
+   */
+  private fun predictClientRange(hostIp: String, prefix: Int): Map<String, String>? {
+    val ipInt = ipToInt(hostIp) ?: return null
+    if (prefix <= 0 || prefix >= 31) return null
+    val mask = -1 shl (32 - prefix)
+    val network = ipInt and mask
+    val broadcast = network or mask.inv()
+
+    var first = network + 1
+    if (first == ipInt) first += 1 // skip the host itself
+    val last = broadcast - 1
+    // Compare as unsigned so high-bit subnets (e.g. 192.168/172.16) order correctly.
+    if (Integer.compareUnsigned(last, first) < 0) return null
+
+    return mapOf("first" to intToIp(first), "last" to intToIp(last))
+  }
+
+  // endregion
+}

package/build/LocalNetworkInfo.types.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Which network role is currently providing the device's local IPv4.
+ *
+ * - `wifi`    — the device is connected to a WiFi network as a station/client.
+ * - `hotspot` — the device is acting as a WiFi hotspot (SoftAP) host.
+ * - `none`    — neither WiFi nor hotspot is providing a usable LAN address
+ *               (e.g. cellular-only, airplane mode, or offline).
+ *
+ * When both WiFi and hotspot are active simultaneously, `wifi` takes precedence.
+ */
+export type NetworkRole = 'wifi' | 'hotspot' | 'none';
+/** The platform that produced a given snapshot. */
+export type DevicePlatform = 'ios' | 'android' | 'web';
+/**
+ * The usable host range of the hotspot subnet — i.e. the addresses a client
+ * could be assigned. This is the whole subnet's usable span (network+1 ..
+ * broadcast-1), so the host/gateway itself is one address *within* this range
+ * (it is not a boundary). When scanning for clients, skip your own `ip`.
+ *
+ * Example: host/gateway `10.121.184.216` on a `/24` → range `10.121.184.1` ..
+ * `10.121.184.254` (a client may legitimately be `.215` *or* `.217`).
+ */
+export interface ClientIpRange {
+    /** First usable client IPv4 in the subnet. */
+    first: string;
+    /** Last usable client IPv4 in the subnet. */
+    last: string;
+}
+/**
+ * A point-in-time snapshot of the device's local network position.
+ *
+ * The same shape is returned by {@link getLocalIp} and delivered to
+ * {@link addNetworkChangeListener} / {@link useLocalIp}.
+ */
+export interface LocalIpInfo {
+    /**
+     * The device's own local IPv4 on the active LAN interface, or `null` when
+     * there is no WiFi/hotspot LAN address. Follows the precedence:
+     * WiFi station IP first, then hotspot host IP.
+     */
+    ip: string | null;
+    /** Which role is providing {@link ip}. WiFi takes precedence over hotspot. */
+    role: NetworkRole;
+    /** `true` when connected to a WiFi network as a client/station. */
+    isWifiConnected: boolean;
+    /** `true` when this device is currently acting as a WiFi hotspot (SoftAP) host. */
+    isHotspotHost: boolean;
+    /**
+     * Name of the network interface backing {@link ip}
+     * (e.g. `en0`, `wlan0`, `bridge100`, `ap0`), or `null`.
+     */
+    interfaceName: string | null;
+    /** Dotted IPv4 subnet mask for {@link ip} (e.g. `255.255.255.0`), or `null`. */
+    netmask: string | null;
+    /**
+     * The LAN gateway.
+     *
+     * - As a **hotspot host**, this is the device itself (it *is* the gateway).
+     * - As an **Android station**, this is the real default-route gateway
+     *   (read from `LinkProperties`).
+     * - As an **iOS station**, this is a best-effort guess derived from the
+     *   subnet (the first host address), because Apple exposes no public gateway
+     *   API. Treat the iOS station gateway as a heuristic.
+     */
+    gateway: string | null;
+    /**
+     * When this device is a hotspot host, the predicted inclusive range of IPs
+     * its clients can receive, derived from the host IP + subnet:
+     *
+     * - **iOS** — the fixed Personal Hotspot range `172.20.10.2`–`172.20.10.14`.
+     * - **Android** — computed from the (randomized on Android 11+) SoftAP subnet.
+     *
+     * `null` when the device is not a hotspot host.
+     */
+    predictedClientRange: ClientIpRange | null;
+    /** Platform that captured this snapshot. */
+    platform: DevicePlatform;
+    /** Epoch milliseconds when this snapshot was captured natively. */
+    timestamp: number;
+}
+/** Per-interface detail, returned by {@link getAllInterfaces} for debugging. */
+export interface NetworkInterfaceInfo {
+    /** Interface name (e.g. `en0`, `wlan0`, `bridge100`, `ap0`, `pdp_ip0`). */
+    name: string;
+    /** The interface's IPv4 address. */
+    ip: string;
+    /** Dotted IPv4 subnet mask, when known. */
+    netmask: string | null;
+    /** Best-effort role classification of the interface. */
+    role: 'wifi' | 'hotspot' | 'cellular' | 'ethernet' | 'other';
+}
+/** Native event map for the module. */
+export type LocalNetworkInfoModuleEvents = {
+    /** Fired whenever the device's network position changes. */
+    onNetworkChange: (info: LocalIpInfo) => void;
+};
+//# sourceMappingURL=LocalNetworkInfo.types.d.ts.map

package/build/LocalNetworkInfo.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalNetworkInfo.types.d.ts","sourceRoot":"","sources":["../src/LocalNetworkInfo.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;AAEtD,mDAAmD;AACnD,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,SAAS,GAAG,KAAK,CAAC;AAEvD;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAElB,8EAA8E;IAC9E,IAAI,EAAE,WAAW,CAAC;IAElB,mEAAmE;IACnE,eAAe,EAAE,OAAO,CAAC;IAEzB,mFAAmF;IACnF,aAAa,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAE7B,gFAAgF;IAChF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvB;;;;;;;;;OASG;IACH,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvB;;;;;;;;OAQG;IACH,oBAAoB,EAAE,aAAa,GAAG,IAAI,CAAC;IAE3C,4CAA4C;IAC5C,QAAQ,EAAE,cAAc,CAAC;IAEzB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,gFAAgF;AAChF,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,2CAA2C;IAC3C,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,wDAAwD;IACxD,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC;CAC9D;AAED,uCAAuC;AACvC,MAAM,MAAM,4BAA4B,GAAG;IACzC,4DAA4D;IAC5D,eAAe,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;CAC9C,CAAC"}

package/build/LocalNetworkInfo.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LocalNetworkInfo.types.js.map

package/build/LocalNetworkInfo.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalNetworkInfo.types.js","sourceRoot":"","sources":["../src/LocalNetworkInfo.types.ts"],"names":[],"mappings":""}