@spencerls/react-native-nfc 1.0.8 → 1.0.9

package/README.md

@@ -1,21 +1,45 @@
 # @spencerls/react-native-nfc
 
-A clean, React-friendly, cross-platform NFC layer built on top of  
+A clean, React-friendly, **cross-platform** NFC layer built on top of  
 `react-native-nfc-manager`.
 
+## 🎯 Truly Cross-Platform
+
+Write your NFC code once and it works on **both iOS and Android**.  
+The only platform-specific code is the optional Android reader mode configuration.  
+Everything else—reading, writing, and all NFC operations—uses the exact same API.
+
 This package provides:
 
 - A unified NFC service (`nfcService`)
-- High-level protocol namespaces (`nfc.v`, `nfc.a`, `nfc.ndef`)
+- High-level protocol namespaces (`nfc.tag`, `nfc.v`, `nfc.ndef`)
+- Low-level tag modules (`nfcTag`, `nfcVTag`, `nfcNdefTag`)
 - Automatic iOS reader restarts
 - Safe Android reader handling
 - Optional React hooks and provider
-- Technology sessions for NDEF/NfcV/NfcA and raw commands
+- Technology sessions for NDEF/NfcV and raw commands
+- Builder pattern for NDEF records
 
 The API is designed to be stable, predictable, and easy to use across iOS and Android.
 
 ---
 
+## Platform Support
+
+| Feature | iOS | Android |
+|---------|-----|---------|
+| Reader Mode* | ❌ | ✅ |
+| NDEF Read/Write | ✅ | ✅ |
+| NFC-V (ISO15693) | ✅ | ✅ |
+| Technology Sessions | ✅ | ✅ |
+| React Hooks | ✅ | ✅ |
+
+**\*Reader Mode** is Android's background NFC scanning API. iOS uses Technology Sessions instead.  
+**Platform-specific code:** Only `enableReaderMode_ANDROID()` is Android-specific (no-op on iOS).  
+All other APIs work identically on both platforms.
+
+---
+
 ## Installation
 
 ```bash
@@ -41,12 +65,14 @@ import { NfcAdapter } from "react-native-nfc-manager";
 export default function ScannerScreen() {
   const { mode } = useNfcState();
 
-  // Enable Android reader mode (call once, typically at app startup)
+  // Platform-specific: Configure Android reader mode (no-op on iOS)
+  // Call once, typically at app startup or in useEffect
   nfcService.enableReaderMode_ANDROID(
     NfcAdapter.FLAG_READER_NFC_V |
     NfcAdapter.FLAG_READER_NO_PLATFORM_SOUNDS
   );
 
+  // Cross-platform: Works identically on iOS and Android
   useNfc((tagId) => {
     console.log("Scanned:", tagId);
   }, {
@@ -72,10 +98,11 @@ import { NfcAdapter } from "react-native-nfc-manager";
 export default function Screen() {
   const { start, stop } = useNfcReader();
 
-  // Enable Android reader mode (call once, typically at app startup)
+  // Platform-specific: Configure Android reader mode (no-op on iOS)
   nfcService.enableReaderMode_ANDROID(NfcAdapter.FLAG_READER_NFC_V);
 
   const begin = () => {
+    // Cross-platform: Works identically on iOS and Android
     start(
       (tag) => {
         console.log("Tag:", tag.id);
@@ -90,70 +117,186 @@ export default function Screen() {
 
 ---
 
-## Technology Sessions (NfcTech.*)
+## Get Basic Tag Information
 
-Always use `NfcTech` enums.  
-Do not pass raw strings.
+**Cross-platform:** Works identically on iOS and Android.
 
 ```tsx
 import { nfc } from "@spencerls/react-native-nfc";
-import { useNfcTechnology } from "@spencerls/react-native-nfc";
 import { NfcTech } from "react-native-nfc-manager";
 
