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

package/ndef-lib/{util.js → util.ts}

@@ -2,8 +2,11 @@
 // Copyright 2013 Don Coleman
 //
 
+type Byte = number;
+type ByteArray = Byte[];
+
 // https://weblog.rogueamoeba.com/2017/02/27/javascript-correctly-converting-a-byte-array-to-a-utf-8-string/
-function _utf8ArrayToStr(data) {
+function _utf8ArrayToStr(data: ByteArray): string | null {
   const extraByteMap = [1, 1, 1, 1, 2, 2, 3, 0];
   var count = data.length;
   var str = '';
@@ -25,16 +28,25 @@ function _utf8ArrayToStr(data) {
 
         ch = (ch << 6) | (chx & 0x3f);
       }
+
+      // A four-byte sequence can decode above the Unicode maximum, which is
+      // not a valid code point. Reject it like the other malformed cases
+      // rather than letting String.fromCodePoint throw a RangeError.
+      if (ch > 0x10ffff) {
+        return null;
+      }
     }
 
-    str += String.fromCharCode(ch);
+    // fromCharCode truncates to 16 bits, which silently corrupts anything
+    // outside the BMP: U+1F4A9 would come back as U+F4A9.
+    str += String.fromCodePoint(ch);
   }
 
   return str;
 }
 
 // https://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array
