react-native-nfc-manager 4.0.0-beta.1 → 4.0.0-beta.10

package/src/{NfcManagerAndroid.js → NfcManagerAndroid.ts}

@@ -5,6 +5,12 @@ import {MifareUltralightHandlerAndroid} from './NfcTech/MifareUltralightHandlerA
 import {NdefFormatableHandlerAndroid} from './NfcTech/NdefFormatableHandlerAndroid';
 import {handleNativeException, buildNfcExceptionAndroid} from './NfcError';
 
+type RequestTechnologyOptions = Record<string, unknown>;
+type CancelTechnologyRequestOptions = {
+  throwOnError?: boolean;
+  delayMsAndroid?: number;
+};
+
 const NfcAdapter = {
   FLAG_READER_NFC_A: 0x1,
   FLAG_READER_NFC_B: 0x2,
@@ -15,15 +21,26 @@ const NfcAdapter = {
   FLAG_READER_NO_PLATFORM_SOUNDS: 0x100,
 };
 
-const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
 class NfcManagerAndroid extends NfcManagerBase {
+  cleanUpTagRegistration: boolean;
+  _mifareClassicHandlerAndroid: MifareClassicHandlerAndroid | null;
+  _mifareUltralightHandlerAndroid: MifareUltralightHandlerAndroid | null;
+  _ndefFormatableHandlerAndroid: NdefFormatableHandlerAndroid | null;
+
   constructor() {
     super();
     this.cleanUpTagRegistration = false;
+    this._mifareClassicHandlerAndroid = null;
+    this._mifareUltralightHandlerAndroid = null;
+    this._ndefFormatableHandlerAndroid = null;
   }
 
-  requestTechnology = async (tech, options = {}) => {
+  requestTechnology = async (
+    tech: string | string[],
+    options: RequestTechnologyOptions = {},
+  ) => {
     try {
       if (typeof tech === 'string') {
         tech = [tech];
@@ -43,7 +60,7 @@ class NfcManagerAndroid extends NfcManagerBase {
     }
   };
 
-  cancelTechnologyRequest = async (options = {}) => {
+  cancelTechnologyRequest = async (options: CancelTechnologyRequestOptions = {}) => {
     const {throwOnError = false, delayMsAndroid = 1000} = options;
 
     try {
@@ -77,18 +94,20 @@ class NfcManagerAndroid extends NfcManagerBase {
   getLaunchTagEvent = () =>
     handleNativeException(callNative('getLaunchTagEvent'));
 
-  setNdefPushMessage = (bytes) => {
+  setNdefPushMessage = (_bytes: number[]) => {
     return Promise.reject('this api is deprecated');
   }
 
-  setTimeout = (timeout) =>
+  setTimeout = (timeout: number) =>
     handleNativeException(callNative('setTimeout', [timeout]));
 
-  connect = (techs) => handleNativeException(callNative('connect', [techs]));
+  getTimeout = () => handleNativeException(callNative('getTimeout'));
+
+  connect = (techs: string[]) => handleNativeException(callNative('connect', [techs]));
 
   close = () => handleNativeException(callNative('close'));
 
-  transceive = (bytes) =>
+  transceive = (bytes: number[]) =>
     handleNativeException(callNative('transceive', [bytes]));
 
   getMaxTransceiveLength = () =>
@@ -121,7 +140,7 @@ class NfcManagerAndroid extends NfcManagerBase {
   // -------------------------------------
   get ndefFormatableHandlerAndroid() {
     if (!this._ndefFormatableHandlerAndroid) {
-      this._ndefFormatableHandlerAndroid = new NdefFormatableHandlerAndroid(this);
+      this._ndefFormatableHandlerAndroid = new NdefFormatableHandlerAndroid();
     }
     return this._ndefFormatableHandlerAndroid;
   }

package/src/{NfcManagerIOS.js → NfcManagerIOS.ts}

@@ -13,16 +13,34 @@ import {
 } from './NfcTech/Iso15693HandlerIOS';
 import {handleNativeException} from './NfcError';
 
+type RegisterTagEventOptions = Partial<typeof DEFAULT_REGISTER_TAG_EVENT_OPTIONS>;
+type CancelTechnologyRequestOptions = {throwOnError?: boolean};
+type BackgroundTag = {ndefMessage?: unknown[]};
+type IsoDepApdu = {
+  cla: number;
+  ins: number;
+  p1: number;
+  p2: number;
+  data: number[];
+  le: number;
+};
+
 class NfcManagerIOS extends NfcManagerBase {
+  _iso15693HandlerIOS: Iso15693HandlerIOS | null;
+
   constructor() {
     super();
+    this._iso15693HandlerIOS = null;
   }
 
   isEnabled = async () => {
     return true;
   };
 
-  requestTechnology = async (tech, options = {}) => {
+  requestTechnology = async (
+    tech: string | string[],
+    options: RegisterTagEventOptions = {},
+  ) => {
     if (typeof tech === 'string') {
       tech = [tech];
     }
@@ -55,7 +73,7 @@ class NfcManagerIOS extends NfcManagerBase {
     );
   };
 
-  cancelTechnologyRequest = async (options = {}) => {
+  cancelTechnologyRequest = async (options: CancelTechnologyRequestOptions = {}) => {
     const {throwOnError = false} = options;
     return handleNativeException(
       callNative('cancelTechnologyRequest'),
@@ -66,18 +84,21 @@ class NfcManagerIOS extends NfcManagerBase {
   getBackgroundTag = () =>
     handleNativeException(callNative('getBackgroundTag'));
 
-  clearBackgroundTag = async () => callNative('clearBackgroundTag');
+  clearBackgroundTag = () =>
+    handleNativeException(callNative('clearBackgroundTag'));
 
   // -------------------------------------
   // public only for iOS
   // -------------------------------------
-  getBackgroundNdef = () =>
-    handleNativeException(callNative('getBackgroundNdef'));
+  getBackgroundNdef = async () => {
+    const tag = await this.getBackgroundTag() as BackgroundTag | null | undefined;
+    return tag?.ndefMessage ?? null;
+  };
 
-  setAlertMessage = (alertMessage) =>
+  setAlertMessage = (alertMessage: string) =>
     handleNativeException(callNative('setAlertMessage', [alertMessage]));
 
-  setAlertMessageIOS = (alertMessage) =>
+  setAlertMessageIOS = (alertMessage: string) =>
     handleNativeException(callNative('setAlertMessage', [alertMessage]));
 
   invalidateSessionIOS = () =>
@@ -97,19 +118,19 @@ class NfcManagerIOS extends NfcManagerBase {
   // -------------------------------------
   // (iOS) NfcTech.MifareIOS API
   // -------------------------------------
-  sendMifareCommandIOS = (bytes) =>
+  sendMifareCommandIOS = (bytes: number[]) =>
     handleNativeException(callNative('sendMifareCommand', [bytes]));
 
   // -------------------------------------
   // (iOS) NfcTech.FelicaIOS API
   // -------------------------------------
-  sendFelicaCommandIOS = (bytes) =>
+  sendFelicaCommandIOS = (bytes: number[]) =>
     handleNativeException(callNative('sendFelicaCommand', [bytes]));
 
   // -------------------------------------
   // (iOS) NfcTech.IsoDep API
   // -------------------------------------
-  sendCommandAPDUIOS = (bytesOrApdu) => {
+  sendCommandAPDUIOS = (bytesOrApdu: number[] | IsoDepApdu) => {
     if (Platform.OS !== 'ios') {
       return Promise.reject('not implemented');
     }

package/src/NfcTech/{Iso15693HandlerIOS.js → Iso15693HandlerIOS.ts}

@@ -1,6 +1,30 @@
 import {callNative} from '../NativeNfcManager';
 import {handleNativeException} from '../NfcError';
 
+type Byte = number;
+type ByteArray = Byte[];
+
+type FlagsOnly = {flags: number};
+type BlockOptions = {flags: number; blockNumber: number};
+type MultiBlockOptions = {flags: number; blockNumber: number; blockCount: number};
+type WriteBlockOptions = {flags: number; blockNumber: number; dataBlock: ByteArray};
+type WriteAfiOptions = {flags: number; afi: number};
+type WriteDsfidOptions = {flags: number; dsfid: number};
+type CustomCommandOptions = {
+  flags: number;
+  customCommandCode: number;
+  customRequestParameters: ByteArray;
+};
+type SendRequestOptions = {flags: number; commandCode: number; data: ByteArray};
+
+type Iso15693SystemInfo = {
+  dsfid: number;
+  afi: number;
+  blockSize: number;
+  blockCount: number;
+  icReference: number;
+};
+
 const Nfc15693RequestFlagIOS = {
   DualSubCarriers: 1 << 0,
   HighDataRate: 1 << 1,
@@ -22,117 +46,121 @@ const Nfc15693ResponseFlagIOS = {
 };
 
 class Iso15693HandlerIOS {
-  getSystemInfo(requestFlag) {
+  getSystemInfo(requestFlag: number): Promise<Iso15693SystemInfo> {
     return handleNativeException(
       callNative('iso15693_getSystemInfo', [requestFlag]),
-    );
+    ) as Promise<Iso15693SystemInfo>;
   }
 
-  readSingleBlock({flags, blockNumber}) {
+  readSingleBlock({flags, blockNumber}: BlockOptions): Promise<ByteArray> {
     return handleNativeException(
       callNative('iso15693_readSingleBlock', [{flags, blockNumber}]),
-    );
+    ) as Promise<ByteArray>;
   }
 
-  readMultipleBlocks({flags, blockNumber, blockCount}) {
+  readMultipleBlocks({flags, blockNumber, blockCount}: MultiBlockOptions): Promise<ByteArray[]> {
     return handleNativeException(
       callNative('iso15693_readMultipleBlocks', [
         {flags, blockNumber, blockCount},
       ]),
-    );
+    ) as Promise<ByteArray[]>;
   }
 
-  writeSingleBlock({flags, blockNumber, dataBlock}) {
+  writeSingleBlock({flags, blockNumber, dataBlock}: WriteBlockOptions): Promise<void> {
     return handleNativeException(
       callNative('iso15693_writeSingleBlock', [
         {flags, blockNumber, dataBlock},
       ]),
-    );
+    ) as Promise<void>;
   }
 
-  lockBlock({flags, blockNumber}) {
+  lockBlock({flags, blockNumber}: BlockOptions): Promise<void> {
     return handleNativeException(
       callNative('iso15693_lockBlock', [{flags, blockNumber}]),
-    );
+    ) as Promise<void>;
   }
 
-  writeAFI({flags, afi}) {
+  writeAFI({flags, afi}: WriteAfiOptions): Promise<void> {
     return handleNativeException(
       callNative('iso15693_writeAFI', [{flags, afi}]),
-    );
+    ) as Promise<void>;
   }
 
-  lockAFI({flags}) {
-    return handleNativeException(callNative('iso15693_lockAFI', [{flags}]));
+  lockAFI({flags}: FlagsOnly): Promise<void> {
+    return handleNativeException(callNative('iso15693_lockAFI', [{flags}])) as Promise<void>;
   }
 
-  writeDSFID({flags, dsfid}) {
+  writeDSFID({flags, dsfid}: WriteDsfidOptions): Promise<void> {
     return handleNativeException(
       callNative('iso15693_writeDSFID', [{flags, dsfid}]),
-    );
+    ) as Promise<void>;
   }
 
-  lockDSFID({flags}) {
-    return handleNativeException(callNative('iso15693_lockDSFID', [{flags}]));
+  lockDSFID({flags}: FlagsOnly): Promise<void> {
+    return handleNativeException(callNative('iso15693_lockDSFID', [{flags}])) as Promise<void>;
   }
 
-  resetToReady({flags}) {
+  resetToReady({flags}: FlagsOnly): Promise<void> {
     return handleNativeException(
       callNative('iso15693_resetToReady', [{flags}]),
-    );
+    ) as Promise<void>;
+  }
+
+  select({flags}: FlagsOnly): Promise<void> {
+    return handleNativeException(callNative('iso15693_select', [{flags}])) as Promise<void>;
   }
 
-  select({flags}) {
-    return handleNativeException(callNative('iso15693_select', [{flags}]));
+  stayQuiet(): Promise<void> {
+    return handleNativeException(callNative('iso15693_stayQuiet')) as Promise<void>;
   }
 
-  stayQuite() {
-    return handleNativeException(callNative('iso15693_stayQuiet'));
+  stayQuite(): Promise<void> {
+    return this.stayQuiet();
   }
 
-  customCommand({flags, customCommandCode, customRequestParameters}) {
+  customCommand({flags, customCommandCode, customRequestParameters}: CustomCommandOptions): Promise<ByteArray> {
     return handleNativeException(
       callNative('iso15693_customCommand', [
         {flags, customCommandCode, customRequestParameters},
       ]),
-    );
+    ) as Promise<ByteArray>;
   }
 
   // https://developer.apple.com/documentation/corenfc/nfciso15693tag/3551933-sendrequestwithflag?language=objc
-  sendRequest({flags, commandCode, data}) {
+  sendRequest({flags, commandCode, data}: SendRequestOptions): Promise<[number, ByteArray]> {
     return handleNativeException(
       callNative('iso15693_sendRequest', [
         {flags, commandCode, data},
       ]),
-    );
+    ) as Promise<[number, ByteArray]>;
   }
 
-  extendedReadSingleBlock({flags, blockNumber}) {
+  extendedReadSingleBlock({flags, blockNumber}: BlockOptions): Promise<ByteArray> {
     return handleNativeException(
       callNative('iso15693_extendedReadSingleBlock', [{flags, blockNumber}]),
-    );
+    ) as Promise<ByteArray>;
   }
 
-  extendedReadMultipleBlocks({flags, blockNumber, blockCount}) {
+  extendedReadMultipleBlocks({flags, blockNumber, blockCount}: MultiBlockOptions): Promise<ByteArray[]> {
     return handleNativeException(
       callNative('iso15693_extendedReadMultipleBlocks', [
         {flags, blockNumber, blockCount},
       ]),
-    );
+    ) as Promise<ByteArray[]>;
   }
 
-  extendedWriteSingleBlock({flags, blockNumber, dataBlock}) {
+  extendedWriteSingleBlock({flags, blockNumber, dataBlock}: WriteBlockOptions): Promise<void> {
     return handleNativeException(
       callNative('iso15693_extendedWriteSingleBlock', [
         {flags, blockNumber, dataBlock},
       ]),
-    );
+    ) as Promise<void>;
   }
 
-  extendedLockBlock({flags, blockNumber}) {
+  extendedLockBlock({flags, blockNumber}: BlockOptions): Promise<void> {
     return handleNativeException(
       callNative('iso15693_extendedLockBlock', [{flags, blockNumber}]),
-    );
+    ) as Promise<void>;
   }
 }
 

package/src/NfcTech/{IsoDepHandler.js → IsoDepHandler.ts}

@@ -2,8 +2,11 @@ import {Platform} from 'react-native';
 import {callNative, NativeNfcManager} from '../NativeNfcManager';
 import {handleNativeException} from '../NfcError';
 
+type Byte = number;
+type ByteArray = Byte[];
+
 class IsoDepHandler {
-  async transceive(bytes) {
+  async transceive(bytes: ByteArray): Promise<ByteArray> {
     if (!Array.isArray(bytes)) {
       throw new Error(
         'IsoDepHandler.transceive only takes input as a byte array',
@@ -12,10 +15,10 @@ class IsoDepHandler {
 
     if (Platform.OS === 'ios') {
       return handleNativeException(
-        new Promise((resolve, reject) => {
+        new Promise<ByteArray>((resolve, reject) => {
           NativeNfcManager.sendCommandAPDUBytes(
             bytes,
-            (err, response, sw1, sw2) => {
+            (err: string | null, response: ByteArray, sw1: number, sw2: number) => {
               if (err) {
                 reject(err);
               } else {
@@ -25,10 +28,10 @@ class IsoDepHandler {
             },
           );
         }),
-      );
+      ) as Promise<ByteArray>;
     }
 
-    return handleNativeException(callNative('transceive', [bytes]));
+    return handleNativeException(callNative('transceive', [bytes])) as Promise<ByteArray>;
   }
 }
 

package/src/NfcTech/{MifareClassicHandlerAndroid.js → MifareClassicHandlerAndroid.ts}

@@ -1,58 +1,67 @@
 import {callNative} from '../NativeNfcManager';
 import {handleNativeException} from '../NfcError';
 
+type Byte = number;
+type ByteArray = Byte[];
+
+type AndroidMifareManager = {
+  MIFARE_BLOCK_SIZE: number;
+};
+
 class MifareClassicHandlerAndroid {
-  constructor(nfcManager) {
+  nfcManager: AndroidMifareManager;
+
+  constructor(nfcManager: AndroidMifareManager) {
     this.nfcManager = nfcManager;
   }
 
-  async mifareClassicAuthenticateA(sector, key) {
+  async mifareClassicAuthenticateA(sector: number, key: ByteArray): Promise<boolean> {
     if (!key || !Array.isArray(key) || key.length !== 6) {
       throw new Error('key should be an Array[6] of integers (0 - 255)');
     }
 
     return handleNativeException(
       callNative('mifareClassicAuthenticateA', [sector, key]),
-    );
+    ) as Promise<boolean>;
   }
 
-  async mifareClassicAuthenticateB(sector, key) {
+  async mifareClassicAuthenticateB(sector: number, key: ByteArray): Promise<boolean> {
     if (!key || !Array.isArray(key) || key.length !== 6) {
       throw new Error('key should be an Array[6] of integers (0 - 255)');
     }
 
     return handleNativeException(
       callNative('mifareClassicAuthenticateB', [sector, key]),
-    );
+    ) as Promise<boolean>;
   }
 
-  async mifareClassicGetBlockCountInSector(sector) {
+  async mifareClassicGetBlockCountInSector(sector: number): Promise<number> {
     return handleNativeException(
       callNative('mifareClassicGetBlockCountInSector', [sector]),
-    );
+    ) as Promise<number>;
   }
 
-  async mifareClassicGetSectorCount() {
-    return handleNativeException(callNative('mifareClassicGetSectorCount'));
+  async mifareClassicGetSectorCount(): Promise<number> {
+    return handleNativeException(callNative('mifareClassicGetSectorCount')) as Promise<number>;
   }
 
-  async mifareClassicSectorToBlock(sector) {
+  async mifareClassicSectorToBlock(sector: number): Promise<number> {
     return handleNativeException(
       callNative('mifareClassicSectorToBlock', [sector]),
-    );
+    ) as Promise<number>;
   }
 
-  async mifareClassicReadBlock(block) {
-    return handleNativeException(callNative('mifareClassicReadBlock', [block]));
+  async mifareClassicReadBlock(block: number): Promise<ByteArray> {
+    return handleNativeException(callNative('mifareClassicReadBlock', [block])) as Promise<ByteArray>;
   }
 
-  async mifareClassicReadSector(sector) {
+  async mifareClassicReadSector(sector: number): Promise<ByteArray> {
     return handleNativeException(
       callNative('mifareClassicReadSector', [sector]),
-    );
+    ) as Promise<ByteArray>;
   }
 
-  async mifareClassicWriteBlock(block, data) {
+  async mifareClassicWriteBlock(block: number, data: ByteArray): Promise<boolean> {
     if (
       !data ||
       !Array.isArray(data) ||
@@ -65,10 +74,10 @@ class MifareClassicHandlerAndroid {
 
     return handleNativeException(
       callNative('mifareClassicWriteBlock', [block, data]),
-    );
+    ) as Promise<boolean>;
   }
 
-  async mifareClassicIncrementBlock(block, value) {
+  async mifareClassicIncrementBlock(block: number, value: number): Promise<boolean> {
     if (
       !value ||
       Number.isNaN(value)) {
@@ -79,10 +88,10 @@ class MifareClassicHandlerAndroid {
 
     return handleNativeException(
       callNative('mifareClassicIncrementBlock', [block, value]),
-    );
+    ) as Promise<boolean>;
   }
 
-  async mifareClassicDecrementBlock(block, value) {
+  async mifareClassicDecrementBlock(block: number, value: number): Promise<boolean> {
     if (
       !value ||
       Number.isNaN(value)) {
@@ -93,9 +102,10 @@ class MifareClassicHandlerAndroid {
 
     return handleNativeException(
       callNative('mifareClassicDecrementBlock', [block, value]),
-    );
+    ) as Promise<boolean>;
   }
-  async mifareClassicTransferBlock(block) {
+
+  async mifareClassicTransferBlock(block: number): Promise<boolean> {
     if (
       !block ||
       Number.isNaN(block)) {
@@ -106,9 +116,8 @@ class MifareClassicHandlerAndroid {
 
     return handleNativeException(
       callNative('mifareClassicTransferBlock', [block]),
-    );
+    ) as Promise<boolean>;
   }
-
 }
 
 export {MifareClassicHandlerAndroid};

package/src/NfcTech/{MifareUltralightHandlerAndroid.js → MifareUltralightHandlerAndroid.ts}

@@ -1,18 +1,27 @@
 import {callNative} from '../NativeNfcManager';
 import {handleNativeException} from '../NfcError';
 
+type Byte = number;
+type ByteArray = Byte[];
+
+type AndroidMifareUltralightManager = {
+  MIFARE_ULTRALIGHT_PAGE_SIZE: number;
+};
+
 class MifareUltralightHandlerAndroid {
-  constructor(nfcManager) {
+  nfcManager: AndroidMifareUltralightManager;
+
+  constructor(nfcManager: AndroidMifareUltralightManager) {
     this.nfcManager = nfcManager;
   }
 
-  async mifareUltralightReadPages(pageOffset) {
+  async mifareUltralightReadPages(pageOffset: number): Promise<ByteArray> {
     return handleNativeException(
       callNative('mifareUltralightReadPages', [pageOffset]),
-    );
+    ) as Promise<ByteArray>;
   }
 
-  async mifareUltralightWritePage(pageOffset, data) {
+  async mifareUltralightWritePage(pageOffset: number, data: ByteArray): Promise<void> {
     if (
       !data ||
       !Array.isArray(data) ||
@@ -25,7 +34,7 @@ class MifareUltralightHandlerAndroid {
 
     return handleNativeException(
       callNative('mifareUltralightWritePage', [pageOffset, data]),
-    );
+    ) as Promise<void>;
   }
 }
 

package/src/NfcTech/{NdefFormatableHandlerAndroid.js → NdefFormatableHandlerAndroid.ts}

@@ -1,15 +1,22 @@
 import {callNative} from '../NativeNfcManager';
 import {handleNativeException} from '../NfcError';
 
+type Byte = number;
+type ByteArray = Byte[];
+
+type NdefFormatOptions = {
+  readOnly?: boolean;
+};
+
 class NdefFormatableHandlerAndroid {
-  async formatNdef(bytes, options={}) {
+  async formatNdef(bytes: ByteArray, options: NdefFormatOptions = {}): Promise<void> {
     const defaultOptions = { readOnly: false };
     return handleNativeException(
         callNative('formatNdef', [
             bytes, 
             {...defaultOptions, ...options}
         ])
-    );
+    ) as Promise<void>;
   }
 }
 

package/src/NfcTech/{NdefHandler.js → NdefHandler.ts}

@@ -2,6 +2,18 @@ import {Platform} from 'react-native';
 import {callNative} from '../NativeNfcManager';
 import {handleNativeException} from '../NfcError';
 
+type Byte = number;
+type ByteArray = Byte[];
+
+type WriteNdefOptions = {
+  reconnectAfterWrite?: boolean;
+};
+
+type NdefStatusResult = {
+  status: number;
+  capacity: number;
+};
+
 const NdefStatus = {
   NotSupported: 1,
   ReadWrite: 2,
@@ -9,8 +21,7 @@ const NdefStatus = {
 };
 
 class NdefHandler {
-  async writeNdefMessage(bytes, options) {
-  
+  async writeNdefMessage(bytes: ByteArray, options?: WriteNdefOptions) {
     const defaultOptions = { reconnectAfterWrite: false };
     return handleNativeException(
         callNative('writeNdefMessage', [
@@ -18,7 +29,6 @@ class NdefHandler {
             {...defaultOptions, ...options}
         ])
     );
-  
   }
 
   async getNdefMessage() {
@@ -29,12 +39,15 @@ class NdefHandler {
     return handleNativeException(callNative('makeReadOnly'));
   }
 
-  async getNdefStatus() {
+  async getNdefStatus(): Promise<NdefStatusResult> {
     if (Platform.OS === 'ios') {
-      return handleNativeException(callNative('queryNdefStatus'));
+      return handleNativeException(callNative('queryNdefStatus')) as Promise<NdefStatusResult>;
     } else {
       try {
-        const result = await handleNativeException(callNative('queryNdefStatus'));
+        const result = await handleNativeException(callNative('queryNdefStatus')) as {
+          isWritable: boolean;
+          maxSize: number;
+        };
         return {
           status: result.isWritable
             ? NdefStatus.ReadWrite

package/src/NfcTech/{NfcAHandler.js → NfcAHandler.ts}

@@ -2,12 +2,15 @@ import {Platform} from 'react-native';
 import {callNative} from '../NativeNfcManager';
 import {handleNativeException} from '../NfcError';
 
+type Byte = number;
+type ByteArray = Byte[];
+
 class NfcAHandler {
-  async transceive(bytes) {
+  async transceive(bytes: ByteArray): Promise<ByteArray> {
     if (Platform.OS === 'ios') {
-      return handleNativeException(callNative('sendMifareCommand', [bytes]));
+      return handleNativeException(callNative('sendMifareCommand', [bytes])) as Promise<ByteArray>;
     }
-    return handleNativeException(callNative('transceive', [bytes]));
+    return handleNativeException(callNative('transceive', [bytes])) as Promise<ByteArray>;
   }
 }