-export function ReadSystemInfo() {
-  const { runWithTech } = useNfcTechnology();
+export default function ScanTagButton() {
+  const scanTag = async () => {
+    const tag = await nfc.tag.getTag([
+      NfcTech.NfcA,
+      NfcTech.NfcV,
+      NfcTech.Ndef,
+    ]);
+    console.log("Tag ID:", tag.id);
+    console.log("Tag Type:", tag.type);
+  };
 
-  const readInfo = async () => {
-    await runWithTech([NfcTech.NfcV], async () => {
-      const info = await nfc.v.getSystemInfoNfcV();
-      console.log(info);
-    });
+  return <Button title="Scan Tag" onPress={scanTag} />;
+}
+```
+
+---
+
+## NDEF Write with Builder
+
+**Cross-platform:** Works identically on iOS and Android.
+
+```tsx
+import { nfc } from "@spencerls/react-native-nfc";
+
+export default function WriteNdefButton() {
+  const writeNdef = async () => {
+    await nfc.ndef.write(
+      nfc.ndef.Builder.records((B) => [
+        B.textRecord("Hello, world!"),
+        B.uriRecord("https://www.google.com"),
+        B.jsonRecord(
+          JSON.stringify({
+            name: "John Doe",
+            age: 30,
+            email: "john.doe@example.com",
+          })
+        ),
+      ])
+    );
   };
 
-  return <Button title="Read NFC-V Info" onPress={readInfo} />;
+  return <Button title="Write NDEF" onPress={writeNdef} />;
 }
 ```
 
 ---
 
-## NDEF Read/Write
+## NDEF Read
+
+**Cross-platform:** Works identically on iOS and Android.
 
 ```tsx
-import { useNfcTechnology } from "@spencerls/react-native-nfc";
-import { NfcTech, Ndef, NfcManager } from "react-native-nfc-manager";
-
-export default function WriteScreen() {
-  const { runWithTech } = useNfcTechnology();
-
-  const writeHello = async () => {
-    await runWithTech([NfcTech.Ndef], async () => {
-      const bytes = Ndef.encodeMessage([
-        Ndef.textRecord("Hello NFC!")
-      ]);
-      await NfcManager.ndefHandler.writeNdefMessage(bytes);
+import { nfc } from "@spencerls/react-native-nfc";
+
+export default function ReadNdefButton() {
+  const readNdef = async () => {
+    const { message, tag } = await nfc.ndef.readFull();
+    console.log("Tag ID:", tag.id);
+    console.log("Records:", message.ndefMessage);
+  };
+
+  return <Button title="Read NDEF" onPress={readNdef} />;
+}
+```
+
+---
+
+## Custom NFC-V Operations
+
+**Cross-platform:** Works identically on iOS and Android.
+
+```tsx
+import { nfc, nfcTag, nfcVTag } from "@spencerls/react-native-nfc";
+
+export default function ReadNfcVButton() {
+  const readCustom = async () => {
+    const data = await nfc.service.withTechnology(nfcVTag.tech, async () => {
+      const tag = await nfcTag.getTag();
+      if (!tag?.id) throw new Error("No NFC-V tag detected");
+
+      const buffer = new Uint8Array();
+      let offset = 0;
+      
+      // Read blocks 0, 2, 4, 6
+      for (let i = 0; i < 8; i += 2) {
+        const block = await nfcVTag.readBlock(tag.id, i);
+        buffer.set(block, offset);
+        offset += block.length;
+      }
+      
+      return buffer;
     });
+    
+    console.log("Data:", data);
   };
 
-  return <Button title="Write NDEF" onPress={writeHello} />;
+  return <Button title="Read NFC-V" onPress={readCustom} />;
 }
 ```
 
 ---
 
-## Namespace API
+## High-Level NFC-V Operations
 
-```ts
+**Cross-platform:** Works identically on iOS and Android.
+
+```tsx
 import { nfc } from "@spencerls/react-native-nfc";
 
-await nfc.v.getSystemInfoNfcV();
-await nfc.v.readSingleBlock(uid, 0);
+export default function NfcVScreen() {
+  const readBlock = async () => {
+    const data = await nfc.v.readBlock(0);
+    console.log("Block 0:", data);
+  };
 
-await nfc.a.transceive(rawBytes);
+  const writeBlock = async () => {
+    const data = new Uint8Array([0x01, 0x02, 0x03, 0x04]);
+    await nfc.v.writeBlock(0, data);
+  };
 
-await nfc.ndef.parse(ndefBytes);
+  const getInfo = async () => {
+    const info = await nfc.v.getSystemInfo();
+    console.log("System Info:", info);
+  };
 
-nfc.service.startReader(...);
-nfc.service.withTechnology(...);
+  return (
+    <View>
+      <Button title="Read Block" onPress={readBlock} />
+      <Button title="Write Block" onPress={writeBlock} />
+      <Button title="Get Info" onPress={getInfo} />
+    </View>
+  );
+}
+```
+
+---
+
+## API Overview
+
+**Cross-platform:** All APIs below work identically on iOS and Android.
+
+```ts
+import { nfc, nfcTag, nfcVTag, nfcNdefTag } from "@spencerls/react-native-nfc";
+
+// High-level namespace operations (auto-manages technology sessions)
+await nfc.tag.getTag([NfcTech.NfcV]);
+await nfc.v.readBlock(0);
+await nfc.v.writeBlock(0, data);
+await nfc.v.getSystemInfo();
+await nfc.ndef.write(records);
+await nfc.ndef.readMessage();
+await nfc.ndef.readFull();
+
+// Low-level tag modules (use inside withTechnology)
+await nfc.service.withTechnology(nfcVTag.tech, async () => {
+  const tag = await nfcTag.getTag();
+  const block = await nfcVTag.readBlock(tag.id, 0);
+});
+
+// NDEF Builder
+const records = nfc.ndef.Builder.records((B) => [
+  B.textRecord("Hello"),
+  B.uriRecord("https://example.com"),
+  B.jsonRecord(JSON.stringify({ key: "value" })),
+  B.mimeRecord("text/plain", "data"),
+  B.externalRecord("example.com", "type", "payload"),
+]);
+
+// Service control
+nfc.service.enableReaderMode_ANDROID(flags); // Android-only (no-op on iOS)
+await nfc.service.startReader(onTag, options); // Cross-platform
+await nfc.service.stopReader(); // Cross-platform
 ```
 
 ---

package/dist/index.d.mts

@@ -1,105 +1,46 @@
 import * as react_native_nfc_manager from 'react-native-nfc-manager';
-import { TagEvent, NfcTech, NdefRecord } from 'react-native-nfc-manager';
+import { NdefRecord, ISOLangCode, TNF, TagEvent, NfcTech, NdefStatus } from 'react-native-nfc-manager';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { PropsWithChildren } from 'react';
 
-declare const operations$2: {
-    transceive(data: number[]): Promise<number[]>;
-};
-
-declare const utils$2: {};
-
-declare namespace index$2 {
-  export { operations$2 as operations, utils$2 as utils };
+declare class Builder {
+    static records(b: NdefBuilder): NdefRecord[];
+    static message(b: NdefBuilder): number[];
+    static record(init: BuildRecordInit): NdefRecord;
+    static textRecord(text: string, lang?: ISOLangCode, encoding?: "utf8" | "utf16", id?: string): NdefRecord;
+    static uriRecord(uri: string, id?: string): NdefRecord;
+    static jsonRecord(payload: string | Uint8Array | number[], id?: string): NdefRecord;
+    static mimeRecord(mimeType: string, payload: string | Uint8Array | number[], id?: string): NdefRecord;
+    static externalRecord(domain: string, type: string, payload: string | Uint8Array | number[], id?: string): NdefRecord;
+    static createEmpty(): NdefRecord;
 }
 
-type StrictTagEvent = TagEvent & {
-    id: string;
-};
-
-declare const operations$1: {
-    withVTag<T>(handler: (tag: StrictTagEvent) => Promise<T>): Promise<T>;
-    writeBlockNfcV(blockNumber: number, data: Uint8Array): Promise<void>;
-    readBlockNfcV(blockNumber: number): Promise<Uint8Array<ArrayBufferLike>>;
-    getSystemInfoNfcV(): Promise<any>;
-};
-
-declare const utils$1: {
-    readonly tech: NfcTech.NfcV | NfcTech[];
-    readonly Flags: {
-        readonly HIGH_DATA_RATE: 2;
-        readonly ADDRESSED: 32;
-    };
-    readonly Commands: {
-        readonly READ_SINGLE_BLOCK: 32;
-        readonly WRITE_SINGLE_BLOCK: 33;
-        readonly GET_SYSTEM_INFO: 43;
-    };
-    /**
-     * Combine multiple flag bits into one byte.
-     * Example: Flags.ADDRESSED | Flags.HIGH_DATA_RATE
-     */
-    readonly flags: (...bits: number[]) => number;
-    /**
-     * Convert tag.id hex string (MSB->LSB) into reversed byte array (LSB->MSB)
-     * ISO15693 requires reversed UID for addressed commands.
-     */
-    readonly reverseUid: (tagIdHex: string) => number[];
-    /**
-     * Build READ_SINGLE_BLOCK command.
-     * FLAGS: addressed + high data rate by default.
-     */
-    readonly buildReadBlock: (uidReversed: number[], blockNumber: number) => number[];
-    /**
-     * Build WRITE_SINGLE_BLOCK command.
-     * Note: data must match the block size (usually 4 or 8 bytes).
-     */
-    readonly buildWriteBlock: (uidReversed: number[], blockNumber: number, data: Uint8Array) => number[];
-    /**
-     * Build GET_SYSTEM_INFO command.
-     */
-    readonly buildGetSystemInfo: (uidReversed: number[]) => number[];
-    /**
-     * Parse a READ_SINGLE_BLOCK response.
-     * Response format:
-     *  - byte[0] = status (0x00 = success)
-     *  - byte[1..] = block payload bytes
-     */
-    readonly parseReadResponse: (resp: number[]) => Uint8Array;
-    /**
-     * Parse WRITE_SINGLE_BLOCK response.
-     * Successful write has resp[0] === 0x00.
-     */
-    readonly parseWriteResponse: (resp: number[]) => void;
-    /**
-     * Parse GET_SYSTEM_INFO response.
-     * Returns: UID, DSFID, AFI, numberOfBlocks, blockSize, manufacturer
-     */
-    readonly parseSystemInfo: (resp: number[]) => any;
-    /** Identify common manufacturers based on UID prefix */
-    readonly detectManufacturer: (uid: string) => string;
-};
-
-declare namespace index$1 {
-  export { operations$1 as operations, utils$1 as utils };
+type NdefBuilder = (r: typeof Builder) => NdefRecord[];
+interface BuildRecordInit {
+    tnf: TNF;
+    type: string | number[];
+    id?: string | number[];
+    payload?: string | number[];
+}
+interface NdefMessageResult {
+    ndefMessage: NdefRecord[];
+    type: number;
+    maxSize: number;
+    isWritable: boolean;
+    canMakeReadOnly: boolean;
 }
 
-declare const operations: {
-    writeNdef(records: NdefRecord[]): Promise<void>;
-    writeTextNdef(text: string): Promise<void>;
-    writeUriNdef(uri: string): Promise<void>;
+type SystemInfo = {
+    uid?: string;
+    dsfid?: number;
+    afi?: number;
+    numberOfBlocks?: number;
+    blockSize?: number;
+    icReference?: number;
+    manufacturer?: string;
 };
 
-declare const utils: {};
-
-declare const index_operations: typeof operations;
-declare const index_utils: typeof utils;
-declare namespace index {
-  export { index_operations as operations, index_utils as utils };
-}
-
 type NfcMode = "idle" | "starting" | "active" | "stopping" | "technology";
-
 interface NfcState {
     mode: NfcMode;
     tag: TagEvent | null;
@@ -129,54 +70,162 @@ declare class NfcService {
 }
 declare const nfcService: NfcService;
 
+declare function readMessage$1(): Promise<NdefMessageResult>;
+declare function write$1(records: NdefRecord[]): Promise<void>;
+
+declare const nfcNdefTag: {
+    readonly tech: react_native_nfc_manager.NfcTech[];
+    readonly readMessage: typeof readMessage$1;
+    readonly write: typeof write$1;
+};
+
+declare function getStatus(): Promise<{
+    status: NdefStatus;
+    capacity: number;
+}>;
+declare function readMessage(): Promise<NdefMessageResult>;
+declare function readFull(): Promise<{
+    message: NdefMessageResult;
+    tag: TagEvent;
+}>;
+declare function write(records: NdefRecord[]): Promise<void>;
+declare function writeText(text: string, lang?: ISOLangCode, encoding?: "utf8" | "utf16", id?: string): Promise<void>;
+declare function writeUri(uri: string, id?: string): Promise<void>;
+declare function writeJson(data: unknown, id?: string): Promise<void>;
+declare function writeMime(mimeType: string, payload: string | Uint8Array | number[], id?: string): Promise<void>;
+declare function writeExternal(domain: string, type: string, payload: string | Uint8Array | number[], id?: string): Promise<void>;
+declare function makeReadOnly(): Promise<void>;
+
+declare function getTag$1(): Promise<react_native_nfc_manager.TagEvent>;
+
+declare const nfcTag: {
+    readonly getTag: typeof getTag$1;
+};
+
+declare function getTag(tech: NfcTech | NfcTech[]): Promise<TagEvent>;
+
+declare function transceive(bytes: number[]): Promise<number[]>;
+declare function readBlock$1(tagId: string, blockNumber: number): Promise<Uint8Array>;
+declare function readBlocks$1(tagId: string, startBlock: number, endBlock: number): Promise<Uint8Array<ArrayBuffer>>;
+declare function writeBlock$1(tagId: string, blockNumber: number, data: Uint8Array): Promise<void>;
+declare function writeBlocks$1(tagId: string, blockNumber: number, data: Uint8Array[]): Promise<void>;
+declare function getSystemInfo$1(): Promise<SystemInfo>;
+
+declare const FLAGS: {
+    HIGH_DATA_RATE: number;
+    ADDRESSED: number;
+};
+declare const COMMANDS: {
+    READ_SINGLE_BLOCK: number;
+    WRITE_SINGLE_BLOCK: number;
+    GET_SYSTEM_INFO: number;
+};
+/**
+ * Combine multiple flag bits into one byte.
+ * Example: Flags.ADDRESSED | Flags.HIGH_DATA_RATE
+ */
+declare function buildFlags(...bits: number[]): number;
+/**
+ * Convert tag.id hex string (MSB->LSB) into reversed byte array (LSB->MSB)
+ * ISO15693 requires reversed UID for addressed commands.
+ */
+declare function reverseUid(tagIdHex: string): number[];
+/**
+ * Build READ_SINGLE_BLOCK command.
+ * FLAGS: addressed + high data rate by default.
+ */
+declare function buildReadBlock(uidReversed: number[], blockNumber: number): number[];
+/**
+ * Build WRITE_SINGLE_BLOCK command.
+ * Note: data must match the block size (usually 4 or 8 bytes).
+ */
+declare function buildWriteBlock(uidReversed: number[], blockNumber: number, data: Uint8Array): number[];
+/**
+ * Build GET_SYSTEM_INFO command.
+ */
+declare function buildGetSystemInfo(): number[];
+/**
+ * Parse a READ_SINGLE_BLOCK response.
+ * Response format:
+ *  - byte[0] = status (0x00 = success)
+ *  - byte[1..] = block payload bytes
+ */
+declare function parseReadResponse(resp: number[]): Uint8Array;
+/**
+ * Parse WRITE_SINGLE_BLOCK response.
+ * Successful write has resp[0] === 0x00.
+ */
+declare function parseWriteResponse(resp: number[]): void;
+/**
+ * Parse GET_SYSTEM_INFO response.
+ * Returns: UID, DSFID, AFI, numberOfBlocks, blockSize, manufacturer
+ */
+declare function parseSystemInfo(resp: number[]): SystemInfo;
+/** Identify common manufacturers based on UID prefix */
+declare function detectManufacturer(uid: string): string;
+
+declare const utils_COMMANDS: typeof COMMANDS;
+declare const utils_FLAGS: typeof FLAGS;
+declare const utils_buildFlags: typeof buildFlags;
+declare const utils_buildGetSystemInfo: typeof buildGetSystemInfo;
+declare const utils_buildReadBlock: typeof buildReadBlock;
+declare const utils_buildWriteBlock: typeof buildWriteBlock;
+declare const utils_detectManufacturer: typeof detectManufacturer;
+declare const utils_parseReadResponse: typeof parseReadResponse;
+declare const utils_parseSystemInfo: typeof parseSystemInfo;
+declare const utils_parseWriteResponse: typeof parseWriteResponse;
+declare const utils_reverseUid: typeof reverseUid;
+declare namespace utils {
+  export { utils_COMMANDS as COMMANDS, utils_FLAGS as FLAGS, utils_buildFlags as buildFlags, utils_buildGetSystemInfo as buildGetSystemInfo, utils_buildReadBlock as buildReadBlock, utils_buildWriteBlock as buildWriteBlock, utils_detectManufacturer as detectManufacturer, utils_parseReadResponse as parseReadResponse, utils_parseSystemInfo as parseSystemInfo, utils_parseWriteResponse as parseWriteResponse, utils_reverseUid as reverseUid };
+}
+
+declare const nfcVTag: {
+    readonly tech: react_native_nfc_manager.NfcTech.NfcV | react_native_nfc_manager.NfcTech[];
+    readonly utils: typeof utils;
+    readonly transceive: typeof transceive;
+    readonly readBlock: typeof readBlock$1;
+    readonly readBlocks: typeof readBlocks$1;
+    readonly writeBlock: typeof writeBlock$1;
+    readonly writeBlocks: typeof writeBlocks$1;
+    readonly getSystemInfo: typeof getSystemInfo$1;
+};
+
+declare function writeBlock(blockNumber: number, data: Uint8Array): Promise<void>;
+declare function writeBlocks(blockNumber: number, data: Uint8Array[]): Promise<void>;
+declare function readBlock(blockNumber: number): Promise<Uint8Array>;
+declare function readBlocks(startBlock: number, endBlock: number): Promise<Uint8Array>;
+declare function getSystemInfo(): Promise<SystemInfo>;
+
 /**
  * NFC root namespace providing access to:
  * - NfcService
  * - ISO15693 NFC-V ops
- * - NFC-A ops
  * - NDEF operations
  */
 declare const nfc: {
     readonly service: NfcService;
-    /** ISO15693 protocol helpers and high-level operations */
     readonly v: {
-        readonly utils: {
-            readonly tech: react_native_nfc_manager.NfcTech.NfcV | react_native_nfc_manager.NfcTech[];
-            readonly Flags: {
-                readonly HIGH_DATA_RATE: 2;
-                readonly ADDRESSED: 32;
-            };
-            readonly Commands: {
-                readonly READ_SINGLE_BLOCK: 32;
-                readonly WRITE_SINGLE_BLOCK: 33;
-                readonly GET_SYSTEM_INFO: 43;
-            };
-            readonly flags: (...bits: number[]) => number;
-            readonly reverseUid: (tagIdHex: string) => number[];
-            readonly buildReadBlock: (uidReversed: number[], blockNumber: number) => number[];
-            readonly buildWriteBlock: (uidReversed: number[], blockNumber: number, data: Uint8Array) => number[];
-            readonly buildGetSystemInfo: (uidReversed: number[]) => number[];
-            readonly parseReadResponse: (resp: number[]) => Uint8Array;
-            readonly parseWriteResponse: (resp: number[]) => void;
-            readonly parseSystemInfo: (resp: number[]) => any;
-            readonly detectManufacturer: (uid: string) => string;
-        };
-        readonly withVTag: <T>(handler: (tag: StrictTagEvent) => Promise<T>) => Promise<T>;
-        readonly writeBlockNfcV: (blockNumber: number, data: Uint8Array) => Promise<void>;
-        readonly readBlockNfcV: (blockNumber: number) => Promise<Uint8Array<ArrayBufferLike>>;
-        readonly getSystemInfoNfcV: () => Promise<any>;
-    };
-    /** NFC-A / Type 2 helpers and operations */
-    readonly a: {
-        readonly utils: {};
-        readonly transceive: (data: number[]) => Promise<number[]>;
+        readonly writeBlock: typeof writeBlock;
+        readonly writeBlocks: typeof writeBlocks;
+        readonly readBlock: typeof readBlock;
+        readonly readBlocks: typeof readBlocks;
+        readonly getSystemInfo: typeof getSystemInfo;
     };
-    /** NDEF read/write utilities and operations */
     readonly ndef: {
-        readonly utils: {};
-        readonly writeNdef: (records: react_native_nfc_manager.NdefRecord[]) => Promise<void>;
-        readonly writeTextNdef: (text: string) => Promise<void>;
-        readonly writeUriNdef: (uri: string) => Promise<void>;
+        readonly Builder: typeof Builder;
+        readonly getStatus: typeof getStatus;
+        readonly readMessage: typeof readMessage;
+        readonly readFull: typeof readFull;
+        readonly write: typeof write;
+        readonly writeText: typeof writeText;
+        readonly writeUri: typeof writeUri;
+        readonly writeJson: typeof writeJson;
+        readonly writeMime: typeof writeMime;
+        readonly writeExternal: typeof writeExternal;
+        readonly makeReadOnly: typeof makeReadOnly;
+    };
+    readonly tag: {
+        readonly getTag: typeof getTag;
     };
 };
 
@@ -203,4 +252,4 @@ declare function useNfcTechnology(): {
     runWithTech: (tech: NfcTech | NfcTech[], fn: () => Promise<void>) => Promise<void>;
 };
 
-export { type NfcMode, NfcProvider, type NfcState, nfc, index$2 as nfcA, index as nfcNdef, nfcService, index$1 as nfcV, useNfc, useNfcContext, useNfcReader, useNfcState, useNfcTechnology };
+export { type BuildRecordInit, type NdefBuilder, type NdefMessageResult, type NfcMode, NfcProvider, type NfcState, type SystemInfo, nfc, nfcNdefTag, nfcService, nfcTag, nfcVTag, useNfc, useNfcContext, useNfcReader, useNfcState, useNfcTechnology };