-function _toUTF8Array(str) {
+function _toUTF8Array(str: string): ByteArray {
   var out = [],
     p = 0;
   for (var i = 0; i < str.length; i++) {
@@ -64,7 +76,7 @@ function _toUTF8Array(str) {
   return out;
 }
 
-function stringToBytes(string) {
+function stringToBytes(string: string): ByteArray {
   return _toUTF8Array(string);
   // var bytes = Buffer(string).toJSON();
   // if (bytes.hasOwnProperty('data')) {
@@ -76,7 +88,7 @@ function stringToBytes(string) {
   // }
 }
 
-function bytesToString(bytes) {
+function bytesToString(bytes: string | ByteArray): string | null {
   if (typeof bytes === 'string') {
     return bytes;
   }
@@ -86,7 +98,7 @@ function bytesToString(bytes) {
 }
 
 // useful for readable version of Tag UID
-function bytesToHexString(bytes) {
+function bytesToHexString(bytes: ByteArray): string {
   var dec,
     hexstring,
     bytesAsHexString = '';
@@ -107,7 +119,7 @@ function bytesToHexString(bytes) {
 }
 
 // i must be <= 256
-function toHex(i) {
+function toHex(i: number): string {
   var hex;
 
   if (i < 0) {
@@ -122,8 +134,8 @@ function toHex(i) {
   return hex;
 }
 
-function toPrintable(i) {
-  if ((i >= 0x20) & (i <= 0x7f)) {
+function toPrintable(i: number): string {
+  if (i >= 0x20 && i <= 0x7f) {
     return String.fromCharCode(i);
   } else {
     return '.';
@@ -137,3 +149,5 @@ module.exports = {
   toHex: toHex,
   toPrintable: toPrintable,
 };
+
+export {};

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "react-native-nfc-manager",
-  "version": "4.0.0-beta.1",
+  "version": "4.0.0-beta.11",
   "description": "A NFC module for react native.",
-  "main": "src/index.js",
+  "main": "dist/src/index.js",
+  "types": "index.d.ts",
   "repository": {
     "type": "git",
-    "url": "https://github.com/whitedogg13/react-native-nfc-manager.git"
+    "url": "https://github.com/revtel/react-native-nfc-manager.git"
   },
   "bugs": {
-    "url": "https://github.com/whitedogg13/react-native-nfc-manager/issues"
+    "url": "https://github.com/revtel/react-native-nfc-manager/issues"
   },
   "keywords": [
     "react-native",
@@ -17,6 +18,7 @@
     "nfc"
   ],
   "files": [
+    "dist",
     "src",
     "ndef-lib",
     "index.d.ts",
@@ -32,16 +34,9 @@
     "url": "https://github.com/whitedogg13"
   },
   "jest": {
-    "testEnvironment": "node"
-  },
-  "babel": {
-    "presets": [
-      "@babel/preset-env",
-      "@babel/preset-react"
-    ],
-    "plugins": [
-      "@babel/plugin-proposal-class-properties",
-      "@babel/plugin-transform-runtime"
+    "testEnvironment": "node",
+    "testPathIgnorePatterns": [
+      "<rootDir>/example/"
     ]
   },
   "devDependencies": {
@@ -50,6 +45,8 @@
     "@babel/plugin-transform-runtime": "^7.12.10",
     "@babel/preset-env": "^7.12.11",
     "@babel/preset-react": "^7.12.10",
+    "@babel/preset-typescript": "^7.27.1",
+    "@expo/config-plugins": "~10.0.0",
     "@react-native-community/eslint-config": "^3.2.0",
     "@release-it/conventional-changelog": "^8.0.1",
     "dotenv-cli": "^7.4.2",
@@ -57,14 +54,15 @@
     "jest": "^29.7.0",
     "jest-cli": "^29.7.0",
     "prettier": "^2.2.1",
-    "react": "^16.13.1",
-    "react-native": "^0.63.0",
+    "react": "^19.2.3",
+    "react-native": "^0.84.0",
     "release-it": "^17.5.0",
-    "typescript": "^4.1.3",
-    "@expo/config-plugins": "~9.0.0"
+    "typescript": "^4.1.3"
   },
   "peerDependencies": {
-    "@expo/config-plugins": "8 || 9"
+    "@expo/config-plugins": "*",
+    "react": ">=18.2",
+    "react-native": ">=0.76"
   },
   "peerDependenciesMeta": {
     "@expo/config-plugins": {
@@ -72,11 +70,31 @@
     }
   },
   "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "test": "jest -i",
-    "release": "dotenv -- release-it --",
-    "release:beta": "release-it --preRelease=beta --increment=prerelease"
+    "typecheck": "tsc --noEmit -p tsconfig.typecheck.json",
+    "verify:package": "npm run build && node scripts/verify-package-contents.js",
+    "verify:codegen": "node scripts/verify-codegen-compatibility.js",
+    "verify:codegen:version": "node scripts/verify-codegen-compatibility.js --version",
+    "verify:codegen:regression": "node scripts/verify-codegen-compatibility.js --version=0.77.3 --assert-beta8-regression",
+    "verify:native:support-floor": "node scripts/verify-native-support-floor.js",
+    "verify:native:support-floor:android": "node scripts/verify-native-support-floor.js --platform=android",
+    "verify:native:support-floor:ios": "node scripts/verify-native-support-floor.js --platform=ios",
+    "verify:expo": "node scripts/verify-expo-consumer.js",
+    "verify:expo:config": "node scripts/verify-expo-consumer.js --platform=config",
+    "verify:expo:android": "node scripts/verify-expo-consumer.js --platform=android",
+    "verify:expo:ios": "node scripts/verify-expo-consumer.js --platform=ios",
+    "prepare:expo:smoke": "node scripts/prepare-expo-smoke.js",
+    "prepack": "npm run build",
+    "release": "dotenv -- node scripts/release.js stable",
+    "release:beta": "dotenv -- node scripts/release.js beta",
+    "test:example": "npm --prefix example test -- --runInBand --no-watchman",
+    "verify": "npm run build && npm run lint && npm run typecheck && npm test -- --runInBand --no-watchman && npm run test:example && node scripts/verify-package-contents.js",
+    "release:stable": "dotenv -- node scripts/release.js stable",
+    "test:publishing": "node --test scripts/trusted-publishing.test.cjs"
   },
   "codegenConfig": {
     "name": "NativeNfcManagerSpec",

package/react-native-nfc-manager.podspec

@@ -13,7 +13,8 @@ Pod::Spec.new do |s|
   s.source = { git: package[:repository][:url] }
   # s.source_files = "ios/**/*.{h,m}"
   s.source_files    = "ios/**/*.{h,m,mm,swift}"
-  s.platform = :ios, "8.0"
+  s.swift_version   = "5.7"
+  s.platform = :ios, "15.1"
 
   # s.dependency "React-Core"
 
@@ -22,4 +23,4 @@ Pod::Spec.new do |s|
   }
 
   install_modules_dependencies(s)
-end
+end

package/specs/NativeNfcManager.ts

@@ -1,8 +1,20 @@
 import type {TurboModule} from 'react-native';
+import type {EventEmitter} from 'react-native/Libraries/Types/CodegenTypes';
 import {TurboModuleRegistry} from 'react-native';
 
+export type SessionClosedEvent = {
+  error: string;
+};
+
+export type StateChangedEvent = {
+  state: string;
+};
+
 export interface Spec extends TurboModule {
-  echo(value: string, callback: (err?: string, resp?: string) => void): void;
+  readonly onDiscoverTag: EventEmitter<Object>;
+  readonly onDiscoverBackgroundTag: EventEmitter<Object>;
+  readonly onSessionClosed: EventEmitter<SessionClosedEvent>;
+  readonly onStateChanged: EventEmitter<StateChangedEvent>;
   isSupported(tech: string, callback: (err?: string, resp?: boolean) => void): void;
   isEnabled(callback: (err?: string, resp?: boolean) => void): void;
   start(callback: (err?: string) => void): void;
@@ -26,6 +38,7 @@ export interface Spec extends TurboModule {
   invalidateSession(callback: (err?: string) => void): void;
   invalidateSessionWithError(message: string, callback: (err?: string) => void): void;
   getNdefMessage(callback: (err?: string, tag?: Object) => void): void;
+  getCachedNdefMessage(callback: (err?: string, tag?: Object) => void): void;
   writeNdefMessage(bytes: number[], options: Object, callback: (err?: string) => void): void;
   makeReadOnly(callback: (err?: string) => void): void;
   setAlertMessage(message: string, callback: (err?: string) => void): void;
@@ -39,7 +52,7 @@ export interface Spec extends TurboModule {
   removeListeners: (count: number) => void;
   iso15693_getSystemInfo(requestFlag: number, callback: (err?: string, systemInfo?: Object) => void): void;
   iso15693_readSingleBlock(options: Object, callback: (err?: string, bytes?: number[]) => void): void;
-  iso15693_readMultipleBlocks(options: Object, callback: (err?: string, bytes?: number[]) => void): void;
+  iso15693_readMultipleBlocks(options: Object, callback: (err?: string, blocks?: number[][]) => void): void;
   iso15693_writeSingleBlock(options: Object, callback: (err?: string) => void): void;
   iso15693_lockBlock(options: Object, callback: (err?: string) => void): void;
   iso15693_writeAFI(options: Object, callback: (err?: string) => void): void;
@@ -48,16 +61,17 @@ export interface Spec extends TurboModule {
   iso15693_lockDSFID(options: Object, callback: (err?: string) => void): void;
   iso15693_resetToReady(options: Object, callback: (err?: string) => void): void;
   iso15693_select(options: Object, callback: (err?: string) => void): void;
-  iso15693_stayQuiet(options: Object, callback: (err?: string) => void): void;
+  iso15693_stayQuiet(callback: (err?: string) => void): void;
   iso15693_customCommand(options: Object, callback: (err?: string, bytes?: number[]) => void): void;
   iso15693_sendRequest(options: Object, callback: (err?: string, responseFlag?: number, bytes?: number[]) => void): void;
   iso15693_extendedReadSingleBlock(options: Object, callback: (err?: string, bytes?: number[]) => void): void;
-  iso15693_extendedReadMultipleBlocks(options: Object, callback: (err?: string, bytes?: number[]) => void): void;
+  iso15693_extendedReadMultipleBlocks(options: Object, callback: (err?: string, blocks?: number[][]) => void): void;
   iso15693_extendedWriteSingleBlock(options: Object, callback: (err?: string) => void): void;
   iso15693_extendedLockBlock(options: Object, callback: (err?: string) => void): void;
   goToNfcSetting(callback: (err?: string) => void): void;
   getLaunchTagEvent(callback: (err?: string, tag?: Object) => void): void;
   setTimeout(timeout: number, callback: (err?: string, tag?: Object) => void): void;
+  getTimeout(callback: (err?: string, timeout?: number) => void): void;
   connect(techs: string[], callback: (err?: string) => void): void;
   close(callback: (err?: string) => void): void;
   transceive(bytes: number[], callback: (err?: string, bytes?: number[]) => void): void;

package/src/NativeNfcManager.ts

@@ -0,0 +1,84 @@
+'use strict';
+import {NativeModules, NativeEventEmitter} from 'react-native';
+
+type NativeMethod = (...args: unknown[]) => void;
+type NativeEventSubscription = {remove: () => void};
+type CodegenEventEmitter = (
+  listener: (payload: unknown) => void,
+) => NativeEventSubscription;
+type NativeModule = Record<string, NativeMethod> & Record<string, unknown> & {
+  addListener: (eventType: string) => void;
+  removeListeners: (count: number) => void;
+  onDiscoverTag?: CodegenEventEmitter;
+  onDiscoverBackgroundTag?: CodegenEventEmitter;
+  onSessionClosed?: CodegenEventEmitter;
+  onStateChanged?: CodegenEventEmitter;
+};
+type NativeEmitterLike = {
+  addListener: (eventName: string, listener: (payload: unknown) => void) => NativeEventSubscription;
+};
+
+const reactNativeGlobal = global as typeof global & {
+  'RN$Bridgeless'?: boolean;
+  __turboModuleProxy?: unknown;
+};
+const isTurboModuleEnabled =
+  reactNativeGlobal['RN$Bridgeless'] === true ||
+  reactNativeGlobal.__turboModuleProxy != null;
+const nativeModules = NativeModules || {};
+const NativeNfcManager = (isTurboModuleEnabled
+  ? require('../specs/NativeNfcManager').default
+  : nativeModules.NfcManager) as NativeModule;
+
+const legacyNfcManagerEmitter: NativeEmitterLike =
+  typeof NativeEventEmitter === 'function'
+    ? new NativeEventEmitter(NativeNfcManager)
+    : {addListener: () => ({remove: () => {}})};
+
+const codegenEventEmitters: Record<string, CodegenEventEmitter | undefined> = {
+  NfcManagerDiscoverTag: NativeNfcManager.onDiscoverTag,
+  NfcManagerDiscoverBackgroundTag: NativeNfcManager.onDiscoverBackgroundTag,
+  NfcManagerSessionClosed: NativeNfcManager.onSessionClosed,
+  NfcManagerStateChanged: NativeNfcManager.onStateChanged,
+};
+
+const NfcManagerEmitter: NativeEmitterLike = {
+  addListener: (eventName, listener) => {
+    const codegenEmitter = codegenEventEmitters[eventName];
+    if (isTurboModuleEnabled && codegenEmitter) {
+      return codegenEmitter(listener);
+    }
+    return legacyNfcManagerEmitter.addListener(eventName, listener);
+  },
+};
+
+function callNative<T = unknown>(name: string, params: unknown[] = []): Promise<T> {
+  const nativeMethod = NativeNfcManager[name] as NativeMethod | undefined;
+
+  if (!nativeMethod) {
+    throw new Error(`no such native method: "${name}"`);
+  }
+
+  if (!Array.isArray(params)) {
+    throw new Error('params must be an array');
+  }
+
+  const createCallback = (
+    resolve: (value: T | PromiseLike<T>) => void,
+    reject: (reason?: unknown) => void,
+  ) => (err: unknown, result: T) => {
+    if (err) {
+      reject(err);
+    } else {
+      resolve(result);
+    }
+  };
+
+  return new Promise((resolve, reject) => {
+    const callback = createCallback(resolve, reject);
+    const inputParams = [...params, callback];
+    nativeMethod(...inputParams);
+  });
+}
+
+export {NativeNfcManager, NfcManagerEmitter, callNative};

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

@@ -7,22 +7,18 @@ export class InvalidParameter extends NfcErrorBase {}
 export class InvalidParameterLength extends NfcErrorBase {}
 export class ParameterOutOfBound extends NfcErrorBase {}
 export class RadioDisabled extends NfcErrorBase {}
-// transceive errors
 export class TagConnectionLost extends NfcErrorBase {}
 export class RetryExceeded extends NfcErrorBase {}
 export class TagResponseError extends NfcErrorBase {}
 export class SessionInvalidated extends NfcErrorBase {}
 export class TagNotConnected extends NfcErrorBase {}
 export class PacketTooLong extends NfcErrorBase {}
-// reader session errors
 export class UserCancel extends NfcErrorBase {}
 export class Timeout extends NfcErrorBase {}
 export class Unexpected extends NfcErrorBase {}
 export class SystemBusy extends NfcErrorBase {}
 export class FirstNdefInvalid extends NfcErrorBase {}
-// tag command configuration errors
 export class InvalidConfiguration extends NfcErrorBase {}
-// ndef reader session error
 export class TagNotWritable extends NfcErrorBase {}
 export class TagUpdateFailure extends NfcErrorBase {}
 export class TagSizeTooSmall extends NfcErrorBase {}
@@ -37,29 +33,25 @@ export const NfcErrorIOS = {
     invalidParameterLength: 4,
     parameterOutOfBound: 5,
     radioDisabled: 6,
-    // transceive errors
     tagConnectionLost: 100,
     retryExceeded: 101,
     tagResponseError: 102,
     sessionInvalidated: 103,
     tagNotConnected: 104,
     packetTooLong: 105,
-    // reader session errors
     userCancel: 200,
     timeout: 201,
     unexpected: 202,
     systemBusy: 203,
     firstNdefInvalid: 204,
-    // tag command configuration errors
     invalidConfiguration: 300,
-    // ndef reader session error
     tagNotWritable: 400,
     tagUpdateFailure: 401,
     tagSizeTooSmall: 402,
     zeroLengthMessage: 403,
   },
 
-  parse: (error) => {
+  parse: (error: string | UserCancel | unknown) => {
     if (typeof error === 'string') {
       const [domainError] = error.split(',');
 
@@ -70,7 +62,6 @@ export const NfcErrorIOS = {
         }
       }
     } else if (error instanceof UserCancel) {
-      // this is for backward capability only
       console.warn('API Deprecated: please use NfcError.UserCancel instead');
       return NfcErrorIOS.errCodes.userCancel;
     }
@@ -78,7 +69,7 @@ export const NfcErrorIOS = {
   },
 };
 
-export function buildNfcExceptionIOS(error) {
+export function buildNfcExceptionIOS(error: string) {
   const [domainError] = error.split(',');
 
   if (domainError) {
@@ -136,7 +127,7 @@ export function buildNfcExceptionIOS(error) {
   return new NfcErrorBase(error);
 }
 
-export function buildNfcExceptionAndroid(error) {
+export function buildNfcExceptionAndroid(error: string) {
   if (error === 'cancelled') {
     return new UserCancel();
   }
@@ -144,15 +135,14 @@ export function buildNfcExceptionAndroid(error) {
   return new NfcErrorBase(error);
 }
 
-export async function handleNativeException(
-  callNativePromise,
+export async function handleNativeException<T>(
+  callNativePromise: Promise<T>,
   ignoreError = false,
-) {
+): Promise<T | undefined> {
   try {
     return await callNativePromise;
   } catch (err) {
     if (!ignoreError) {
-      // the error from the native side will always be a string
       if (typeof err === 'string') {
         if (Platform.OS === 'ios') {
           throw buildNfcExceptionIOS(err);
@@ -161,7 +151,6 @@ export async function handleNativeException(
         }
       }
 
-      // unexpected condition, simply throws them out without conversion
       throw err;
     }
   }

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

@@ -20,7 +20,7 @@ const NfcEvents = {
   DiscoverBackgroundTag: 'NfcManagerDiscoverBackgroundTag',
   SessionClosed: 'NfcManagerSessionClosed',
   StateChanged: 'NfcManagerStateChanged',
-};
+} as const;
 
 const NfcTech = {
   Ndef: 'Ndef',
@@ -35,37 +35,50 @@ const NfcTech = {
   Iso15693IOS: 'iso15693',
   FelicaIOS: 'felica',
   NdefFormatable: 'NdefFormatable',
-};
+} as const;
 
 const DEFAULT_REGISTER_TAG_EVENT_OPTIONS = {
   alertMessage: 'Please tap NFC tags',
   invalidateAfterFirstRead: false,
   isReaderModeEnabled: false,
   readerModeFlags: 0,
-  readerModeDelay: 10,
-};
+  readerModeDelay: 250,
+} as const;
+
+type NfcEventName = (typeof NfcEvents)[keyof typeof NfcEvents];
+type RegisterTagEventOptions = Partial<typeof DEFAULT_REGISTER_TAG_EVENT_OPTIONS>;
+type WriteNdefOptions = {reconnectAfterWrite?: boolean};
+type ClientEventCallback = ((payload: unknown) => void) | null;
+type NativeSubscriptionMap = Partial<Record<NfcEventName, {remove: () => void}>>;
+type ClientListenerMap = Partial<Record<NfcEventName, ClientEventCallback>>;
+type AsyncMethod = (...args: unknown[]) => Promise<unknown>;
 
 function NotImpl() {
   throw new Error('not implemented');
 }
 
-async function DoNothing() {
+async function DoNothing(..._args: unknown[]) {
   // allow derived class to not implment it
 }
 
 class NfcManagerBase {
+  _subscriptions: NativeSubscriptionMap;
+  _clientListeners: ClientListenerMap;
+  _ndefHandler: NdefHandler | null;
+  _nfcAHandler: NfcAHandler | null;
+  _nfcVHandler: NfcVHandler | null;
+  _isoDepHandler: IsoDepHandler | null;
+
   constructor() {
+    this._subscriptions = {};
+    this._clientListeners = {};
+    this._ndefHandler = null;
+    this._nfcAHandler = null;
+    this._nfcVHandler = null;
+    this._isoDepHandler = null;
     this._subscribeNativeEvents();
   }
 
-  hello(str) {
-    return NativeNfcManager.hello(str);
-  }
-
-  async echo(msg) {
-    return handleNativeException(callNative('echo', [msg]));
-  }
-
   async start() {
     return handleNativeException(callNative('start'));
   }
@@ -74,7 +87,7 @@ class NfcManagerBase {
     return handleNativeException(callNative('isSupported', [tech]));
   }
 
-  async registerTagEvent(options = {}) {
+  async registerTagEvent(options: RegisterTagEventOptions = {}) {
     const optionsWithDefault = {
       ...DEFAULT_REGISTER_TAG_EVENT_OPTIONS,
       ...options,
@@ -93,8 +106,10 @@ class NfcManagerBase {
     return handleNativeException(callNative('getTag'));
   }
 
-  setEventListener(name, callback) {
-    const allNfcEvents = Object.keys(NfcEvents).map((k) => NfcEvents[k]);
+  setEventListener(name: NfcEventName, callback: ClientEventCallback) {
+    const allNfcEvents = Object.keys(NfcEvents).map(
+      (k) => NfcEvents[k as keyof typeof NfcEvents],
+    );
     if (allNfcEvents.indexOf(name) === -1) {
       throw new Error('no such event');
     }
@@ -102,24 +117,26 @@ class NfcManagerBase {
     this._clientListeners[name] = callback;
   }
 
-  requestTechnology = NotImpl;
+  requestTechnology: AsyncMethod = async (..._args: unknown[]) => NotImpl();
+
+  restartTechnologyRequestIOS: AsyncMethod = async (..._args: unknown[]) => NotImpl();
 
-  restartTechnologyRequestIOS = NotImpl;
+  cancelTechnologyRequest: AsyncMethod = async (..._args: unknown[]) => NotImpl();
 
-  cancelTechnologyRequest = NotImpl;
+  getBackgroundTag: AsyncMethod = async (..._args: unknown[]) => NotImpl();
 
-  getBackgroundTag = NotImpl;
+  clearBackgroundTag: AsyncMethod = async (..._args: unknown[]) => NotImpl();
 
-  clearBackgroundTag = NotImpl;
+  setAlertMessage: AsyncMethod = DoNothing;
 
-  setAlertMessage = DoNothing;
+  getTimeout: AsyncMethod = DoNothing;
 
-  async writeNdefMessage(bytes, options = {}) {
-    return handleNativeException(callNative('writeNdefMessage', [bytes, options]));
+  async writeNdefMessage(bytes: number[], options: WriteNdefOptions = {}) {
+    return this.ndefHandler.writeNdefMessage(bytes, options);
   }
 
   async getNdefMessage() {
-    return handleNativeException(callNative('getNdefMessage'));
+    return this.ndefHandler.getNdefMessage();
   }
 
   get ndefHandler() {
@@ -151,36 +168,36 @@ class NfcManagerBase {
   }
 
   get MIFARE_BLOCK_SIZE() {
-    return NativeNfcManager.MIFARE_BLOCK_SIZE;
+    return NativeNfcManager.MIFARE_BLOCK_SIZE as unknown as number;
   }
   get MIFARE_ULTRALIGHT_PAGE_SIZE() {
-    return NativeNfcManager.MIFARE_ULTRALIGHT_PAGE_SIZE;
+    return NativeNfcManager.MIFARE_ULTRALIGHT_PAGE_SIZE as unknown as number;
   }
   get MIFARE_ULTRALIGHT_TYPE() {
-    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE;
+    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE as unknown as number;
   }
   get MIFARE_ULTRALIGHT_TYPE_C() {
-    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE_C;
+    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE_C as unknown as number;
   }
   get MIFARE_ULTRALIGHT_TYPE_UNKNOWN() {
-    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE_UNKNOWN;
+    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE_UNKNOWN as unknown as number;
   }
 
-  _onDiscoverTag = (tag) => {
+  _onDiscoverTag = (tag: unknown) => {
     const callback = this._clientListeners[NfcEvents.DiscoverTag];
     if (callback) {
       callback(tag);
     }
   };
 
-  _onDiscoverBackgroundTag = (tag) => {
+  _onDiscoverBackgroundTag = (tag: unknown) => {
     const callback = this._clientListeners[NfcEvents.DiscoverBackgroundTag];
     if (callback) {
       callback(tag);
     }
   };
 
-  _onSessionClosedIOS = (resp) => {
+  _onSessionClosedIOS = (resp: {error: string}) => {
     const callback = this._clientListeners[NfcEvents.SessionClosed];
     if (callback) {
       const error = buildNfcExceptionIOS(resp.error);
@@ -188,7 +205,7 @@ class NfcManagerBase {
     }
   };
 
-  _onStateChangedAndroid = (state) => {
+  _onStateChangedAndroid = (state: unknown) => {
     const callback = this._clientListeners[NfcEvents.StateChanged];
     if (callback) {
       callback(state);