capacitor-plugin-faceantispoofing 0.0.1

package/android/src/main/java/io/github/asephermann/plugins/faceantispoofing/MyUtil.java

@@ -0,0 +1,174 @@
+package io.github.asephermann.plugins.faceantispoofing;
+
+import android.content.Context;
+import android.content.res.AssetFileDescriptor;
+import android.content.res.AssetManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Matrix;
+import android.graphics.Rect;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+
+import io.github.asephermann.plugins.faceantispoofing.mtcnn.Box;
+
+public class MyUtil {
+
+    public static Bitmap readFromAssets(Context context, String filename){
+        Bitmap bitmap;
+        AssetManager asm = context.getAssets();
+        try {
+            InputStream is = asm.open(filename);
+            bitmap = BitmapFactory.decodeStream(is);
+            is.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+        }
+        return bitmap;
+    }
+
+    public static void rectExtend(Bitmap bitmap, Rect rect, int marginX, int marginY) {
+        rect.left = Math.max(0, rect.left - marginX / 2);
+        rect.right = Math.min(bitmap.getWidth() - 1, rect.right + marginX / 2);
+        rect.top = Math.max(0, rect.top - marginY / 2);
+        rect.bottom = Math.min(bitmap.getHeight() - 1, rect.bottom + marginY / 2);
+    }
+
+    public static void rectExtend(Bitmap bitmap, Rect rect) {
+        int width = rect.right - rect.left;
+        int height = rect.bottom - rect.top;
+        int margin = (height - width) / 2;
+        rect.left = Math.max(0, rect.left - margin);
+        rect.right = Math.min(bitmap.getWidth() - 1, rect.right + margin);
+    }
+
+    public static MappedByteBuffer loadModelFile(AssetManager assetManager, String modelPath) throws IOException {
+        AssetFileDescriptor fileDescriptor = assetManager.openFd(modelPath);
+        FileInputStream inputStream = new FileInputStream(fileDescriptor.getFileDescriptor());
+        FileChannel fileChannel = inputStream.getChannel();
+        long startOffset = fileDescriptor.getStartOffset();
+        long declaredLength = fileDescriptor.getDeclaredLength();
+        return fileChannel.map(FileChannel.MapMode.READ_ONLY, startOffset, declaredLength);
+    }
+
+    public static float[][][] normalizeImage(Bitmap bitmap) {
+        int h = bitmap.getHeight();
+        int w = bitmap.getWidth();
+        float[][][] floatValues = new float[h][w][3];
+
+        float imageMean = 127.5f;
+        float imageStd = 128;
+
+        int[] pixels = new int[h * w];
+        bitmap.getPixels(pixels, 0, bitmap.getWidth(), 0, 0, w, h);
+        for (int i = 0; i < h; i++) {
+            for (int j = 0; j < w; j++) {
+                final int val = pixels[i * w + j];
+                float r = (((val >> 16) & 0xFF) - imageMean) / imageStd;
+                float g = (((val >> 8) & 0xFF) - imageMean) / imageStd;
+                float b = ((val & 0xFF) - imageMean) / imageStd;
+                float[] arr = {r, g, b};
+                floatValues[i][j] = arr;
+            }
+        }
+        return floatValues;
+    }
+
+    public static Bitmap bitmapResize(Bitmap bitmap, float scale) {
+        int width = bitmap.getWidth();
+        int height = bitmap.getHeight();
+        Matrix matrix = new Matrix();
+        matrix.postScale(scale, scale);
+        return Bitmap.createBitmap(
+                bitmap, 0, 0, width, height, matrix, true);
+    }
+
+    public static float[][][] transposeImage(float[][][] in) {
+        int h = in.length;
+        int w = in[0].length;
+        int channel = in[0][0].length;
+        float[][][] out = new float[w][h][channel];
+        for (int i = 0; i < h; i++) {
+            for (int j = 0; j < w; j++) {
+                out[j][i] = in[i][j] ;
+            }
+        }
+        return out;
+    }
+
+    public static float[][][][] transposeBatch(float[][][][] in) {
+        int batch = in.length;
+        int h = in[0].length;
+        int w = in[0][0].length;
+        int channel = in[0][0][0].length;
+        float[][][][] out = new float[batch][w][h][channel];
+        for (int i = 0; i < batch; i++) {
+            for (int j = 0; j < h; j++) {
+                for (int k = 0; k < w; k++) {
+                    out[i][k][j] = in[i][j][k] ;
+                }
+            }
+        }
+        return out;
+    }
+
+    public static float[][][] cropAndResize(Bitmap bitmap, Box box, int size) {
+        Matrix matrix = new Matrix();
+        float scaleW = 1.0f * size / box.width();
+        float scaleH = 1.0f * size / box.height();
+        matrix.postScale(scaleW, scaleH);
+        Rect rect = box.transform2Rect();
+        Bitmap croped = Bitmap.createBitmap(
+                bitmap, rect.left, rect.top, box.width(), box.height(), matrix, true);
+
+        return normalizeImage(croped);
+    }
+
+    public static Bitmap crop(Bitmap bitmap, Rect rect) {
+        Bitmap cropped = Bitmap.createBitmap(bitmap, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
+        return cropped;
+    }
+
+    public static void l2Normalize(float[][] embeddings, double epsilon) {
+        for (int i = 0; i < embeddings.length; i++) {
+            float squareSum = 0;
+            for (int j = 0; j < embeddings[i].length; j++) {
+                squareSum += Math.pow(embeddings[i][j], 2);
+            }
+            float xInvNorm = (float) Math.sqrt(Math.max(squareSum, epsilon));
+            for (int j = 0; j < embeddings[i].length; j++) {
+                embeddings[i][j] = embeddings[i][j] / xInvNorm;
+            }
+        }
+    }
+
+    public static int[][] convertGreyImg(Bitmap bitmap) {
+        int w = bitmap.getWidth();
+        int h = bitmap.getHeight();
+
+        int[] pixels = new int[h * w];
+        bitmap.getPixels(pixels, 0, w, 0, 0, w, h);
+
+        int[][] result = new int[h][w];
+        int alpha = 0xFF << 24;
+        for(int i = 0; i < h; i++)	{
+            for(int j = 0; j < w; j++) {
+                int val = pixels[w * i + j];
+
+                int red = ((val >> 16) & 0xFF);
+                int green = ((val >> 8) & 0xFF);
+                int blue = (val & 0xFF);
+
+                int grey = (int)((float) red * 0.3 + (float)green * 0.59 + (float)blue * 0.11);
+                grey = alpha | (grey << 16) | (grey << 8) | grey;
+                result[i][j] = grey;
+            }
+        }
+        return result;
+    }
+}

package/android/src/main/java/io/github/asephermann/plugins/faceantispoofing/mtcnn/Align.java

@@ -0,0 +1,28 @@
+package io.github.asephermann.plugins.faceantispoofing.mtcnn;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.Point;
+
+public class Align {
+    public static Bitmap face_align(Bitmap img, Point[] landmark) {
+        // Calculate the average position of eyes
+        int x_left_eye = landmark[0].x;
+        int y_left_eye = landmark[0].y;
+        int x_right_eye = landmark[1].x;
+        int y_right_eye = landmark[1].y;
+
+        // Calculate the angle between the eyes
+        double dx = x_right_eye - x_left_eye;
+        double dy = y_right_eye - y_left_eye;
+        double angle = Math.toDegrees(Math.atan2(dy, dx));
+
+        // Rotate the image to align the eyes horizontally
+        Matrix matrix = new Matrix();
+        matrix.postRotate((float) -angle, img.getWidth() / 2f, img.getHeight() / 2f);
+        Bitmap rotatedImg = Bitmap.createBitmap(img, 0, 0, img.getWidth(), img.getHeight(), matrix, true);
+
+        return rotatedImg;
+    }
+}

package/android/src/main/java/io/github/asephermann/plugins/faceantispoofing/mtcnn/Box.java

@@ -0,0 +1,73 @@
+package io.github.asephermann.plugins.faceantispoofing.mtcnn;
+
+import android.graphics.Point;
+import android.graphics.Rect;
+
+public class Box {
+    public int[] box = new int[4];
+    public float score;
+    public float[] bbr = new float[4];
+    public boolean deleted = false;
+    public Point[] landmark = new Point[5];
+
+    public int left() {
+        return box[0];
+    }
+
+    public int right() {
+        return box[2];
+    }
+
+    public int top() {
+        return box[1];
+    }
+
+    public int bottom() {
+        return box[3];
+    }
+
+    public int width() {
+        return box[2] - box[0] + 1;
+    }
+
+    public int height() {
+        return box[3] - box[1] + 1;
+    }
+
+    public Rect transform2Rect() {
+        Rect rect = new Rect(box[0], box[1], box[2], box[3]);
+        return rect;
+    }
+
+    public int area() {
+        return width() * height();
+    }
+
+    public void calibrate() {
+        int w = width();
+        int h = height();
+        box[0] = Math.round(box[0] + bbr[0] * w);
+        box[1] = Math.round(box[1] + bbr[1] * h);
+        box[2] = Math.round(box[2] + bbr[2] * w);
+        box[3] = Math.round(box[3] + bbr[3] * h);
+    }
+
+    public void toSquareShape() {
+        int w = width();
+        int h = height();
+        int maxSide = Math.max(w, h);
+        box[2] = box[0] + maxSide - 1;
+        box[3] = box[1] + maxSide - 1;
+    }
+
+    public void limitSquare(int w, int h) {
+        if (box[0] < 0) box[0] = 0;
+        if (box[1] < 0) box[1] = 0;
+        if (box[2] >= w) box[2] = w - 1;
+        if (box[3] >= h) box[3] = h - 1;
+    }
+
+    public boolean transbound(int w, int h) {
+        return box[0] < 0 || box[1] < 0 || box[2] >= w || box[3] >= h;
+    }
+}

package/android/src/main/java/io/github/asephermann/plugins/faceantispoofing/mtcnn/MTCNN.java

@@ -0,0 +1,268 @@
+package io.github.asephermann.plugins.faceantispoofing.mtcnn;
+
+import android.content.res.AssetManager;
+import android.graphics.Bitmap;
+import android.graphics.Point;
+
+import com.google.ai.edge.litert.Interpreter;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Vector;
+
+import io.github.asephermann.plugins.faceantispoofing.MyUtil;
+
+public class MTCNN {
+    private float factor = 0.709f;
+    private float pNetThreshold = 0.6f;
+    private float rNetThreshold = 0.7f;
+    private float oNetThreshold = 0.7f;
+
+    private static final String MODEL_FILE_PNET = "pnet.tflite";
+    private static final String MODEL_FILE_RNET = "rnet.tflite";
+    private static final String MODEL_FILE_ONET = "onet.tflite";
+
+    private Interpreter pInterpreter;
+    private Interpreter rInterpreter;
+    private Interpreter oInterpreter;
+
+    public MTCNN(AssetManager assetManager) throws IOException {
+        Interpreter.Options options = new Interpreter.Options();
+        options.setNumThreads(4);
+        pInterpreter = new Interpreter(MyUtil.loadModelFile(assetManager, MODEL_FILE_PNET), options);
+        rInterpreter = new Interpreter(MyUtil.loadModelFile(assetManager, MODEL_FILE_RNET), options);
+        oInterpreter = new Interpreter(MyUtil.loadModelFile(assetManager, MODEL_FILE_ONET), options);
+    }
+
+    public Vector<Box> detectFaces(Bitmap bitmap, int minFaceSize) {
+        Vector<Box> boxes;
+        try {
+            boxes = pNet(bitmap, minFaceSize);
+            square_limit(boxes, bitmap.getWidth(), bitmap.getHeight());
+
+            boxes = rNet(bitmap, boxes);
+            square_limit(boxes, bitmap.getWidth(), bitmap.getHeight());
+
+            boxes = oNet(bitmap, boxes);
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+            boxes = new Vector<>();
+        }
+        return boxes;
+    }
+
+    private void square_limit(Vector<Box> boxes, int w, int h) {
+        for (int i = 0; i < boxes.size(); i++) {
+            boxes.get(i).toSquareShape();
+            boxes.get(i).limitSquare(w, h);
+        }
+    }
+
+    private Vector<Box> pNet(Bitmap bitmap, int minSize) {
+        int whMin = Math.min(bitmap.getWidth(), bitmap.getHeight());
+        float currentFaceSize = minSize;
+        Vector<Box> totalBoxes = new Vector<>();
+
+        while (currentFaceSize <= whMin) {
+            float scale = 12.0f / currentFaceSize;
+
+            Bitmap bm = MyUtil.bitmapResize(bitmap, scale);
+            int w = bm.getWidth();
+            int h = bm.getHeight();
+
+            int outW = (int) (Math.ceil(w * 0.5 - 5) + 0.5);
+            int outH = (int) (Math.ceil(h * 0.5 - 5) + 0.5);
+            float[][][][] prob1 = new float[1][outW][outH][2];
+            float[][][][] conv4_2_BiasAdd = new float[1][outW][outH][4];
+            pNetForward(bm, prob1, conv4_2_BiasAdd);
+            prob1 = MyUtil.transposeBatch(prob1);
+            conv4_2_BiasAdd = MyUtil.transposeBatch(conv4_2_BiasAdd);
+
+            Vector<Box> curBoxes = new Vector<>();
+            generateBoxes(prob1, conv4_2_BiasAdd, scale, curBoxes);
+
+            nms(curBoxes, 0.5f, "Union");
+
+            for (int i = 0; i < curBoxes.size(); i++)
+                if (!curBoxes.get(i).deleted)
+                    totalBoxes.addElement(curBoxes.get(i));
+
+            currentFaceSize /= factor;
+        }
+
+        nms(totalBoxes, 0.7f, "Union");
+
+        BoundingBoxReggression(totalBoxes);
+
+        return updateBoxes(totalBoxes);
+    }
+
+    private void pNetForward(Bitmap bitmap, float[][][][] prob1, float[][][][] conv4_2_BiasAdd) {
+        float[][][] img = MyUtil.normalizeImage(bitmap);
+        float[][][][] pNetIn = new float[1][][][];
+        pNetIn[0] = img;
+        pNetIn = MyUtil.transposeBatch(pNetIn);
+
+        Map<Integer, Object> outputs = new HashMap<>();
+        outputs.put(pInterpreter.getOutputIndex("pnet/prob1"), prob1);
+        outputs.put(pInterpreter.getOutputIndex("pnet/conv4-2/BiasAdd"), conv4_2_BiasAdd);
+
+        pInterpreter.runForMultipleInputsOutputs(new Object[]{pNetIn}, outputs);
+    }
+
+    private int generateBoxes(float[][][][] prob1, float[][][][] conv4_2_BiasAdd, float scale, Vector<Box> boxes) {
+        int h = prob1[0].length;
+        int w = prob1[0][0].length;
+
+        for (int y = 0; y < h; y++) {
+            for (int x = 0; x < w; x++) {
+                float score = prob1[0][y][x][1];
+                if (score > pNetThreshold) {
+                    Box box = new Box();
+                    box.score = score;
+                    box.box[0] = Math.round(x * 2 / scale);
+                    box.box[1] = Math.round(y * 2 / scale);
+                    box.box[2] = Math.round((x * 2 + 11) / scale);
+                    box.box[3] = Math.round((y * 2 + 11) / scale);
+                    for (int i = 0; i < 4; i++) {
+                        box.bbr[i] = conv4_2_BiasAdd[0][y][x][i];
+                    }
+                    boxes.addElement(box);
+                }
+            }
+        }
+        return 0;
+    }
+
+    private void nms(Vector<Box> boxes, float threshold, String method) {
+        for (int i = 0; i < boxes.size(); i++) {
+            Box box = boxes.get(i);
+            if (!box.deleted) {
+                for (int j = i + 1; j < boxes.size(); j++) {
+                    Box box2 = boxes.get(j);
+                    if (!box2.deleted) {
+                        int x1 = Math.max(box.box[0], box2.box[0]);
+                        int y1 = Math.max(box.box[1], box2.box[1]);
+                        int x2 = Math.min(box.box[2], box2.box[2]);
+                        int y2 = Math.min(box.box[3], box2.box[3]);
+                        if (x2 < x1 || y2 < y1) continue;
+                        int areaIoU = (x2 - x1 + 1) * (y2 - y1 + 1);
+                        float iou = 0f;
+                        if (method.equals("Union"))
+                            iou = 1.0f * areaIoU / (box.area() + box2.area() - areaIoU);
+                        else if (method.equals("Min"))
+                            iou = 1.0f * areaIoU / (Math.min(box.area(), box2.area()));
+                        if (iou >= threshold) {
+                            if (box.score > box2.score)
+                                box2.deleted = true;
+                            else
+                                box.deleted = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private void BoundingBoxReggression(Vector<Box> boxes) {
+        for (int i = 0; i < boxes.size(); i++)
+            boxes.get(i).calibrate();
+    }
+
+    private Vector<Box> rNet(Bitmap bitmap, Vector<Box> boxes) {
+        int num = boxes.size();
+        float[][][][] rNetIn = new float[num][24][24][3];
+        for (int i = 0; i < num; i++) {
+            float[][][] curCrop = MyUtil.cropAndResize(bitmap, boxes.get(i), 24);
+            curCrop = MyUtil.transposeImage(curCrop);
+            rNetIn[i] = curCrop;
+        }
+
+        rNetForward(rNetIn, boxes);
+
+        for (int i = 0; i < num; i++) {
+            if (boxes.get(i).score < rNetThreshold) {
+                boxes.get(i).deleted = true;
+            }
+        }
+
+        nms(boxes, 0.7f, "Union");
+        BoundingBoxReggression(boxes);
+        return updateBoxes(boxes);
+    }
+
+    private void rNetForward(float[][][][] rNetIn, Vector<Box> boxes) {
+        int num = rNetIn.length;
+        float[][] prob1 = new float[num][2];
+        float[][] conv5_2_conv5_2 = new float[num][4];
+
+        Map<Integer, Object> outputs = new HashMap<>();
+        outputs.put(rInterpreter.getOutputIndex("rnet/prob1"), prob1);
+        outputs.put(rInterpreter.getOutputIndex("rnet/conv5-2/conv5-2"), conv5_2_conv5_2);
+        rInterpreter.runForMultipleInputsOutputs(new Object[]{rNetIn}, outputs);
+
+        for (int i = 0; i < num; i++) {
+            boxes.get(i).score = prob1[i][1];
+            for (int j = 0; j < 4; j++) {
+                boxes.get(i).bbr[j] = conv5_2_conv5_2[i][j];
+            }
+        }
+    }
+
+    private Vector<Box> oNet(Bitmap bitmap, Vector<Box> boxes) {
+        int num = boxes.size();
+        float[][][][] oNetIn = new float[num][48][48][3];
+        for (int i = 0; i < num; i++) {
+            float[][][] curCrop = MyUtil.cropAndResize(bitmap, boxes.get(i), 48);
+            curCrop = MyUtil.transposeImage(curCrop);
+            oNetIn[i] = curCrop;
+        }
+
+        oNetForward(oNetIn, boxes);
+
+        for (int i = 0; i < num; i++) {
+            if (boxes.get(i).score < oNetThreshold) {
+                boxes.get(i).deleted = true;
+            }
+        }
+        BoundingBoxReggression(boxes);
+        nms(boxes, 0.7f, "Min");
+        return updateBoxes(boxes);
+    }
+
+    private void oNetForward(float[][][][] oNetIn, Vector<Box> boxes) {
+        int num = oNetIn.length;
+        float[][] prob1 = new float[num][2];
+        float[][] conv6_2_conv6_2 = new float[num][4];
+        float[][] conv6_3_conv6_3 = new float[num][10];
+
+        Map<Integer, Object> outputs = new HashMap<>();
+        outputs.put(oInterpreter.getOutputIndex("onet/prob1"), prob1);
+        outputs.put(oInterpreter.getOutputIndex("onet/conv6-2/conv6-2"), conv6_2_conv6_2);
+        outputs.put(oInterpreter.getOutputIndex("onet/conv6-3/conv6-3"), conv6_3_conv6_3);
+        oInterpreter.runForMultipleInputsOutputs(new Object[]{oNetIn}, outputs);
+
+        for (int i = 0; i < num; i++) {
+            boxes.get(i).score = prob1[i][1];
+            for (int j = 0; j < 4; j++) {
+                boxes.get(i).bbr[j] = conv6_2_conv6_2[i][j];
+            }
+            for (int j = 0; j < 5; j++) {
+                int x = Math.round(boxes.get(i).left() + (conv6_3_conv6_3[i][j] * boxes.get(i).width()));
+                int y = Math.round(boxes.get(i).top() + (conv6_3_conv6_3[i][j + 5] * boxes.get(i).height()));
+                boxes.get(i).landmark[j] = new Point(x, y);
+            }
+        }
+    }
+
+    public static Vector<Box> updateBoxes(Vector<Box> boxes) {
+        Vector<Box> b = new Vector<>();
+        for (int i = 0; i < boxes.size(); i++) {
+            if (!boxes.get(i).deleted) {
+                b.addElement(boxes.get(i));
+            }
+        }
+        return b;
+    }
+}

package/android/src/main/java/io/github/asephermann/plugins/faceantispoofing/mtcnn/Utils.java

@@ -0,0 +1,25 @@
+package io.github.asephermann.plugins.faceantispoofing.mtcnn;
+
+import android.graphics.Bitmap;
+
+public class Utils {
+    public static float[][][] cropAndResize(Bitmap bitmap, Box box, int size) {
+        return io.github.asephermann.plugins.faceantispoofing.MyUtil.cropAndResize(bitmap, box, size);
+    }
+
+    public static float[][][] transposeImage(float[][][] in) {
+        return io.github.asephermann.plugins.faceantispoofing.MyUtil.transposeImage(in);
+    }
+
+    public static float[][][][] transposeBatch(float[][][][] in) {
+        return io.github.asephermann.plugins.faceantispoofing.MyUtil.transposeBatch(in);
+    }
+
+    public static float[][][] normalizeImage(Bitmap bitmap) {
+        return io.github.asephermann.plugins.faceantispoofing.MyUtil.normalizeImage(bitmap);
+    }
+
+    public static Bitmap bitmapResize(Bitmap bitmap, float scale) {
+        return io.github.asephermann.plugins.faceantispoofing.MyUtil.bitmapResize(bitmap, scale);
+    }
+}

package/dist/docs.json

@@ -0,0 +1,104 @@
+{
+  "api": {
+    "name": "FaceAntiSpoofingPlugin",
+    "slug": "faceantispoofingplugin",
+    "docs": "",
+    "tags": [],
+    "methods": [
+      {
+        "name": "detect",
+        "signature": "(options: DetectOptions) => Promise<DetectionResult>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "Image data as base64 string or file URI",
+            "type": "DetectOptions"
+          }
+        ],
+        "returns": "Promise<DetectionResult>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "options Image data as base64 string or file URI"
+          },
+          {
+            "name": "returns",
+            "text": "Promise with detection result containing liveness status"
+          }
+        ],
+        "docs": "Detect face liveness and anti-spoofing",
+        "complexTypes": [
+          "DetectionResult",
+          "DetectOptions"
+        ],
+        "slug": "detect"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "DetectionResult",
+      "slug": "detectionresult",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "error",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "boolean"
+        },
+        {
+          "name": "liveness",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "boolean"
+        },
+        {
+          "name": "score",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "threshold",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "message",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        }
+      ]
+    },
+    {
+      "name": "DetectOptions",
+      "slug": "detectoptions",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "image",
+          "tags": [],
+          "docs": "Base64 encoded image data (without data:image/...;base64, prefix)\nor file URI to the image",
+          "complexTypes": [],
+          "type": "string"
+        }
+      ]
+    }
+  ],
+  "enums": [],
+  "typeAliases": [],
+  "pluginConfigs": []
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,22 @@
+export interface DetectionResult {
+    error: boolean;
+    liveness: boolean;
+    score: string;
+    threshold: string;
+    message: string;
+}
+export interface DetectOptions {
+    /**
+     * Base64 encoded image data (without data:image/...;base64, prefix)
+     * or file URI to the image
+     */
+    image: string;
+}
+export interface FaceAntiSpoofingPlugin {
+    /**
+     * Detect face liveness and anti-spoofing
+     * @param options Image data as base64 string or file URI
+     * @returns Promise with detection result containing liveness status
+     */
+    detect(options: DetectOptions): Promise<DetectionResult>;
+}