diff --git a/ffigen.yaml b/ffigen.yaml
index 0fc4ad90..b891e2e9 100644
--- a/ffigen.yaml
+++ b/ffigen.yaml
@@ -28,8 +28,11 @@ headers:
     - src/dnn/dnn.h
     - src/dnn/dnn_async.h
     - src/extra/aruco.h
+    - src/extra/aruco_async.h
     - src/extra/img_hash.h
+    - src/extra/img_hash_async.h
     - src/extra/wechat_qrcode.h
+    - src/extra/wechat_qrcode_async.h
     - src/features2d/features2d.h
     - src/features2d/features2d_async.h
     - src/gapi/gapi.h
@@ -62,8 +65,11 @@ headers:
     - src/dnn/dnn.h
     - src/dnn/dnn_async.h
     - src/extra/aruco.h
+    - src/extra/aruco_async.h
     - src/extra/img_hash.h
+    - src/extra/img_hash_async.h
     - src/extra/wechat_qrcode.h
+    - src/extra/wechat_qrcode_async.h
     - src/features2d/features2d.h
     - src/features2d/features2d_async.h
     - src/gapi/gapi.h
diff --git a/lib/opencv_dart.dart b/lib/opencv_dart.dart
index 2de504ac..4902a354 100644
--- a/lib/opencv_dart.dart
+++ b/lib/opencv_dart.dart
@@ -4,10 +4,14 @@ export 'src/calib3d/calib3d.dart';
 export 'src/calib3d/calib3d_async.dart';
 export 'src/calib3d/fisheye.dart';
 export 'src/constants.g.dart';
+
 export 'src/contrib/aruco.dart';
+export 'src/contrib/aruco_async.dart';
 export 'src/contrib/aruco_dict.dart';
 export 'src/contrib/img_hash.dart';
 export 'src/contrib/wechat_qrcode.dart';
+export 'src/contrib/wechat_qrcode_async.dart';
+
 export 'src/core/array.dart';
 export 'src/core/asyncarray.dart';
 export 'src/core/base.dart';
diff --git a/lib/src/contrib/aruco.dart b/lib/src/contrib/aruco.dart
index e5ed1931..34af483f 100644
--- a/lib/src/contrib/aruco.dart
+++ b/lib/src/contrib/aruco.dart
@@ -18,6 +18,11 @@ class ArucoDetector extends CvStruct<cvg.ArucoDetector> {
       finalizer.attach(this, ptr.cast(), detach: this);
     }
   }
+  factory ArucoDetector.fromPointer(
+    cvg.ArucoDetectorPtr ptr, [
+    bool attach = true,
+  ]) =>
+      ArucoDetector._(ptr, attach);
 
   factory ArucoDetector.empty() {
     final p = calloc<cvg.ArucoDetector>();
@@ -25,9 +30,14 @@ class ArucoDetector extends CvStruct<cvg.ArucoDetector> {
     return ArucoDetector._(p);
   }
 
-  factory ArucoDetector.create(ArucoDictionary dictionary, ArucoDetectorParameters parameters) {
+  factory ArucoDetector.create(
+    ArucoDictionary dictionary,
+    ArucoDetectorParameters parameters,
+  ) {
     final p = calloc<cvg.ArucoDetector>();
-    cvRun(() => CFFI.ArucoDetector_NewWithParams(dictionary.ref, parameters.ref, p));
+    cvRun(
+      () => CFFI.ArucoDetector_NewWithParams(dictionary.ref, parameters.ref, p),
+    );
     return ArucoDetector._(p);
   }
 
@@ -49,7 +59,15 @@ class ArucoDetector extends CvStruct<cvg.ArucoDetector> {
       final pCorners = calloc<cvg.VecVecPoint2f>();
       final pRejected = calloc<cvg.VecVecPoint2f>();
       final pIds = calloc<cvg.VecInt>();
-      cvRun(() => CFFI.ArucoDetector_DetectMarkers(ref, image.ref, pCorners, pIds, pRejected));
+      cvRun(
+        () => CFFI.ArucoDetector_DetectMarkers(
+          ref,
+          image.ref,
+          pCorners,
+          pIds,
+          pRejected,
+        ),
+      );
       return (
         VecVecPoint2f.fromVec(pCorners.ref),
         VecInt.fromVec(pIds.ref),
@@ -62,27 +80,56 @@ class ArucoDetector extends CvStruct<cvg.ArucoDetector> {
   List<int> get props => [ptr.address];
 }
 
-void arucoDrawDetectedMarkers(Mat img, VecVecPoint2f markerCorners, VecInt markerIds, Scalar borderColor) {
-  cvRun(() => CFFI.ArucoDrawDetectedMarkers(img.ref, markerCorners.ref, markerIds.ref, borderColor.ref));
+void arucoDrawDetectedMarkers(
+  Mat img,
+  VecVecPoint2f markerCorners,
+  VecInt markerIds,
+  Scalar borderColor,
+) {
+  cvRun(
+    () => CFFI.ArucoDrawDetectedMarkers(
+      img.ref,
+      markerCorners.ref,
+      markerIds.ref,
+      borderColor.ref,
+    ),
+  );
 }
 
-void arucoGenerateImageMarker(
+Mat arucoGenerateImageMarker(
   PredefinedDictionaryType dictionaryId,
   int id,
   int sidePixels,
-  Mat img,
-  int borderBits,
-) {
-  cvRun(() => CFFI.ArucoGenerateImageMarker(dictionaryId.value, id, sidePixels, img.ref, borderBits));
+  int borderBits, [
+  Mat? outImg,
+]) {
+  final p = outImg?.ptr ?? calloc<cvg.Mat>();
+  cvRun(
+    () => CFFI.ArucoGenerateImageMarker(
+      dictionaryId.value,
+      id,
+      sidePixels,
+      borderBits,
+      p,
+    ),
+  );
+  return outImg ?? Mat.fromPointer(p);
 }
 
 class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
-  ArucoDetectorParameters._(cvg.ArucoDetectorParametersPtr ptr, [bool attach = true])
-      : super.fromPointer(ptr) {
+  ArucoDetectorParameters._(
+    cvg.ArucoDetectorParametersPtr ptr, [
+    bool attach = true,
+  ]) : super.fromPointer(ptr) {
     if (attach) {
       finalizer.attach(this, ptr.cast(), detach: this);
     }
   }
+  factory ArucoDetectorParameters.fromPointer(
+    cvg.ArucoDetectorParametersPtr ptr, [
+    bool attach = true,
+  ]) =>
+      ArucoDetectorParameters._(ptr, attach);
 
   factory ArucoDetectorParameters.empty() {
     final p = calloc<cvg.ArucoDetectorParameters>();
@@ -92,8 +139,9 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
 
   @override
   cvg.ArucoDetectorParameters get ref => ptr.ref;
-  static final finalizer =
-      OcvFinalizer<cvg.ArucoDetectorParametersPtr>(CFFI.addresses.ArucoDetectorParameters_Close);
+  static final finalizer = OcvFinalizer<cvg.ArucoDetectorParametersPtr>(
+    CFFI.addresses.ArucoDetectorParameters_Close,
+  );
 
   void dispose() {
     finalizer.detach(this);
@@ -103,51 +151,65 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   int get adaptiveThreshWinSizeMin {
     return cvRunArena<int>((arena) {
       final p = arena<ffi.Int>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetAdaptiveThreshWinSizeMin(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetAdaptiveThreshWinSizeMin(ref, p),
+      );
       return p.value;
     });
   }
 
-  set adaptiveThreshWinSizeMin(int value) =>
-      cvRun(() => CFFI.ArucoDetectorParameters_SetAdaptiveThreshWinSizeMin(ref, value));
+  set adaptiveThreshWinSizeMin(int value) => cvRun(
+        () => CFFI.ArucoDetectorParameters_SetAdaptiveThreshWinSizeMin(ref, value),
+      );
 
   int get adaptiveThreshWinSizeMax {
     return cvRunArena<int>((arena) {
       final p = arena<ffi.Int>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetAdaptiveThreshWinSizeMax(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetAdaptiveThreshWinSizeMax(ref, p),
+      );
       return p.value;
     });
   }
 
-  set adaptiveThreshWinSizeMax(int value) =>
-      cvRun(() => CFFI.ArucoDetectorParameters_SetAdaptiveThreshWinSizeMax(ref, value));
+  set adaptiveThreshWinSizeMax(int value) => cvRun(
+        () => CFFI.ArucoDetectorParameters_SetAdaptiveThreshWinSizeMax(ref, value),
+      );
 
   int get adaptiveThreshWinSizeStep {
     return cvRunArena<int>((arena) {
       final p = arena<ffi.Int>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetAdaptiveThreshWinSizeStep(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetAdaptiveThreshWinSizeStep(ref, p),
+      );
       return p.value;
     });
   }
 
-  set adaptiveThreshWinSizeStep(int value) =>
-      cvRun(() => CFFI.ArucoDetectorParameters_SetAdaptiveThreshWinSizeStep(ref, value));
+  set adaptiveThreshWinSizeStep(int value) => cvRun(
+        () => CFFI.ArucoDetectorParameters_SetAdaptiveThreshWinSizeStep(ref, value),
+      );
 
   double get adaptiveThreshConstant {
     return cvRunArena<double>((arena) {
       final p = arena<ffi.Double>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetAdaptiveThreshConstant(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetAdaptiveThreshConstant(ref, p),
+      );
       return p.value;
     });
   }
 
-  set adaptiveThreshConstant(double value) =>
-      cvRun(() => CFFI.ArucoDetectorParameters_SetAdaptiveThreshConstant(ref, value));
+  set adaptiveThreshConstant(double value) => cvRun(
+        () => CFFI.ArucoDetectorParameters_SetAdaptiveThreshConstant(ref, value),
+      );
 
   double get minMarkerPerimeterRate {
     return cvRunArena<double>((arena) {
       final p = arena<ffi.Double>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetMinMarkerPerimeterRate(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetMinMarkerPerimeterRate(ref, p),
+      );
       return p.value;
     });
   }
@@ -158,7 +220,9 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   double get maxMarkerPerimeterRate {
     return cvRunArena<double>((arena) {
       final p = arena<ffi.Double>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetMaxMarkerPerimeterRate(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetMaxMarkerPerimeterRate(ref, p),
+      );
       return p.value;
     });
   }
@@ -169,7 +233,9 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   double get polygonalApproxAccuracyRate {
     return cvRunArena<double>((arena) {
       final p = arena<ffi.Double>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetPolygonalApproxAccuracyRate(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetPolygonalApproxAccuracyRate(ref, p),
+      );
       return p.value;
     });
   }
@@ -180,7 +246,9 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   double get minCornerDistanceRate {
     return cvRunArena<double>((arena) {
       final p = arena<ffi.Double>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetMinCornerDistanceRate(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetMinCornerDistanceRate(ref, p),
+      );
       return p.value;
     });
   }
@@ -201,7 +269,9 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   double get minMarkerDistanceRate {
     return cvRunArena<double>((arena) {
       final p = arena<ffi.Double>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetMinMarkerDistanceRate(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetMinMarkerDistanceRate(ref, p),
+      );
       return p.value;
     });
   }
@@ -212,7 +282,9 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   int get cornerRefinementMethod {
     return cvRunArena<int>((arena) {
       final p = arena<ffi.Int>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetCornerRefinementMethod(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetCornerRefinementMethod(ref, p),
+      );
       return p.value;
     });
   }
@@ -222,7 +294,9 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   int get cornerRefinementWinSize {
     return cvRunArena<int>((arena) {
       final p = arena<ffi.Int>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetCornerRefinementWinSize(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetCornerRefinementWinSize(ref, p),
+      );
       return p.value;
     });
   }
@@ -233,7 +307,12 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   int get cornerRefinementMaxIterations {
     return cvRunArena<int>((arena) {
       final p = arena<ffi.Int>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetCornerRefinementMaxIterations(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetCornerRefinementMaxIterations(
+          ref,
+          p,
+        ),
+      );
       return p.value;
     });
   }
@@ -244,7 +323,9 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   double get cornerRefinementMinAccuracy {
     return cvRunArena<double>((arena) {
       final p = arena<ffi.Double>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetCornerRefinementMinAccuracy(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetCornerRefinementMinAccuracy(ref, p),
+      );
       return p.value;
     });
   }
@@ -265,7 +346,12 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   int get perspectiveRemovePixelPerCell {
     return cvRunArena<int>((arena) {
       final p = arena<ffi.Int>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetPerspectiveRemovePixelPerCell(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetPerspectiveRemovePixelPerCell(
+          ref,
+          p,
+        ),
+      );
       return p.value;
     });
   }
@@ -276,18 +362,28 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   double get perspectiveRemoveIgnoredMarginPerCell {
     return cvRunArena<double>((arena) {
       final p = arena<ffi.Double>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetPerspectiveRemoveIgnoredMarginPerCell(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetPerspectiveRemoveIgnoredMarginPerCell(
+          ref,
+          p,
+        ),
+      );
       return p.value;
     });
   }
 
   set perspectiveRemoveIgnoredMarginPerCell(double value) =>
-      CFFI.ArucoDetectorParameters_SetPerspectiveRemoveIgnoredMarginPerCell(ref, value);
+      CFFI.ArucoDetectorParameters_SetPerspectiveRemoveIgnoredMarginPerCell(
+        ref,
+        value,
+      );
 
   double get maxErroneousBitsInBorderRate {
     return cvRunArena<double>((arena) {
       final p = arena<ffi.Double>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetMaxErroneousBitsInBorderRate(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetMaxErroneousBitsInBorderRate(ref, p),
+      );
       return p.value;
     });
   }
@@ -338,7 +434,9 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   int get aprilTagMinClusterPixels {
     return cvRunArena<int>((arena) {
       final p = arena<ffi.Int>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetAprilTagMinClusterPixels(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetAprilTagMinClusterPixels(ref, p),
+      );
       return p.value;
     });
   }
@@ -369,24 +467,30 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
   double get aprilTagMaxLineFitMse {
     return cvRunArena<double>((arena) {
       final p = arena<ffi.Float>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetAprilTagMaxLineFitMse(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetAprilTagMaxLineFitMse(ref, p),
+      );
       return p.value;
     });
   }
 
-  set aprilTagMaxLineFitMse(double value) =>
-      cvRun(() => CFFI.ArucoDetectorParameters_SetAprilTagMaxLineFitMse(ref, value));
+  set aprilTagMaxLineFitMse(double value) => cvRun(
+        () => CFFI.ArucoDetectorParameters_SetAprilTagMaxLineFitMse(ref, value),
+      );
 
   int get aprilTagMinWhiteBlackDiff {
     return cvRunArena<int>((arena) {
       final p = arena<ffi.Int>();
-      cvRun(() => CFFI.ArucoDetectorParameters_GetAprilTagMinWhiteBlackDiff(ref, p));
+      cvRun(
+        () => CFFI.ArucoDetectorParameters_GetAprilTagMinWhiteBlackDiff(ref, p),
+      );
       return p.value;
     });
   }
 
-  set aprilTagMinWhiteBlackDiff(int value) =>
-      cvRun(() => CFFI.ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiff(ref, value));
+  set aprilTagMinWhiteBlackDiff(int value) => cvRun(
+        () => CFFI.ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiff(ref, value),
+      );
 
   int get aprilTagDeglitch {
     return cvRunArena<int>((arena) {
@@ -407,8 +511,9 @@ class ArucoDetectorParameters extends CvStruct<cvg.ArucoDetectorParameters> {
     });
   }
 
-  set detectInvertedMarker(bool value) =>
-      cvRun(() => CFFI.ArucoDetectorParameters_SetDetectInvertedMarker(ref, value));
+  set detectInvertedMarker(bool value) => cvRun(
+        () => CFFI.ArucoDetectorParameters_SetDetectInvertedMarker(ref, value),
+      );
 
   @override
   List<int> get props => [ptr.address];
diff --git a/lib/src/contrib/aruco_async.dart b/lib/src/contrib/aruco_async.dart
new file mode 100644
index 00000000..3272df64
--- /dev/null
+++ b/lib/src/contrib/aruco_async.dart
@@ -0,0 +1,75 @@
+library cv;
+
+import '../core/base.dart';
+import '../core/mat.dart';
+import '../core/point.dart';
+import '../core/scalar.dart';
+import '../core/vec.dart';
+import '../opencv.g.dart' as cvg;
+import 'aruco.dart';
+import 'aruco_dict.dart';
+
+extension ArucoDetectorAsync on ArucoDetector {
+  static Future<ArucoDetector> emptyAsync() async => cvRunAsync<ArucoDetector>(
+        CFFI.ArucoDetector_New_Async,
+        (c, p) => c.complete(ArucoDetector.fromPointer(p.cast<cvg.ArucoDetector>())),
+      );
+
+  static Future<ArucoDetector> createAsync(
+    ArucoDictionary dictionary,
+    ArucoDetectorParameters parameters,
+  ) async =>
+      cvRunAsync<ArucoDetector>(
+        (callback) => CFFI.ArucoDetector_NewWithParams_Async(
+          dictionary.ref,
+          parameters.ref,
+          callback,
+        ),
+        (c, p) => c.complete(ArucoDetector.fromPointer(p.cast<cvg.ArucoDetector>())),
+      );
+
+  Future<(VecVecPoint2f, VecInt, VecVecPoint2f)> detectMarkersAsync(
+    InputArray image,
+  ) async =>
+      cvRunAsync3<(VecVecPoint2f, VecInt, VecVecPoint2f)>(
+          (callback) => CFFI.ArucoDetector_DetectMarkers_Async(ref, image.ref, callback), (c, p, p2, p3) {
+        final corners = VecVecPoint2f.fromPointer(p.cast<cvg.VecVecPoint2f>());
+        final ids = VecInt.fromPointer(p2.cast<cvg.VecInt>());
+        final rejected = VecVecPoint2f.fromPointer(p3.cast<cvg.VecVecPoint2f>());
+        return c.complete((corners, ids, rejected));
+      });
+}
+
+Future<void> arucoDrawDetectedMarkersAsync(
+  Mat img,
+  VecVecPoint2f markerCorners,
+  VecInt markerIds,
+  Scalar borderColor,
+) async =>
+    cvRunAsync0<void>(
+      (callback) => CFFI.ArucoDrawDetectedMarkers_Async(
+        img.ref,
+        markerCorners.ref,
+        markerIds.ref,
+        borderColor.ref,
+        callback,
+      ),
+      (c) => c.complete(),
+    );
+
+Future<Mat> arucoGenerateImageMarkerAsync(
+  PredefinedDictionaryType dictionaryId,
+  int id,
+  int sidePixels,
+  int borderBits,
+) async =>
+    cvRunAsync<Mat>(
+      (callback) => CFFI.ArucoGenerateImageMarker_Async(
+        dictionaryId.value,
+        id,
+        sidePixels,
+        borderBits,
+        callback,
+      ),
+      matCompleter,
+    );
diff --git a/lib/src/contrib/img_hash.dart b/lib/src/contrib/img_hash.dart
index ad22a6e0..ef0d13c4 100644
--- a/lib/src/contrib/img_hash.dart
+++ b/lib/src/contrib/img_hash.dart
@@ -8,11 +8,14 @@ import 'package:ffi/ffi.dart';
 
 import '../core/base.dart';
 import '../core/mat.dart';
+import '../core/vec.dart';
 import '../opencv.g.dart' as cvg;
 
 abstract class ImgHashBase {
   double compare(InputArray hashOne, InputArray hashTwo);
-  void compute(InputArray inputArr, OutputArray outputArr);
+  Mat compute(InputArray inputArr, [OutputArray? outputArr]);
+  Future<double> compareAsync(InputArray hashOne, InputArray hashTwo);
+  Future<Mat> computeAsync(InputArray inputArr);
 }
 
 /// PHash is implementation of the PHash algorithm.
@@ -35,9 +38,23 @@ class PHash implements ImgHashBase {
   /// For further information, see:
   /// https://docs.opencv.org/master/de/d29/classcv_1_1img__hash_1_1ImgHashBase.html#ae2d9288db370089dfd8aab85d5e0b0f3
   @override
-  void compute(InputArray inputArr, OutputArray outputArr) {
-    cvRun(() => CFFI.pHashCompute(inputArr.ref, outputArr.ref));
+  Mat compute(InputArray inputArr, [OutputArray? outputArr]) {
+    final p = outputArr?.ptr ?? calloc<cvg.Mat>();
+    cvRun(() => CFFI.pHashCompute(inputArr.ref, p));
+    return outputArr ?? Mat.fromPointer(p);
   }
+
+  @override
+  Future<double> compareAsync(InputArray hashOne, InputArray hashTwo) async => cvRunAsync<double>(
+        (callback) => CFFI.pHashCompare_Async(hashOne.ref, hashTwo.ref, callback),
+        doubleCompleter,
+      );
+
+  @override
+  Future<Mat> computeAsync(InputArray inputArr) async => cvRunAsync<Mat>(
+        (callback) => CFFI.pHashCompute_Async(inputArr.ref, callback),
+        matCompleter,
+      );
 }
 
 /// AverageHash is implementation of the AverageHash algorithm.
@@ -60,9 +77,26 @@ class AverageHash implements ImgHashBase {
   /// For further information, see:
   /// https://docs.opencv.org/master/de/d29/classcv_1_1img__hash_1_1ImgHashBase.html#ae2d9288db370089dfd8aab85d5e0b0f3
   @override
-  void compute(InputArray inputArr, OutputArray outputArr) {
-    cvRun(() => CFFI.averageHashCompute(inputArr.ref, outputArr.ref));
+  Mat compute(InputArray inputArr, [OutputArray? outputArr]) {
+    final p = outputArr?.ptr ?? calloc<cvg.Mat>();
+    cvRun(() => CFFI.averageHashCompute(inputArr.ref, p));
+    return outputArr ?? Mat.fromPointer(p);
   }
+
+  @override
+  Future<double> compareAsync(InputArray hashOne, InputArray hashTwo) async => cvRunAsync<double>(
+        (callback) => CFFI.averageHashCompare_Async(hashOne.ref, hashTwo.ref, callback),
+        doubleCompleter,
+      );
+
+  @override
+  Future<Mat> computeAsync(InputArray inputArr) async => cvRunAsync<Mat>(
+        (callback) => CFFI.averageHashCompute_Async(
+          inputArr.ref,
+          callback,
+        ),
+        matCompleter,
+      );
 }
 
 /// !< use fewer block and generate 16*16/8 uchar hash value
@@ -107,8 +141,7 @@ class BlockMeanHash extends CvStruct<cvg.BlockMeanHash> implements ImgHashBase {
   /// For further information, see:
   /// https://docs.opencv.org/master/de/d29/classcv_1_1img__hash_1_1ImgHashBase.html#a444a3e9ec792cf029385809393f84ad5
   @override
-  double compare(InputArray hashOne, InputArray hashTwo, [int? mode_]) {
-    mode_ ??= mode;
+  double compare(InputArray hashOne, InputArray hashTwo) {
     return using<double>((arena) {
       final p = arena<ffi.Double>();
       cvRun(() => CFFI.BlockMeanHash_Compare(ref, hashOne.ref, hashTwo.ref, p));
@@ -120,7 +153,11 @@ class BlockMeanHash extends CvStruct<cvg.BlockMeanHash> implements ImgHashBase {
   ///
   /// For further information, see:
   /// https://docs.opencv.org/master/de/d29/classcv_1_1img__hash_1_1ImgHashBase.html#a444a3e9ec792cf029385809393f84ad5
-  static double compareS(InputArray hashOne, InputArray hashTwo, [int mode = 0]) {
+  static double compareS(
+    InputArray hashOne,
+    InputArray hashTwo, [
+    int mode = 0,
+  ]) {
     return using<double>((arena) {
       final p = arena<ffi.Double>();
       cvRun(() => CFFI.blockMeanHashCompare(hashOne.ref, hashTwo.ref, mode, p));
@@ -133,17 +170,20 @@ class BlockMeanHash extends CvStruct<cvg.BlockMeanHash> implements ImgHashBase {
   /// For further information, see:
   /// https://docs.opencv.org/master/de/d29/classcv_1_1img__hash_1_1ImgHashBase.html#ae2d9288db370089dfd8aab85d5e0b0f3
   @override
-  void compute(InputArray inputArr, OutputArray outputArr, [int? mode_]) {
-    mode_ ??= mode;
-    cvRun(() => CFFI.BlockMeanHash_Compute(ref, inputArr.ref, outputArr.ref));
+  Mat compute(InputArray inputArr, [OutputArray? outputArr]) {
+    final p = outputArr?.ptr ?? calloc<cvg.Mat>();
+    cvRun(() => CFFI.BlockMeanHash_Compute(ref, inputArr.ref, p));
+    return outputArr ?? Mat.fromPointer(p);
   }
 
   /// STATIC Compute computes hash of the input image using BlockMeanHash.
   ///
   /// For further information, see:
   /// https://docs.opencv.org/master/de/d29/classcv_1_1img__hash_1_1ImgHashBase.html#ae2d9288db370089dfd8aab85d5e0b0f3
-  static void computeS(InputArray inputArr, OutputArray outputArr, [int mode = 0]) {
-    cvRun(() => CFFI.blockMeanHashCompute(inputArr.ref, outputArr.ref, mode));
+  static Mat computeS(InputArray inputArr, {OutputArray? outputArr, int mode = 0}) {
+    final p = outputArr?.ptr ?? calloc<cvg.Mat>();
+    cvRun(() => CFFI.blockMeanHashCompute(inputArr.ref, p, mode));
+    return outputArr ?? Mat.fromPointer(p);
   }
 
   /// https://docs.opencv.org/4.x/df/d55/classcv_1_1img__hash_1_1BlockMeanHash.html#ad5aef85f58315551cac14bcabe05f0c3
@@ -157,6 +197,56 @@ class BlockMeanHash extends CvStruct<cvg.BlockMeanHash> implements ImgHashBase {
     });
   }
 
+  @override
+  Future<double> compareAsync(InputArray hashOne, InputArray hashTwo) async => cvRunAsync<double>(
+        (callback) => CFFI.BlockMeanHash_Compare_Async(
+          ref,
+          hashOne.ref,
+          hashTwo.ref,
+          callback,
+        ),
+        doubleCompleter,
+      );
+
+  Future<double> compareSAsync(
+    InputArray hashOne,
+    InputArray hashTwo, [
+    int mode = 0,
+  ]) async =>
+      cvRunAsync<double>(
+        (callback) => CFFI.BlockMeanHash_Compare_Async(
+          ref,
+          hashOne.ref,
+          hashTwo.ref,
+          callback,
+        ),
+        doubleCompleter,
+      );
+
+  @override
+  Future<Mat> computeAsync(InputArray inputArr) async => cvRunAsync1<Mat>(
+        (callback) => CFFI.BlockMeanHash_Compute_Async(
+          ref,
+          inputArr.ref,
+          callback,
+        ),
+        matCompleter,
+      );
+
+  Future<Mat> computeSAsync(InputArray inputArr, [int mode = 0]) async => cvRunAsync<Mat>(
+        (callback) => CFFI.BlockMeanHash_Compute_Async(
+          ref,
+          inputArr.ref,
+          callback,
+        ),
+        matCompleter,
+      );
+
+  Future<VecDouble> getMeanAsync() async => cvRunAsync<VecDouble>(
+        (callback) => CFFI.BlockMeanHash_GetMean_Async(ref, callback),
+        vecDoubleCompleter,
+      );
+
   @override
   List<int> get props => [ptr.address];
 
@@ -184,9 +274,30 @@ class ColorMomentHash implements ImgHashBase {
   /// For further information, see:
   /// https://docs.opencv.org/master/de/d29/classcv_1_1img__hash_1_1ImgHashBase.html#ae2d9288db370089dfd8aab85d5e0b0f3
   @override
-  void compute(InputArray inputArr, OutputArray outputArr) {
-    cvRun(() => CFFI.colorMomentHashCompute(inputArr.ref, outputArr.ref));
+  Mat compute(InputArray inputArr, [OutputArray? outputArr]) {
+    final p = outputArr?.ptr ?? calloc<cvg.Mat>();
+    cvRun(() => CFFI.colorMomentHashCompute(inputArr.ref, p));
+    return outputArr ?? Mat.fromPointer(p);
   }
+
+  @override
+  Future<double> compareAsync(InputArray hashOne, InputArray hashTwo) async => cvRunAsync<double>(
+        (callback) => CFFI.colorMomentHashCompare_Async(
+          hashOne.ref,
+          hashTwo.ref,
+          callback,
+        ),
+        doubleCompleter,
+      );
+
+  @override
+  Future<Mat> computeAsync(InputArray inputArr) async => cvRunAsync<Mat>(
+        (callback) => CFFI.colorMomentHashCompute_Async(
+          inputArr.ref,
+          callback,
+        ),
+        matCompleter,
+      );
 }
 
 /// MarrHildrethHash is implementation of the MarrHildrethHash algorithm.
@@ -204,7 +315,15 @@ class NewMarrHildrethHash implements ImgHashBase {
   double compare(InputArray hashOne, InputArray hashTwo) {
     return using<double>((arena) {
       final p = arena<ffi.Double>();
-      cvRun(() => CFFI.marrHildrethHashCompare(hashOne.ref, hashTwo.ref, alpha, scale, p));
+      cvRun(
+        () => CFFI.marrHildrethHashCompare(
+          hashOne.ref,
+          hashTwo.ref,
+          alpha,
+          scale,
+          p,
+        ),
+      );
       return p.value;
     });
   }
@@ -214,9 +333,41 @@ class NewMarrHildrethHash implements ImgHashBase {
   /// For further information, see:
   /// https://docs.opencv.org/master/de/d29/classcv_1_1img__hash_1_1ImgHashBase.html#ae2d9288db370089dfd8aab85d5e0b0f3
   @override
-  void compute(InputArray inputArr, OutputArray outputArr) {
-    cvRun(() => CFFI.marrHildrethHashCompute(inputArr.ref, outputArr.ref, alpha, scale));
+  Mat compute(InputArray inputArr, [OutputArray? outputArr]) {
+    final p = outputArr?.ptr ?? calloc<cvg.Mat>();
+    cvRun(
+      () => CFFI.marrHildrethHashCompute(
+        inputArr.ref,
+        p,
+        alpha,
+        scale,
+      ),
+    );
+    return outputArr ?? Mat.fromPointer(p);
   }
+
+  @override
+  Future<double> compareAsync(InputArray hashOne, InputArray hashTwo) async => cvRunAsync<double>(
+        (callback) => CFFI.marrHildrethHashCompare_Async(
+          hashOne.ref,
+          hashTwo.ref,
+          alpha,
+          scale,
+          callback,
+        ),
+        doubleCompleter,
+      );
+
+  @override
+  Future<Mat> computeAsync(InputArray inputArr) async => cvRunAsync<Mat>(
+        (callback) => CFFI.marrHildrethHashCompute_Async(
+          inputArr.ref,
+          alpha,
+          scale,
+          callback,
+        ),
+        matCompleter,
+      );
 }
 
 /// NewRadialVarianceHash is implementation of the NewRadialVarianceHash algorithm.
@@ -234,7 +385,15 @@ class NewRadialVarianceHash implements ImgHashBase {
   double compare(InputArray hashOne, InputArray hashTwo) {
     return using<double>((arena) {
       final p = arena<ffi.Double>();
-      cvRun(() => CFFI.radialVarianceHashCompare(hashOne.ref, hashTwo.ref, sigma, numOfAngleLine, p));
+      cvRun(
+        () => CFFI.radialVarianceHashCompare(
+          hashOne.ref,
+          hashTwo.ref,
+          sigma,
+          numOfAngleLine,
+          p,
+        ),
+      );
       return p.value;
     });
   }
@@ -244,7 +403,39 @@ class NewRadialVarianceHash implements ImgHashBase {
   /// For further information, see:
   /// https://docs.opencv.org/master/de/d29/classcv_1_1img__hash_1_1ImgHashBase.html#ae2d9288db370089dfd8aab85d5e0b0f3
   @override
-  void compute(InputArray inputArr, OutputArray outputArr) {
-    cvRun(() => CFFI.radialVarianceHashCompute(inputArr.ref, outputArr.ref, sigma, numOfAngleLine));
+  Mat compute(InputArray inputArr, [OutputArray? outputArr]) {
+    final p = outputArr?.ptr ?? calloc<cvg.Mat>();
+    cvRun(
+      () => CFFI.radialVarianceHashCompute(
+        inputArr.ref,
+        p,
+        sigma,
+        numOfAngleLine,
+      ),
+    );
+    return outputArr ?? Mat.fromPointer(p);
   }
+
+  @override
+  Future<double> compareAsync(InputArray hashOne, InputArray hashTwo) async => cvRunAsync<double>(
+        (callback) => CFFI.radialVarianceHashCompare_Async(
+          hashOne.ref,
+          hashTwo.ref,
+          sigma,
+          numOfAngleLine,
+          callback,
+        ),
+        doubleCompleter,
+      );
+
+  @override
+  Future<Mat> computeAsync(InputArray inputArr) async => cvRunAsync<Mat>(
+        (callback) => CFFI.radialVarianceHashCompute_Async(
+          inputArr.ref,
+          sigma,
+          numOfAngleLine,
+          callback,
+        ),
+        matCompleter,
+      );
 }
diff --git a/lib/src/contrib/wechat_qrcode.dart b/lib/src/contrib/wechat_qrcode.dart
index 7bcf18d6..bc455479 100644
--- a/lib/src/contrib/wechat_qrcode.dart
+++ b/lib/src/contrib/wechat_qrcode.dart
@@ -15,6 +15,11 @@ class WeChatQRCode extends CvStruct<cvg.WeChatQRCode> {
       finalizer.attach(this, ptr.cast(), detach: this);
     }
   }
+  factory WeChatQRCode.fromPointer(
+    cvg.WeChatQRCodePtr ptr, [
+    bool attach = true,
+  ]) =>
+      WeChatQRCode._(ptr, attach);
 
   factory WeChatQRCode.empty() {
     final p = calloc<cvg.WeChatQRCode>();
@@ -46,7 +51,10 @@ class WeChatQRCode extends CvStruct<cvg.WeChatQRCode> {
 
   /// Both detects and decodes QR code. To simplify the usage, there is a only API: detectAndDecode.
   /// https://docs.opencv.org/4.x/d5/d04/classcv_1_1wechat__qrcode_1_1WeChatQRCode.html#a27c167d2d58e5ee4418fd3a9ed5876cc
-  (List<String>, VecMat points) detectAndDecode(InputArray img, [VecMat? points]) {
+  (List<String>, VecMat points) detectAndDecode(
+    InputArray img, [
+    VecMat? points,
+  ]) {
     final p = calloc<cvg.VecMat>();
     final rval = calloc<cvg.VecVecChar>();
     cvRun(() => CFFI.WeChatQRCode_DetectAndDecode(ptr, img.ref, p, rval));
diff --git a/lib/src/contrib/wechat_qrcode_async.dart b/lib/src/contrib/wechat_qrcode_async.dart
new file mode 100644
index 00000000..87b3f17d
--- /dev/null
+++ b/lib/src/contrib/wechat_qrcode_async.dart
@@ -0,0 +1,46 @@
+library cv;
+
+import 'dart:ffi' as ffi;
+import 'package:ffi/ffi.dart';
+
+import '../core/base.dart';
+import '../core/mat.dart';
+import '../core/vec.dart';
+import '../opencv.g.dart' as cvg;
+import 'wechat_qrcode.dart';
+
+extension WeChatQRCodeAsync on WeChatQRCode {
+  static Future<WeChatQRCode> emptyAsync() async => cvRunAsync<WeChatQRCode>(
+        CFFI.WeChatQRCode_New_Async,
+        (c, p) => c.complete(WeChatQRCode.fromPointer(p.cast<cvg.WeChatQRCode>())),
+      );
+
+  static Future<WeChatQRCode> createAsync([
+    String detectorPrototxtPath = "",
+    String detectorCaffeModelPath = "",
+    String superResolutionPrototxtPath = "",
+    String superResolutionCaffeModelPath = "",
+  ]) async {
+    final arena = Arena();
+    final dp = detectorPrototxtPath.toNativeUtf8(allocator: arena).cast<ffi.Char>();
+    final dm = detectorCaffeModelPath.toNativeUtf8(allocator: arena).cast<ffi.Char>();
+    final srp = superResolutionPrototxtPath.toNativeUtf8(allocator: arena).cast<ffi.Char>();
+    final srm = superResolutionCaffeModelPath.toNativeUtf8(allocator: arena).cast<ffi.Char>();
+    final rval = cvRunAsync<WeChatQRCode>(
+      (callback) => CFFI.WeChatQRCode_NewWithParams_Async(dp, dm, srp, srm, callback),
+      (c, p) => c.complete(WeChatQRCode.fromPointer(p.cast<cvg.WeChatQRCode>())),
+    );
+    arena.releaseAll();
+    return rval;
+  }
+
+  Future<(List<String>, VecMat)> detectAndDecodeAsync(InputArray img) async =>
+      cvRunAsync2<(List<String>, VecMat)>(
+          (callback) => CFFI.WeChatQRCode_DetectAndDecode_Async(ptr, img.ref, callback), (c, p, p2) {
+        final vec = VecVecChar.fromPointer(p.cast<cvg.VecVecChar>());
+        final points = VecMat.fromPointer(p2.cast<cvg.VecMat>());
+        final rval = vec.asStringList();
+        vec.dispose();
+        return c.complete((rval, points));
+      });
+}
diff --git a/lib/src/core/array.dart b/lib/src/core/array.dart
index d7163890..33bfd101 100644
--- a/lib/src/core/array.dart
+++ b/lib/src/core/array.dart
@@ -54,6 +54,7 @@ class U8Array extends NativeArray<ffi.Uint8, int> {
 
   static final finalizer = ffi.NativeFinalizer(calloc.nativeFree);
 
+  @override
   void dispose() {
     finalizer.detach(this);
     calloc.free(ptr);
@@ -104,6 +105,7 @@ class I8Array extends NativeArray<ffi.Int8, int> {
 
   static final finalizer = ffi.NativeFinalizer(calloc.nativeFree);
 
+  @override
   void dispose() {
     finalizer.detach(this);
     calloc.free(ptr);
@@ -154,6 +156,7 @@ class U16Array extends NativeArray<ffi.Uint16, int> {
 
   static final finalizer = ffi.NativeFinalizer(calloc.nativeFree);
 
+  @override
   void dispose() {
     finalizer.detach(this);
     calloc.free(ptr);
@@ -204,6 +207,7 @@ class I16Array extends NativeArray<ffi.Int16, int> {
 
   static final finalizer = ffi.NativeFinalizer(calloc.nativeFree);
 
+  @override
   void dispose() {
     finalizer.detach(this);
     calloc.free(ptr);
@@ -254,6 +258,7 @@ class I32Array extends NativeArray<ffi.Int, int> {
 
   static final finalizer = ffi.NativeFinalizer(calloc.nativeFree);
 
+  @override
   void dispose() {
     finalizer.detach(this);
     calloc.free(ptr);
@@ -304,6 +309,7 @@ class F32Array extends NativeArray<ffi.Float, double> {
 
   static final finalizer = ffi.NativeFinalizer(calloc.nativeFree);
 
+  @override
   void dispose() {
     finalizer.detach(this);
     calloc.free(ptr);
@@ -354,6 +360,7 @@ class F64Array extends NativeArray<ffi.Double, double> {
 
   static final finalizer = ffi.NativeFinalizer(calloc.nativeFree);
 
+  @override
   void dispose() {
     finalizer.detach(this);
     calloc.free(ptr);
diff --git a/lib/src/opencv.g.dart b/lib/src/opencv.g.dart
index ab6840a5..ee0b2d08 100644
--- a/lib/src/opencv.g.dart
+++ b/lib/src/opencv.g.dart
@@ -717,6 +717,21 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ffi.Pointer<ArucoDetectorParameters>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_Create_Async(
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_Create_Async(
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_Create_AsyncPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<CvStatus> Function(CvCallback_1)>>(
+          'ArucoDetectorParameters_Create_Async');
+  late final _ArucoDetectorParameters_Create_Async =
+      _ArucoDetectorParameters_Create_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAdaptiveThreshConstant(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Double> rval,
@@ -737,6 +752,27 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAdaptiveThreshConstant_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAdaptiveThreshConstant_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAdaptiveThreshConstant_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetAdaptiveThreshConstant_Async');
+  late final _ArucoDetectorParameters_GetAdaptiveThreshConstant_Async =
+      _ArucoDetectorParameters_GetAdaptiveThreshConstant_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAdaptiveThreshWinSizeMax(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Int> rval,
@@ -757,6 +793,28 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetAdaptiveThreshWinSizeMax_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAdaptiveThreshWinSizeMax_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAdaptiveThreshWinSizeMax_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetAdaptiveThreshWinSizeMax_Async');
+  late final _ArucoDetectorParameters_GetAdaptiveThreshWinSizeMax_Async =
+      _ArucoDetectorParameters_GetAdaptiveThreshWinSizeMax_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAdaptiveThreshWinSizeMin(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Int> rval,
@@ -777,6 +835,28 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetAdaptiveThreshWinSizeMin_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAdaptiveThreshWinSizeMin_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAdaptiveThreshWinSizeMin_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetAdaptiveThreshWinSizeMin_Async');
+  late final _ArucoDetectorParameters_GetAdaptiveThreshWinSizeMin_Async =
+      _ArucoDetectorParameters_GetAdaptiveThreshWinSizeMin_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAdaptiveThreshWinSizeStep(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Int> rval,
@@ -797,6 +877,28 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetAdaptiveThreshWinSizeStep_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAdaptiveThreshWinSizeStep_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAdaptiveThreshWinSizeStep_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetAdaptiveThreshWinSizeStep_Async');
+  late final _ArucoDetectorParameters_GetAdaptiveThreshWinSizeStep_Async =
+      _ArucoDetectorParameters_GetAdaptiveThreshWinSizeStep_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagCriticalRad(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Float> rval,
@@ -817,6 +919,26 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Float>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagCriticalRad_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAprilTagCriticalRad_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAprilTagCriticalRad_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>>(
+      'ArucoDetectorParameters_GetAprilTagCriticalRad_Async');
+  late final _ArucoDetectorParameters_GetAprilTagCriticalRad_Async =
+      _ArucoDetectorParameters_GetAprilTagCriticalRad_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagDeglitch(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Int> rval,
@@ -837,6 +959,26 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagDeglitch_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAprilTagDeglitch_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAprilTagDeglitch_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>>(
+      'ArucoDetectorParameters_GetAprilTagDeglitch_Async');
+  late final _ArucoDetectorParameters_GetAprilTagDeglitch_Async =
+      _ArucoDetectorParameters_GetAprilTagDeglitch_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagMaxLineFitMse(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Float> rval,
@@ -857,6 +999,27 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Float>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagMaxLineFitMse_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAprilTagMaxLineFitMse_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAprilTagMaxLineFitMse_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetAprilTagMaxLineFitMse_Async');
+  late final _ArucoDetectorParameters_GetAprilTagMaxLineFitMse_Async =
+      _ArucoDetectorParameters_GetAprilTagMaxLineFitMse_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagMaxNmaxima(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Int> rval,
@@ -877,6 +1040,26 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagMaxNmaxima_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAprilTagMaxNmaxima_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAprilTagMaxNmaxima_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>>(
+      'ArucoDetectorParameters_GetAprilTagMaxNmaxima_Async');
+  late final _ArucoDetectorParameters_GetAprilTagMaxNmaxima_Async =
+      _ArucoDetectorParameters_GetAprilTagMaxNmaxima_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagMinClusterPixels(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Int> rval,
@@ -897,6 +1080,28 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetAprilTagMinClusterPixels_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAprilTagMinClusterPixels_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAprilTagMinClusterPixels_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetAprilTagMinClusterPixels_Async');
+  late final _ArucoDetectorParameters_GetAprilTagMinClusterPixels_Async =
+      _ArucoDetectorParameters_GetAprilTagMinClusterPixels_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagMinWhiteBlackDiff(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Int> rval,
@@ -917,6 +1122,28 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetAprilTagMinWhiteBlackDiff_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAprilTagMinWhiteBlackDiff_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAprilTagMinWhiteBlackDiff_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetAprilTagMinWhiteBlackDiff_Async');
+  late final _ArucoDetectorParameters_GetAprilTagMinWhiteBlackDiff_Async =
+      _ArucoDetectorParameters_GetAprilTagMinWhiteBlackDiff_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagQuadDecimate(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Float> rval,
@@ -937,6 +1164,27 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Float>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagQuadDecimate_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAprilTagQuadDecimate_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAprilTagQuadDecimate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetAprilTagQuadDecimate_Async');
+  late final _ArucoDetectorParameters_GetAprilTagQuadDecimate_Async =
+      _ArucoDetectorParameters_GetAprilTagQuadDecimate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagQuadSigma(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Float> rval,
@@ -957,6 +1205,26 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Float>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetAprilTagQuadSigma_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetAprilTagQuadSigma_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetAprilTagQuadSigma_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>>(
+      'ArucoDetectorParameters_GetAprilTagQuadSigma_Async');
+  late final _ArucoDetectorParameters_GetAprilTagQuadSigma_Async =
+      _ArucoDetectorParameters_GetAprilTagQuadSigma_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus>
       ArucoDetectorParameters_GetCornerRefinementMaxIterations(
     ArucoDetectorParameters ap,
@@ -979,6 +1247,29 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetCornerRefinementMaxIterations_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetCornerRefinementMaxIterations_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetCornerRefinementMaxIterations_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetCornerRefinementMaxIterations_Async');
+  late final _ArucoDetectorParameters_GetCornerRefinementMaxIterations_Async =
+      _ArucoDetectorParameters_GetCornerRefinementMaxIterations_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetCornerRefinementMethod(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Int> rval,
@@ -999,6 +1290,27 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetCornerRefinementMethod_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetCornerRefinementMethod_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetCornerRefinementMethod_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetCornerRefinementMethod_Async');
+  late final _ArucoDetectorParameters_GetCornerRefinementMethod_Async =
+      _ArucoDetectorParameters_GetCornerRefinementMethod_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetCornerRefinementMinAccuracy(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Double> rval,
@@ -1020,6 +1332,29 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetCornerRefinementMinAccuracy_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetCornerRefinementMinAccuracy_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetCornerRefinementMinAccuracy_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetCornerRefinementMinAccuracy_Async');
+  late final _ArucoDetectorParameters_GetCornerRefinementMinAccuracy_Async =
+      _ArucoDetectorParameters_GetCornerRefinementMinAccuracy_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetCornerRefinementWinSize(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Int> rval,
@@ -1040,6 +1375,28 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetCornerRefinementWinSize_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetCornerRefinementWinSize_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetCornerRefinementWinSize_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetCornerRefinementWinSize_Async');
+  late final _ArucoDetectorParameters_GetCornerRefinementWinSize_Async =
+      _ArucoDetectorParameters_GetCornerRefinementWinSize_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetDetectInvertedMarker(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Bool> rval,
@@ -1060,6 +1417,27 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Bool>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetDetectInvertedMarker_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetDetectInvertedMarker_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetDetectInvertedMarker_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetDetectInvertedMarker_Async');
+  late final _ArucoDetectorParameters_GetDetectInvertedMarker_Async =
+      _ArucoDetectorParameters_GetDetectInvertedMarker_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetErrorCorrectionRate(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Double> rval,
@@ -1080,6 +1458,26 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetErrorCorrectionRate_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetErrorCorrectionRate_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetErrorCorrectionRate_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>>(
+      'ArucoDetectorParameters_GetErrorCorrectionRate_Async');
+  late final _ArucoDetectorParameters_GetErrorCorrectionRate_Async =
+      _ArucoDetectorParameters_GetErrorCorrectionRate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMarkerBorderBits(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Int> rval,
@@ -1100,6 +1498,26 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMarkerBorderBits_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetMarkerBorderBits_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetMarkerBorderBits_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>>(
+      'ArucoDetectorParameters_GetMarkerBorderBits_Async');
+  late final _ArucoDetectorParameters_GetMarkerBorderBits_Async =
+      _ArucoDetectorParameters_GetMarkerBorderBits_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMaxErroneousBitsInBorderRate(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Double> rval,
@@ -1121,6 +1539,29 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetMaxErroneousBitsInBorderRate_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetMaxErroneousBitsInBorderRate_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetMaxErroneousBitsInBorderRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetMaxErroneousBitsInBorderRate_Async');
+  late final _ArucoDetectorParameters_GetMaxErroneousBitsInBorderRate_Async =
+      _ArucoDetectorParameters_GetMaxErroneousBitsInBorderRate_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMaxMarkerPerimeterRate(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Double> rval,
@@ -1141,6 +1582,27 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMaxMarkerPerimeterRate_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetMaxMarkerPerimeterRate_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetMaxMarkerPerimeterRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetMaxMarkerPerimeterRate_Async');
+  late final _ArucoDetectorParameters_GetMaxMarkerPerimeterRate_Async =
+      _ArucoDetectorParameters_GetMaxMarkerPerimeterRate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMinCornerDistanceRate(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Double> rval,
@@ -1161,6 +1623,27 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMinCornerDistanceRate_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetMinCornerDistanceRate_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetMinCornerDistanceRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetMinCornerDistanceRate_Async');
+  late final _ArucoDetectorParameters_GetMinCornerDistanceRate_Async =
+      _ArucoDetectorParameters_GetMinCornerDistanceRate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMinDistanceToBorder(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Int> rval,
@@ -1181,6 +1664,26 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMinDistanceToBorder_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetMinDistanceToBorder_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetMinDistanceToBorder_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>>(
+      'ArucoDetectorParameters_GetMinDistanceToBorder_Async');
+  late final _ArucoDetectorParameters_GetMinDistanceToBorder_Async =
+      _ArucoDetectorParameters_GetMinDistanceToBorder_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMinMarkerDistanceRate(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Double> rval,
@@ -1201,6 +1704,27 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMinMarkerDistanceRate_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetMinMarkerDistanceRate_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetMinMarkerDistanceRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetMinMarkerDistanceRate_Async');
+  late final _ArucoDetectorParameters_GetMinMarkerDistanceRate_Async =
+      _ArucoDetectorParameters_GetMinMarkerDistanceRate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMinMarkerPerimeterRate(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Double> rval,
@@ -1221,6 +1745,27 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMinMarkerPerimeterRate_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetMinMarkerPerimeterRate_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetMinMarkerPerimeterRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetMinMarkerPerimeterRate_Async');
+  late final _ArucoDetectorParameters_GetMinMarkerPerimeterRate_Async =
+      _ArucoDetectorParameters_GetMinMarkerPerimeterRate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMinOtsuStdDev(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Double> rval,
@@ -1241,6 +1786,25 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_GetMinOtsuStdDev_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetMinOtsuStdDev_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetMinOtsuStdDev_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(ArucoDetectorParameters,
+              CvCallback_1)>>('ArucoDetectorParameters_GetMinOtsuStdDev_Async');
+  late final _ArucoDetectorParameters_GetMinOtsuStdDev_Async =
+      _ArucoDetectorParameters_GetMinOtsuStdDev_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus>
       ArucoDetectorParameters_GetPerspectiveRemoveIgnoredMarginPerCell(
     ArucoDetectorParameters ap,
@@ -1264,6 +1828,29 @@ class CvNative {
               ffi.Pointer<CvStatus> Function(
                   ArucoDetectorParameters, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetPerspectiveRemoveIgnoredMarginPerCell_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetPerspectiveRemoveIgnoredMarginPerCell_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetPerspectiveRemoveIgnoredMarginPerCell_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetPerspectiveRemoveIgnoredMarginPerCell_Async');
+  late final _ArucoDetectorParameters_GetPerspectiveRemoveIgnoredMarginPerCell_Async =
+      _ArucoDetectorParameters_GetPerspectiveRemoveIgnoredMarginPerCell_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus>
       ArucoDetectorParameters_GetPerspectiveRemovePixelPerCell(
     ArucoDetectorParameters ap,
@@ -1286,6 +1873,29 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetPerspectiveRemovePixelPerCell_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetPerspectiveRemovePixelPerCell_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetPerspectiveRemovePixelPerCell_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetPerspectiveRemovePixelPerCell_Async');
+  late final _ArucoDetectorParameters_GetPerspectiveRemovePixelPerCell_Async =
+      _ArucoDetectorParameters_GetPerspectiveRemovePixelPerCell_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_GetPolygonalApproxAccuracyRate(
     ArucoDetectorParameters ap,
     ffi.Pointer<ffi.Double> rval,
@@ -1307,6 +1917,29 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ArucoDetectorParameters, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_GetPolygonalApproxAccuracyRate_Async(
+    ArucoDetectorParameters ap,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetectorParameters_GetPolygonalApproxAccuracyRate_Async(
+      ap,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_GetPolygonalApproxAccuracyRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, CvCallback_1)>>(
+          'ArucoDetectorParameters_GetPolygonalApproxAccuracyRate_Async');
+  late final _ArucoDetectorParameters_GetPolygonalApproxAccuracyRate_Async =
+      _ArucoDetectorParameters_GetPolygonalApproxAccuracyRate_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAdaptiveThreshConstant(
     ArucoDetectorParameters ap,
     double adaptiveThreshConstant,
@@ -1326,6 +1959,29 @@ class CvNative {
       _ArucoDetectorParameters_SetAdaptiveThreshConstantPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAdaptiveThreshConstant_Async(
+    ArucoDetectorParameters ap,
+    double adaptiveThreshConstant,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAdaptiveThreshConstant_Async(
+      ap,
+      adaptiveThreshConstant,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAdaptiveThreshConstant_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Double, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetAdaptiveThreshConstant_Async');
+  late final _ArucoDetectorParameters_SetAdaptiveThreshConstant_Async =
+      _ArucoDetectorParameters_SetAdaptiveThreshConstant_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAdaptiveThreshWinSizeMax(
     ArucoDetectorParameters ap,
     int adaptiveThreshWinSizeMax,
@@ -1344,6 +2000,30 @@ class CvNative {
       _ArucoDetectorParameters_SetAdaptiveThreshWinSizeMaxPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetAdaptiveThreshWinSizeMax_Async(
+    ArucoDetectorParameters ap,
+    int adaptiveThreshWinSizeMax,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAdaptiveThreshWinSizeMax_Async(
+      ap,
+      adaptiveThreshWinSizeMax,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAdaptiveThreshWinSizeMax_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetAdaptiveThreshWinSizeMax_Async');
+  late final _ArucoDetectorParameters_SetAdaptiveThreshWinSizeMax_Async =
+      _ArucoDetectorParameters_SetAdaptiveThreshWinSizeMax_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAdaptiveThreshWinSizeMin(
     ArucoDetectorParameters ap,
     int adaptiveThreshWinSizeMin,
@@ -1362,6 +2042,30 @@ class CvNative {
       _ArucoDetectorParameters_SetAdaptiveThreshWinSizeMinPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetAdaptiveThreshWinSizeMin_Async(
+    ArucoDetectorParameters ap,
+    int adaptiveThreshWinSizeMin,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAdaptiveThreshWinSizeMin_Async(
+      ap,
+      adaptiveThreshWinSizeMin,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAdaptiveThreshWinSizeMin_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetAdaptiveThreshWinSizeMin_Async');
+  late final _ArucoDetectorParameters_SetAdaptiveThreshWinSizeMin_Async =
+      _ArucoDetectorParameters_SetAdaptiveThreshWinSizeMin_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAdaptiveThreshWinSizeStep(
     ArucoDetectorParameters ap,
     int adaptiveThreshWinSizeStep,
@@ -1381,6 +2085,30 @@ class CvNative {
       _ArucoDetectorParameters_SetAdaptiveThreshWinSizeStepPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetAdaptiveThreshWinSizeStep_Async(
+    ArucoDetectorParameters ap,
+    int adaptiveThreshWinSizeStep,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAdaptiveThreshWinSizeStep_Async(
+      ap,
+      adaptiveThreshWinSizeStep,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAdaptiveThreshWinSizeStep_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetAdaptiveThreshWinSizeStep_Async');
+  late final _ArucoDetectorParameters_SetAdaptiveThreshWinSizeStep_Async =
+      _ArucoDetectorParameters_SetAdaptiveThreshWinSizeStep_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagCriticalRad(
     ArucoDetectorParameters ap,
     double aprilTagCriticalRad,
@@ -1399,6 +2127,28 @@ class CvNative {
       _ArucoDetectorParameters_SetAprilTagCriticalRadPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagCriticalRad_Async(
+    ArucoDetectorParameters ap,
+    double aprilTagCriticalRad,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAprilTagCriticalRad_Async(
+      ap,
+      aprilTagCriticalRad,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAprilTagCriticalRad_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, ffi.Float, CvCallback_0)>>(
+      'ArucoDetectorParameters_SetAprilTagCriticalRad_Async');
+  late final _ArucoDetectorParameters_SetAprilTagCriticalRad_Async =
+      _ArucoDetectorParameters_SetAprilTagCriticalRad_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagDeglitch(
     ArucoDetectorParameters ap,
     int aprilTagDeglitch,
@@ -1417,6 +2167,28 @@ class CvNative {
       _ArucoDetectorParameters_SetAprilTagDeglitchPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagDeglitch_Async(
+    ArucoDetectorParameters ap,
+    int aprilTagDeglitch,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAprilTagDeglitch_Async(
+      ap,
+      aprilTagDeglitch,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAprilTagDeglitch_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+      'ArucoDetectorParameters_SetAprilTagDeglitch_Async');
+  late final _ArucoDetectorParameters_SetAprilTagDeglitch_Async =
+      _ArucoDetectorParameters_SetAprilTagDeglitch_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagMaxLineFitMse(
     ArucoDetectorParameters ap,
     double aprilTagMaxLineFitMse,
@@ -1435,6 +2207,29 @@ class CvNative {
       _ArucoDetectorParameters_SetAprilTagMaxLineFitMsePtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagMaxLineFitMse_Async(
+    ArucoDetectorParameters ap,
+    double aprilTagMaxLineFitMse,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAprilTagMaxLineFitMse_Async(
+      ap,
+      aprilTagMaxLineFitMse,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAprilTagMaxLineFitMse_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Float, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetAprilTagMaxLineFitMse_Async');
+  late final _ArucoDetectorParameters_SetAprilTagMaxLineFitMse_Async =
+      _ArucoDetectorParameters_SetAprilTagMaxLineFitMse_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagMaxNmaxima(
     ArucoDetectorParameters ap,
     int aprilTagMaxNmaxima,
@@ -1453,6 +2248,28 @@ class CvNative {
       _ArucoDetectorParameters_SetAprilTagMaxNmaximaPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagMaxNmaxima_Async(
+    ArucoDetectorParameters ap,
+    int aprilTagMaxNmaxima,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAprilTagMaxNmaxima_Async(
+      ap,
+      aprilTagMaxNmaxima,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAprilTagMaxNmaxima_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+      'ArucoDetectorParameters_SetAprilTagMaxNmaxima_Async');
+  late final _ArucoDetectorParameters_SetAprilTagMaxNmaxima_Async =
+      _ArucoDetectorParameters_SetAprilTagMaxNmaxima_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagMinClusterPixels(
     ArucoDetectorParameters ap,
     int aprilTagMinClusterPixels,
@@ -1471,6 +2288,30 @@ class CvNative {
       _ArucoDetectorParameters_SetAprilTagMinClusterPixelsPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetAprilTagMinClusterPixels_Async(
+    ArucoDetectorParameters ap,
+    int aprilTagMinClusterPixels,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAprilTagMinClusterPixels_Async(
+      ap,
+      aprilTagMinClusterPixels,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAprilTagMinClusterPixels_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetAprilTagMinClusterPixels_Async');
+  late final _ArucoDetectorParameters_SetAprilTagMinClusterPixels_Async =
+      _ArucoDetectorParameters_SetAprilTagMinClusterPixels_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiff(
     ArucoDetectorParameters ap,
     int aprilTagMinWhiteBlackDiff,
@@ -1490,6 +2331,30 @@ class CvNative {
       _ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiffPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiff_Async(
+    ArucoDetectorParameters ap,
+    int aprilTagMinWhiteBlackDiff,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiff_Async(
+      ap,
+      aprilTagMinWhiteBlackDiff,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiff_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiff_Async');
+  late final _ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiff_Async =
+      _ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiff_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagQuadDecimate(
     ArucoDetectorParameters ap,
     double aprilTagQuadDecimate,
@@ -1508,6 +2373,29 @@ class CvNative {
       _ArucoDetectorParameters_SetAprilTagQuadDecimatePtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagQuadDecimate_Async(
+    ArucoDetectorParameters ap,
+    double aprilTagQuadDecimate,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAprilTagQuadDecimate_Async(
+      ap,
+      aprilTagQuadDecimate,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAprilTagQuadDecimate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Float, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetAprilTagQuadDecimate_Async');
+  late final _ArucoDetectorParameters_SetAprilTagQuadDecimate_Async =
+      _ArucoDetectorParameters_SetAprilTagQuadDecimate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagQuadSigma(
     ArucoDetectorParameters ap,
     double aprilTagQuadSigma,
@@ -1526,6 +2414,28 @@ class CvNative {
       _ArucoDetectorParameters_SetAprilTagQuadSigmaPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetAprilTagQuadSigma_Async(
+    ArucoDetectorParameters ap,
+    double aprilTagQuadSigma,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetAprilTagQuadSigma_Async(
+      ap,
+      aprilTagQuadSigma,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetAprilTagQuadSigma_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, ffi.Float, CvCallback_0)>>(
+      'ArucoDetectorParameters_SetAprilTagQuadSigma_Async');
+  late final _ArucoDetectorParameters_SetAprilTagQuadSigma_Async =
+      _ArucoDetectorParameters_SetAprilTagQuadSigma_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus>
       ArucoDetectorParameters_SetCornerRefinementMaxIterations(
     ArucoDetectorParameters ap,
@@ -1547,6 +2457,31 @@ class CvNative {
       _ArucoDetectorParameters_SetCornerRefinementMaxIterationsPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetCornerRefinementMaxIterations_Async(
+    ArucoDetectorParameters ap,
+    int cornerRefinementMaxIterations,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetCornerRefinementMaxIterations_Async(
+      ap,
+      cornerRefinementMaxIterations,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetCornerRefinementMaxIterations_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetCornerRefinementMaxIterations_Async');
+  late final _ArucoDetectorParameters_SetCornerRefinementMaxIterations_Async =
+      _ArucoDetectorParameters_SetCornerRefinementMaxIterations_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetCornerRefinementMethod(
     ArucoDetectorParameters ap,
     int cornerRefinementMethod,
@@ -1565,6 +2500,29 @@ class CvNative {
       _ArucoDetectorParameters_SetCornerRefinementMethodPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetCornerRefinementMethod_Async(
+    ArucoDetectorParameters ap,
+    int cornerRefinementMethod,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetCornerRefinementMethod_Async(
+      ap,
+      cornerRefinementMethod,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetCornerRefinementMethod_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetCornerRefinementMethod_Async');
+  late final _ArucoDetectorParameters_SetCornerRefinementMethod_Async =
+      _ArucoDetectorParameters_SetCornerRefinementMethod_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetCornerRefinementMinAccuracy(
     ArucoDetectorParameters ap,
     double cornerRefinementMinAccuracy,
@@ -1585,6 +2543,31 @@ class CvNative {
       _ArucoDetectorParameters_SetCornerRefinementMinAccuracyPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetCornerRefinementMinAccuracy_Async(
+    ArucoDetectorParameters ap,
+    double cornerRefinementMinAccuracy,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetCornerRefinementMinAccuracy_Async(
+      ap,
+      cornerRefinementMinAccuracy,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetCornerRefinementMinAccuracy_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Double, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetCornerRefinementMinAccuracy_Async');
+  late final _ArucoDetectorParameters_SetCornerRefinementMinAccuracy_Async =
+      _ArucoDetectorParameters_SetCornerRefinementMinAccuracy_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetCornerRefinementWinSize(
     ArucoDetectorParameters ap,
     int cornerRefinementWinSize,
@@ -1603,6 +2586,30 @@ class CvNative {
       _ArucoDetectorParameters_SetCornerRefinementWinSizePtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetCornerRefinementWinSize_Async(
+    ArucoDetectorParameters ap,
+    int cornerRefinementWinSize,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetCornerRefinementWinSize_Async(
+      ap,
+      cornerRefinementWinSize,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetCornerRefinementWinSize_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetCornerRefinementWinSize_Async');
+  late final _ArucoDetectorParameters_SetCornerRefinementWinSize_Async =
+      _ArucoDetectorParameters_SetCornerRefinementWinSize_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetDetectInvertedMarker(
     ArucoDetectorParameters ap,
     bool detectInvertedMarker,
@@ -1621,6 +2628,29 @@ class CvNative {
       _ArucoDetectorParameters_SetDetectInvertedMarkerPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, bool)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetDetectInvertedMarker_Async(
+    ArucoDetectorParameters ap,
+    bool detectInvertedMarker,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetDetectInvertedMarker_Async(
+      ap,
+      detectInvertedMarker,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetDetectInvertedMarker_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Bool, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetDetectInvertedMarker_Async');
+  late final _ArucoDetectorParameters_SetDetectInvertedMarker_Async =
+      _ArucoDetectorParameters_SetDetectInvertedMarker_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, bool, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetErrorCorrectionRate(
     ArucoDetectorParameters ap,
     double errorCorrectionRate,
@@ -1639,6 +2669,28 @@ class CvNative {
       _ArucoDetectorParameters_SetErrorCorrectionRatePtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetErrorCorrectionRate_Async(
+    ArucoDetectorParameters ap,
+    double errorCorrectionRate,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetErrorCorrectionRate_Async(
+      ap,
+      errorCorrectionRate,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetErrorCorrectionRate_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, ffi.Double, CvCallback_0)>>(
+      'ArucoDetectorParameters_SetErrorCorrectionRate_Async');
+  late final _ArucoDetectorParameters_SetErrorCorrectionRate_Async =
+      _ArucoDetectorParameters_SetErrorCorrectionRate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMarkerBorderBits(
     ArucoDetectorParameters ap,
     int markerBorderBits,
@@ -1657,6 +2709,28 @@ class CvNative {
       _ArucoDetectorParameters_SetMarkerBorderBitsPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMarkerBorderBits_Async(
+    ArucoDetectorParameters ap,
+    int markerBorderBits,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetMarkerBorderBits_Async(
+      ap,
+      markerBorderBits,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetMarkerBorderBits_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+      'ArucoDetectorParameters_SetMarkerBorderBits_Async');
+  late final _ArucoDetectorParameters_SetMarkerBorderBits_Async =
+      _ArucoDetectorParameters_SetMarkerBorderBits_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMaxErroneousBitsInBorderRate(
     ArucoDetectorParameters ap,
     double maxErroneousBitsInBorderRate,
@@ -1677,6 +2751,31 @@ class CvNative {
       _ArucoDetectorParameters_SetMaxErroneousBitsInBorderRatePtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetMaxErroneousBitsInBorderRate_Async(
+    ArucoDetectorParameters ap,
+    double maxErroneousBitsInBorderRate,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetMaxErroneousBitsInBorderRate_Async(
+      ap,
+      maxErroneousBitsInBorderRate,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetMaxErroneousBitsInBorderRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Double, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetMaxErroneousBitsInBorderRate_Async');
+  late final _ArucoDetectorParameters_SetMaxErroneousBitsInBorderRate_Async =
+      _ArucoDetectorParameters_SetMaxErroneousBitsInBorderRate_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMaxMarkerPerimeterRate(
     ArucoDetectorParameters ap,
     double maxMarkerPerimeterRate,
@@ -1696,6 +2795,29 @@ class CvNative {
       _ArucoDetectorParameters_SetMaxMarkerPerimeterRatePtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMaxMarkerPerimeterRate_Async(
+    ArucoDetectorParameters ap,
+    double maxMarkerPerimeterRate,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetMaxMarkerPerimeterRate_Async(
+      ap,
+      maxMarkerPerimeterRate,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetMaxMarkerPerimeterRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Double, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetMaxMarkerPerimeterRate_Async');
+  late final _ArucoDetectorParameters_SetMaxMarkerPerimeterRate_Async =
+      _ArucoDetectorParameters_SetMaxMarkerPerimeterRate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMinCornerDistanceRate(
     ArucoDetectorParameters ap,
     double minCornerDistanceRate,
@@ -1714,6 +2836,29 @@ class CvNative {
       _ArucoDetectorParameters_SetMinCornerDistanceRatePtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMinCornerDistanceRate_Async(
+    ArucoDetectorParameters ap,
+    double minCornerDistanceRate,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetMinCornerDistanceRate_Async(
+      ap,
+      minCornerDistanceRate,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetMinCornerDistanceRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Double, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetMinCornerDistanceRate_Async');
+  late final _ArucoDetectorParameters_SetMinCornerDistanceRate_Async =
+      _ArucoDetectorParameters_SetMinCornerDistanceRate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMinDistanceToBorder(
     ArucoDetectorParameters ap,
     int minDistanceToBorder,
@@ -1732,6 +2877,28 @@ class CvNative {
       _ArucoDetectorParameters_SetMinDistanceToBorderPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMinDistanceToBorder_Async(
+    ArucoDetectorParameters ap,
+    int minDistanceToBorder,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetMinDistanceToBorder_Async(
+      ap,
+      minDistanceToBorder,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetMinDistanceToBorder_AsyncPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+      'ArucoDetectorParameters_SetMinDistanceToBorder_Async');
+  late final _ArucoDetectorParameters_SetMinDistanceToBorder_Async =
+      _ArucoDetectorParameters_SetMinDistanceToBorder_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMinMarkerDistanceRate(
     ArucoDetectorParameters ap,
     double minMarkerDistanceRate,
@@ -1750,6 +2917,29 @@ class CvNative {
       _ArucoDetectorParameters_SetMinMarkerDistanceRatePtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMinMarkerDistanceRate_Async(
+    ArucoDetectorParameters ap,
+    double minMarkerDistanceRate,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetMinMarkerDistanceRate_Async(
+      ap,
+      minMarkerDistanceRate,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetMinMarkerDistanceRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Double, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetMinMarkerDistanceRate_Async');
+  late final _ArucoDetectorParameters_SetMinMarkerDistanceRate_Async =
+      _ArucoDetectorParameters_SetMinMarkerDistanceRate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMinMarkerPerimeterRate(
     ArucoDetectorParameters ap,
     double minMarkerPerimeterRate,
@@ -1769,6 +2959,29 @@ class CvNative {
       _ArucoDetectorParameters_SetMinMarkerPerimeterRatePtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMinMarkerPerimeterRate_Async(
+    ArucoDetectorParameters ap,
+    double minMarkerPerimeterRate,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetMinMarkerPerimeterRate_Async(
+      ap,
+      minMarkerPerimeterRate,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetMinMarkerPerimeterRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Double, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetMinMarkerPerimeterRate_Async');
+  late final _ArucoDetectorParameters_SetMinMarkerPerimeterRate_Async =
+      _ArucoDetectorParameters_SetMinMarkerPerimeterRate_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMinOtsuStdDev(
     ArucoDetectorParameters ap,
     double minOtsuStdDev,
@@ -1787,6 +3000,27 @@ class CvNative {
       _ArucoDetectorParameters_SetMinOtsuStdDevPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus> ArucoDetectorParameters_SetMinOtsuStdDev_Async(
+    ArucoDetectorParameters ap,
+    double minOtsuStdDev,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetMinOtsuStdDev_Async(
+      ap,
+      minOtsuStdDev,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetMinOtsuStdDev_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, ffi.Double,
+              CvCallback_0)>>('ArucoDetectorParameters_SetMinOtsuStdDev_Async');
+  late final _ArucoDetectorParameters_SetMinOtsuStdDev_Async =
+      _ArucoDetectorParameters_SetMinOtsuStdDev_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus>
       ArucoDetectorParameters_SetPerspectiveRemoveIgnoredMarginPerCell(
     ArucoDetectorParameters ap,
@@ -1810,6 +3044,31 @@ class CvNative {
               ffi.Pointer<CvStatus> Function(
                   ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetPerspectiveRemoveIgnoredMarginPerCell_Async(
+    ArucoDetectorParameters ap,
+    double perspectiveRemoveIgnoredMarginPerCell,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetPerspectiveRemoveIgnoredMarginPerCell_Async(
+      ap,
+      perspectiveRemoveIgnoredMarginPerCell,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetPerspectiveRemoveIgnoredMarginPerCell_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Double, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetPerspectiveRemoveIgnoredMarginPerCell_Async');
+  late final _ArucoDetectorParameters_SetPerspectiveRemoveIgnoredMarginPerCell_Async =
+      _ArucoDetectorParameters_SetPerspectiveRemoveIgnoredMarginPerCell_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, double, CvCallback_0)>();
+
   ffi.Pointer<CvStatus>
       ArucoDetectorParameters_SetPerspectiveRemovePixelPerCell(
     ArucoDetectorParameters ap,
@@ -1831,6 +3090,31 @@ class CvNative {
       _ArucoDetectorParameters_SetPerspectiveRemovePixelPerCellPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, int)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetPerspectiveRemovePixelPerCell_Async(
+    ArucoDetectorParameters ap,
+    int perspectiveRemovePixelPerCell,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetPerspectiveRemovePixelPerCell_Async(
+      ap,
+      perspectiveRemovePixelPerCell,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetPerspectiveRemovePixelPerCell_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Int, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetPerspectiveRemovePixelPerCell_Async');
+  late final _ArucoDetectorParameters_SetPerspectiveRemovePixelPerCell_Async =
+      _ArucoDetectorParameters_SetPerspectiveRemovePixelPerCell_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoDetectorParameters_SetPolygonalApproxAccuracyRate(
     ArucoDetectorParameters ap,
     double polygonalApproxAccuracyRate,
@@ -1851,6 +3135,31 @@ class CvNative {
       _ArucoDetectorParameters_SetPolygonalApproxAccuracyRatePtr.asFunction<
           ffi.Pointer<CvStatus> Function(ArucoDetectorParameters, double)>();
 
+  ffi.Pointer<CvStatus>
+      ArucoDetectorParameters_SetPolygonalApproxAccuracyRate_Async(
+    ArucoDetectorParameters ap,
+    double polygonalApproxAccuracyRate,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDetectorParameters_SetPolygonalApproxAccuracyRate_Async(
+      ap,
+      polygonalApproxAccuracyRate,
+      callback,
+    );
+  }
+
+  late final _ArucoDetectorParameters_SetPolygonalApproxAccuracyRate_AsyncPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<CvStatus> Function(
+                      ArucoDetectorParameters, ffi.Double, CvCallback_0)>>(
+          'ArucoDetectorParameters_SetPolygonalApproxAccuracyRate_Async');
+  late final _ArucoDetectorParameters_SetPolygonalApproxAccuracyRate_Async =
+      _ArucoDetectorParameters_SetPolygonalApproxAccuracyRate_AsyncPtr
+          .asFunction<
+              ffi.Pointer<CvStatus> Function(
+                  ArucoDetectorParameters, double, CvCallback_0)>();
+
   void ArucoDetector_Close(
     ArucoDetectorPtr ad,
   ) {
@@ -1898,6 +3207,26 @@ class CvNative {
               ffi.Pointer<VecInt>,
               ffi.Pointer<VecVecPoint2f>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetector_DetectMarkers_Async(
+    ArucoDetector ad,
+    Mat inputArr,
+    CvCallback_3 callback,
+  ) {
+    return _ArucoDetector_DetectMarkers_Async(
+      ad,
+      inputArr,
+      callback,
+    );
+  }
+
+  late final _ArucoDetector_DetectMarkers_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(ArucoDetector, Mat,
+              CvCallback_3)>>('ArucoDetector_DetectMarkers_Async');
+  late final _ArucoDetector_DetectMarkers_Async =
+      _ArucoDetector_DetectMarkers_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(ArucoDetector, Mat, CvCallback_3)>();
+
   ffi.Pointer<CvStatus> ArucoDetector_New(
     ffi.Pointer<ArucoDetector> rval,
   ) {
@@ -1936,6 +3265,43 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(ArucoDictionary,
               ArucoDetectorParameters, ffi.Pointer<ArucoDetector>)>();
 
+  ffi.Pointer<CvStatus> ArucoDetector_NewWithParams_Async(
+    ArucoDictionary dictionary,
+    ArucoDetectorParameters params,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetector_NewWithParams_Async(
+      dictionary,
+      params,
+      callback,
+    );
+  }
+
+  late final _ArucoDetector_NewWithParams_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDictionary,
+              ArucoDetectorParameters,
+              CvCallback_1)>>('ArucoDetector_NewWithParams_Async');
+  late final _ArucoDetector_NewWithParams_Async =
+      _ArucoDetector_NewWithParams_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ArucoDictionary, ArucoDetectorParameters, CvCallback_1)>();
+
+  ffi.Pointer<CvStatus> ArucoDetector_New_Async(
+    CvCallback_1 callback,
+  ) {
+    return _ArucoDetector_New_Async(
+      callback,
+    );
+  }
+
+  late final _ArucoDetector_New_AsyncPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<CvStatus> Function(CvCallback_1)>>(
+          'ArucoDetector_New_Async');
+  late final _ArucoDetector_New_Async = _ArucoDetector_New_AsyncPtr.asFunction<
+      ffi.Pointer<CvStatus> Function(CvCallback_1)>();
+
   void ArucoDictionary_Close(
     ArucoDictionaryPtr self,
   ) {
@@ -1972,28 +3338,79 @@ class CvNative {
       _ArucoDrawDetectedMarkersPtr.asFunction<
           ffi.Pointer<CvStatus> Function(Mat, VecVecPoint2f, VecInt, Scalar)>();
 
+  ffi.Pointer<CvStatus> ArucoDrawDetectedMarkers_Async(
+    Mat image,
+    VecVecPoint2f markerCorners,
+    VecInt markerIds,
+    Scalar borderColor,
+    CvCallback_0 callback,
+  ) {
+    return _ArucoDrawDetectedMarkers_Async(
+      image,
+      markerCorners,
+      markerIds,
+      borderColor,
+      callback,
+    );
+  }
+
+  late final _ArucoDrawDetectedMarkers_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(Mat, VecVecPoint2f, VecInt, Scalar,
+              CvCallback_0)>>('ArucoDrawDetectedMarkers_Async');
+  late final _ArucoDrawDetectedMarkers_Async =
+      _ArucoDrawDetectedMarkers_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              Mat, VecVecPoint2f, VecInt, Scalar, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> ArucoGenerateImageMarker(
     int dictionaryId,
     int id,
     int sidePixels,
-    Mat img,
     int borderBits,
+    ffi.Pointer<Mat> img,
   ) {
     return _ArucoGenerateImageMarker(
       dictionaryId,
       id,
       sidePixels,
-      img,
       borderBits,
+      img,
     );
   }
 
   late final _ArucoGenerateImageMarkerPtr = _lookup<
       ffi.NativeFunction<
-          ffi.Pointer<CvStatus> Function(ffi.Int, ffi.Int, ffi.Int, Mat,
-              ffi.Int)>>('ArucoGenerateImageMarker');
-  late final _ArucoGenerateImageMarker = _ArucoGenerateImageMarkerPtr
-      .asFunction<ffi.Pointer<CvStatus> Function(int, int, int, Mat, int)>();
+          ffi.Pointer<CvStatus> Function(ffi.Int, ffi.Int, ffi.Int, ffi.Int,
+              ffi.Pointer<Mat>)>>('ArucoGenerateImageMarker');
+  late final _ArucoGenerateImageMarker =
+      _ArucoGenerateImageMarkerPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              int, int, int, int, ffi.Pointer<Mat>)>();
+
+  ffi.Pointer<CvStatus> ArucoGenerateImageMarker_Async(
+    int dictionaryId,
+    int id,
+    int sidePixels,
+    int borderBits,
+    CvCallback_1 callback,
+  ) {
+    return _ArucoGenerateImageMarker_Async(
+      dictionaryId,
+      id,
+      sidePixels,
+      borderBits,
+      callback,
+    );
+  }
+
+  late final _ArucoGenerateImageMarker_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(ffi.Int, ffi.Int, ffi.Int, ffi.Int,
+              CvCallback_1)>>('ArucoGenerateImageMarker_Async');
+  late final _ArucoGenerateImageMarker_Async =
+      _ArucoGenerateImageMarker_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(int, int, int, int, CvCallback_1)>();
 
   void AsyncArray_Close(
     AsyncArrayPtr a,
@@ -2726,10 +4143,33 @@ class CvNative {
       ffi.Pointer<CvStatus> Function(
           BlockMeanHash, Mat, Mat, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> BlockMeanHash_Compare_Async(
+    BlockMeanHash self,
+    Mat hashOne,
+    Mat hashTwo,
+    CvCallback_1 callback,
+  ) {
+    return _BlockMeanHash_Compare_Async(
+      self,
+      hashOne,
+      hashTwo,
+      callback,
+    );
+  }
+
+  late final _BlockMeanHash_Compare_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(BlockMeanHash, Mat, Mat,
+              CvCallback_1)>>('BlockMeanHash_Compare_Async');
+  late final _BlockMeanHash_Compare_Async =
+      _BlockMeanHash_Compare_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              BlockMeanHash, Mat, Mat, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> BlockMeanHash_Compute(
     BlockMeanHash self,
     Mat inputArr,
-    Mat outputArr,
+    ffi.Pointer<Mat> outputArr,
   ) {
     return _BlockMeanHash_Compute(
       self,
@@ -2741,9 +4181,29 @@ class CvNative {
   late final _BlockMeanHash_ComputePtr = _lookup<
       ffi.NativeFunction<
           ffi.Pointer<CvStatus> Function(
-              BlockMeanHash, Mat, Mat)>>('BlockMeanHash_Compute');
+              BlockMeanHash, Mat, ffi.Pointer<Mat>)>>('BlockMeanHash_Compute');
   late final _BlockMeanHash_Compute = _BlockMeanHash_ComputePtr.asFunction<
-      ffi.Pointer<CvStatus> Function(BlockMeanHash, Mat, Mat)>();
+      ffi.Pointer<CvStatus> Function(BlockMeanHash, Mat, ffi.Pointer<Mat>)>();
+
+  ffi.Pointer<CvStatus> BlockMeanHash_Compute_Async(
+    BlockMeanHash self,
+    Mat inputArr,
+    CvCallback_1 callback,
+  ) {
+    return _BlockMeanHash_Compute_Async(
+      self,
+      inputArr,
+      callback,
+    );
+  }
+
+  late final _BlockMeanHash_Compute_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(BlockMeanHash, Mat,
+              CvCallback_1)>>('BlockMeanHash_Compute_Async');
+  late final _BlockMeanHash_Compute_Async =
+      _BlockMeanHash_Compute_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(BlockMeanHash, Mat, CvCallback_1)>();
 
   ffi.Pointer<CvStatus> BlockMeanHash_Create(
     int mode,
@@ -2762,6 +4222,23 @@ class CvNative {
   late final _BlockMeanHash_Create = _BlockMeanHash_CreatePtr.asFunction<
       ffi.Pointer<CvStatus> Function(int, ffi.Pointer<BlockMeanHash>)>();
 
+  ffi.Pointer<CvStatus> BlockMeanHash_Create_Async(
+    int mode,
+    CvCallback_1 callback,
+  ) {
+    return _BlockMeanHash_Create_Async(
+      mode,
+      callback,
+    );
+  }
+
+  late final _BlockMeanHash_Create_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              ffi.Int, CvCallback_1)>>('BlockMeanHash_Create_Async');
+  late final _BlockMeanHash_Create_Async = _BlockMeanHash_Create_AsyncPtr
+      .asFunction<ffi.Pointer<CvStatus> Function(int, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> BlockMeanHash_GetMean(
     BlockMeanHash self,
     ffi.Pointer<ffi.Pointer<ffi.Double>> rval,
@@ -2784,6 +4261,24 @@ class CvNative {
       ffi.Pointer<CvStatus> Function(BlockMeanHash,
           ffi.Pointer<ffi.Pointer<ffi.Double>>, ffi.Pointer<ffi.Int>)>();
 
+  ffi.Pointer<CvStatus> BlockMeanHash_GetMean_Async(
+    BlockMeanHash self,
+    CvCallback_1 callback,
+  ) {
+    return _BlockMeanHash_GetMean_Async(
+      self,
+      callback,
+    );
+  }
+
+  late final _BlockMeanHash_GetMean_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              BlockMeanHash, CvCallback_1)>>('BlockMeanHash_GetMean_Async');
+  late final _BlockMeanHash_GetMean_Async =
+      _BlockMeanHash_GetMean_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(BlockMeanHash, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> BlockMeanHash_SetMode(
     BlockMeanHash self,
     int mode,
@@ -2801,6 +4296,26 @@ class CvNative {
   late final _BlockMeanHash_SetMode = _BlockMeanHash_SetModePtr.asFunction<
       ffi.Pointer<CvStatus> Function(BlockMeanHash, int)>();
 
+  ffi.Pointer<CvStatus> BlockMeanHash_SetMode_Async(
+    BlockMeanHash self,
+    int mode,
+    CvCallback_0 callback,
+  ) {
+    return _BlockMeanHash_SetMode_Async(
+      self,
+      mode,
+      callback,
+    );
+  }
+
+  late final _BlockMeanHash_SetMode_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(BlockMeanHash, ffi.Int,
+              CvCallback_0)>>('BlockMeanHash_SetMode_Async');
+  late final _BlockMeanHash_SetMode_Async =
+      _BlockMeanHash_SetMode_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(BlockMeanHash, int, CvCallback_0)>();
+
   ffi.Pointer<CvStatus> Blur(
     Mat src,
     Mat dst,
@@ -28223,6 +29738,27 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(ffi.Pointer<WeChatQRCode>, Mat,
               ffi.Pointer<VecMat>, ffi.Pointer<VecVecChar>)>();
 
+  ffi.Pointer<CvStatus> WeChatQRCode_DetectAndDecode_Async(
+    ffi.Pointer<WeChatQRCode> self,
+    Mat img,
+    CvCallback_2 callback,
+  ) {
+    return _WeChatQRCode_DetectAndDecode_Async(
+      self,
+      img,
+      callback,
+    );
+  }
+
+  late final _WeChatQRCode_DetectAndDecode_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(ffi.Pointer<WeChatQRCode>, Mat,
+              CvCallback_2)>>('WeChatQRCode_DetectAndDecode_Async');
+  late final _WeChatQRCode_DetectAndDecode_Async =
+      _WeChatQRCode_DetectAndDecode_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ffi.Pointer<WeChatQRCode>, Mat, CvCallback_2)>();
+
   ffi.Pointer<CvStatus> WeChatQRCode_GetScaleFactor(
     ffi.Pointer<WeChatQRCode> self,
     ffi.Pointer<ffi.Float> rval,
@@ -28242,6 +29778,25 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               ffi.Pointer<WeChatQRCode>, ffi.Pointer<ffi.Float>)>();
 
+  ffi.Pointer<CvStatus> WeChatQRCode_GetScaleFactor_Async(
+    ffi.Pointer<WeChatQRCode> self,
+    CvCallback_1 callback,
+  ) {
+    return _WeChatQRCode_GetScaleFactor_Async(
+      self,
+      callback,
+    );
+  }
+
+  late final _WeChatQRCode_GetScaleFactor_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(ffi.Pointer<WeChatQRCode>,
+              CvCallback_1)>>('WeChatQRCode_GetScaleFactor_Async');
+  late final _WeChatQRCode_GetScaleFactor_Async =
+      _WeChatQRCode_GetScaleFactor_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ffi.Pointer<WeChatQRCode>, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> WeChatQRCode_New(
     ffi.Pointer<WeChatQRCode> qrcode,
   ) {
@@ -28290,6 +29845,53 @@ class CvNative {
               ffi.Pointer<ffi.Char>,
               ffi.Pointer<WeChatQRCode>)>();
 
+  ffi.Pointer<CvStatus> WeChatQRCode_NewWithParams_Async(
+    ffi.Pointer<ffi.Char> detector_prototxt_path,
+    ffi.Pointer<ffi.Char> detector_caffe_model_path,
+    ffi.Pointer<ffi.Char> super_resolution_prototxt_path,
+    ffi.Pointer<ffi.Char> super_resolution_caffe_model_path,
+    CvCallback_1 callback,
+  ) {
+    return _WeChatQRCode_NewWithParams_Async(
+      detector_prototxt_path,
+      detector_caffe_model_path,
+      super_resolution_prototxt_path,
+      super_resolution_caffe_model_path,
+      callback,
+    );
+  }
+
+  late final _WeChatQRCode_NewWithParams_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              CvCallback_1)>>('WeChatQRCode_NewWithParams_Async');
+  late final _WeChatQRCode_NewWithParams_Async =
+      _WeChatQRCode_NewWithParams_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              CvCallback_1)>();
+
+  ffi.Pointer<CvStatus> WeChatQRCode_New_Async(
+    CvCallback_1 callback,
+  ) {
+    return _WeChatQRCode_New_Async(
+      callback,
+    );
+  }
+
+  late final _WeChatQRCode_New_AsyncPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<CvStatus> Function(CvCallback_1)>>(
+          'WeChatQRCode_New_Async');
+  late final _WeChatQRCode_New_Async = _WeChatQRCode_New_AsyncPtr.asFunction<
+      ffi.Pointer<CvStatus> Function(CvCallback_1)>();
+
   ffi.Pointer<CvStatus> WeChatQRCode_SetScaleFactor(
     ffi.Pointer<WeChatQRCode> self,
     double scale_factor,
@@ -28308,6 +29910,27 @@ class CvNative {
       _WeChatQRCode_SetScaleFactorPtr.asFunction<
           ffi.Pointer<CvStatus> Function(ffi.Pointer<WeChatQRCode>, double)>();
 
+  ffi.Pointer<CvStatus> WeChatQRCode_SetScaleFactor_Async(
+    ffi.Pointer<WeChatQRCode> self,
+    double scale_factor,
+    CvCallback_0 callback,
+  ) {
+    return _WeChatQRCode_SetScaleFactor_Async(
+      self,
+      scale_factor,
+      callback,
+    );
+  }
+
+  late final _WeChatQRCode_SetScaleFactor_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(ffi.Pointer<WeChatQRCode>, ffi.Float,
+              CvCallback_0)>>('WeChatQRCode_SetScaleFactor_Async');
+  late final _WeChatQRCode_SetScaleFactor_Async =
+      _WeChatQRCode_SetScaleFactor_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              ffi.Pointer<WeChatQRCode>, double, CvCallback_0)>();
+
   void Window_Close(
     ffi.Pointer<ffi.Char> winname,
   ) {
@@ -28548,9 +30171,28 @@ class CvNative {
   late final _averageHashCompare = _averageHashComparePtr.asFunction<
       ffi.Pointer<CvStatus> Function(Mat, Mat, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> averageHashCompare_Async(
+    Mat a,
+    Mat b,
+    CvCallback_1 callback,
+  ) {
+    return _averageHashCompare_Async(
+      a,
+      b,
+      callback,
+    );
+  }
+
+  late final _averageHashCompare_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              Mat, Mat, CvCallback_1)>>('averageHashCompare_Async');
+  late final _averageHashCompare_Async = _averageHashCompare_AsyncPtr
+      .asFunction<ffi.Pointer<CvStatus> Function(Mat, Mat, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> averageHashCompute(
     Mat inputArr,
-    Mat outputArr,
+    ffi.Pointer<Mat> outputArr,
   ) {
     return _averageHashCompute(
       inputArr,
@@ -28558,11 +30200,29 @@ class CvNative {
     );
   }
 
-  late final _averageHashComputePtr =
-      _lookup<ffi.NativeFunction<ffi.Pointer<CvStatus> Function(Mat, Mat)>>(
-          'averageHashCompute');
+  late final _averageHashComputePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              Mat, ffi.Pointer<Mat>)>>('averageHashCompute');
   late final _averageHashCompute = _averageHashComputePtr
-      .asFunction<ffi.Pointer<CvStatus> Function(Mat, Mat)>();
+      .asFunction<ffi.Pointer<CvStatus> Function(Mat, ffi.Pointer<Mat>)>();
+
+  ffi.Pointer<CvStatus> averageHashCompute_Async(
+    Mat inputArr,
+    CvCallback_1 callback,
+  ) {
+    return _averageHashCompute_Async(
+      inputArr,
+      callback,
+    );
+  }
+
+  late final _averageHashCompute_AsyncPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Pointer<CvStatus> Function(Mat, CvCallback_1)>>(
+      'averageHashCompute_Async');
+  late final _averageHashCompute_Async = _averageHashCompute_AsyncPtr
+      .asFunction<ffi.Pointer<CvStatus> Function(Mat, CvCallback_1)>();
 
   ffi.Pointer<CvStatus> blockMeanHashCompare(
     Mat a,
@@ -28587,7 +30247,7 @@ class CvNative {
 
   ffi.Pointer<CvStatus> blockMeanHashCompute(
     Mat inputArr,
-    Mat outputArr,
+    ffi.Pointer<Mat> outputArr,
     int mode,
   ) {
     return _blockMeanHashCompute(
@@ -28598,11 +30258,11 @@ class CvNative {
   }
 
   late final _blockMeanHashComputePtr = _lookup<
-          ffi
-          .NativeFunction<ffi.Pointer<CvStatus> Function(Mat, Mat, ffi.Int)>>(
-      'blockMeanHashCompute');
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              Mat, ffi.Pointer<Mat>, ffi.Int)>>('blockMeanHashCompute');
   late final _blockMeanHashCompute = _blockMeanHashComputePtr
-      .asFunction<ffi.Pointer<CvStatus> Function(Mat, Mat, int)>();
+      .asFunction<ffi.Pointer<CvStatus> Function(Mat, ffi.Pointer<Mat>, int)>();
 
   ffi.Pointer<CvStatus> calibrateCamera_Async(
     VecVecPoint3f objectPoints,
@@ -28660,9 +30320,28 @@ class CvNative {
   late final _colorMomentHashCompare = _colorMomentHashComparePtr.asFunction<
       ffi.Pointer<CvStatus> Function(Mat, Mat, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> colorMomentHashCompare_Async(
+    Mat a,
+    Mat b,
+    CvCallback_1 callback,
+  ) {
+    return _colorMomentHashCompare_Async(
+      a,
+      b,
+      callback,
+    );
+  }
+
+  late final _colorMomentHashCompare_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              Mat, Mat, CvCallback_1)>>('colorMomentHashCompare_Async');
+  late final _colorMomentHashCompare_Async = _colorMomentHashCompare_AsyncPtr
+      .asFunction<ffi.Pointer<CvStatus> Function(Mat, Mat, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> colorMomentHashCompute(
     Mat inputArr,
-    Mat outputArr,
+    ffi.Pointer<Mat> outputArr,
   ) {
     return _colorMomentHashCompute(
       inputArr,
@@ -28670,11 +30349,29 @@ class CvNative {
     );
   }
 
-  late final _colorMomentHashComputePtr =
-      _lookup<ffi.NativeFunction<ffi.Pointer<CvStatus> Function(Mat, Mat)>>(
-          'colorMomentHashCompute');
+  late final _colorMomentHashComputePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              Mat, ffi.Pointer<Mat>)>>('colorMomentHashCompute');
   late final _colorMomentHashCompute = _colorMomentHashComputePtr
-      .asFunction<ffi.Pointer<CvStatus> Function(Mat, Mat)>();
+      .asFunction<ffi.Pointer<CvStatus> Function(Mat, ffi.Pointer<Mat>)>();
+
+  ffi.Pointer<CvStatus> colorMomentHashCompute_Async(
+    Mat inputArr,
+    CvCallback_1 callback,
+  ) {
+    return _colorMomentHashCompute_Async(
+      inputArr,
+      callback,
+    );
+  }
+
+  late final _colorMomentHashCompute_AsyncPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Pointer<CvStatus> Function(Mat, CvCallback_1)>>(
+      'colorMomentHashCompute_Async');
+  late final _colorMomentHashCompute_Async = _colorMomentHashCompute_AsyncPtr
+      .asFunction<ffi.Pointer<CvStatus> Function(Mat, CvCallback_1)>();
 
   ffi.Pointer<CvStatus> core_AbsDiff_Async(
     Mat src1,
@@ -33507,6 +35204,23 @@ class CvNative {
   late final _getPredefinedDictionary = _getPredefinedDictionaryPtr.asFunction<
       ffi.Pointer<CvStatus> Function(int, ffi.Pointer<ArucoDictionary>)>();
 
+  ffi.Pointer<CvStatus> getPredefinedDictionary_Async(
+    int dictionaryId,
+    CvCallback_1 callback,
+  ) {
+    return _getPredefinedDictionary_Async(
+      dictionaryId,
+      callback,
+    );
+  }
+
+  late final _getPredefinedDictionary_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              ffi.Int, CvCallback_1)>>('getPredefinedDictionary_Async');
+  late final _getPredefinedDictionary_Async = _getPredefinedDictionary_AsyncPtr
+      .asFunction<ffi.Pointer<CvStatus> Function(int, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> initUndistortRectifyMap_Async(
     Mat cameraMatrix,
     Mat distCoeffs,
@@ -33560,9 +35274,34 @@ class CvNative {
       ffi.Pointer<CvStatus> Function(
           Mat, Mat, double, double, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> marrHildrethHashCompare_Async(
+    Mat a,
+    Mat b,
+    double alpha,
+    double scale,
+    CvCallback_1 callback,
+  ) {
+    return _marrHildrethHashCompare_Async(
+      a,
+      b,
+      alpha,
+      scale,
+      callback,
+    );
+  }
+
+  late final _marrHildrethHashCompare_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(Mat, Mat, ffi.Float, ffi.Float,
+              CvCallback_1)>>('marrHildrethHashCompare_Async');
+  late final _marrHildrethHashCompare_Async =
+      _marrHildrethHashCompare_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              Mat, Mat, double, double, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> marrHildrethHashCompute(
     Mat inputArr,
-    Mat outputArr,
+    ffi.Pointer<Mat> outputArr,
     double alpha,
     double scale,
   ) {
@@ -33576,10 +35315,32 @@ class CvNative {
 
   late final _marrHildrethHashComputePtr = _lookup<
       ffi.NativeFunction<
-          ffi.Pointer<CvStatus> Function(
-              Mat, Mat, ffi.Float, ffi.Float)>>('marrHildrethHashCompute');
-  late final _marrHildrethHashCompute = _marrHildrethHashComputePtr
-      .asFunction<ffi.Pointer<CvStatus> Function(Mat, Mat, double, double)>();
+          ffi.Pointer<CvStatus> Function(Mat, ffi.Pointer<Mat>, ffi.Float,
+              ffi.Float)>>('marrHildrethHashCompute');
+  late final _marrHildrethHashCompute = _marrHildrethHashComputePtr.asFunction<
+      ffi.Pointer<CvStatus> Function(Mat, ffi.Pointer<Mat>, double, double)>();
+
+  ffi.Pointer<CvStatus> marrHildrethHashCompute_Async(
+    Mat inputArr,
+    double alpha,
+    double scale,
+    CvCallback_1 callback,
+  ) {
+    return _marrHildrethHashCompute_Async(
+      inputArr,
+      alpha,
+      scale,
+      callback,
+    );
+  }
+
+  late final _marrHildrethHashCompute_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(Mat, ffi.Float, ffi.Float,
+              CvCallback_1)>>('marrHildrethHashCompute_Async');
+  late final _marrHildrethHashCompute_Async =
+      _marrHildrethHashCompute_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(Mat, double, double, CvCallback_1)>();
 
   ffi.Pointer<CvStatus> openCVVersion(
     ffi.Pointer<ffi.Pointer<ffi.Char>> rval,
@@ -33629,9 +35390,28 @@ class CvNative {
   late final _pHashCompare = _pHashComparePtr.asFunction<
       ffi.Pointer<CvStatus> Function(Mat, Mat, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> pHashCompare_Async(
+    Mat a,
+    Mat b,
+    CvCallback_1 callback,
+  ) {
+    return _pHashCompare_Async(
+      a,
+      b,
+      callback,
+    );
+  }
+
+  late final _pHashCompare_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              Mat, Mat, CvCallback_1)>>('pHashCompare_Async');
+  late final _pHashCompare_Async = _pHashCompare_AsyncPtr
+      .asFunction<ffi.Pointer<CvStatus> Function(Mat, Mat, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> pHashCompute(
     Mat inputArr,
-    Mat outputArr,
+    ffi.Pointer<Mat> outputArr,
   ) {
     return _pHashCompute(
       inputArr,
@@ -33639,11 +35419,29 @@ class CvNative {
     );
   }
 
-  late final _pHashComputePtr =
-      _lookup<ffi.NativeFunction<ffi.Pointer<CvStatus> Function(Mat, Mat)>>(
-          'pHashCompute');
-  late final _pHashCompute =
-      _pHashComputePtr.asFunction<ffi.Pointer<CvStatus> Function(Mat, Mat)>();
+  late final _pHashComputePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              Mat, ffi.Pointer<Mat>)>>('pHashCompute');
+  late final _pHashCompute = _pHashComputePtr
+      .asFunction<ffi.Pointer<CvStatus> Function(Mat, ffi.Pointer<Mat>)>();
+
+  ffi.Pointer<CvStatus> pHashCompute_Async(
+    Mat inputArr,
+    CvCallback_1 callback,
+  ) {
+    return _pHashCompute_Async(
+      inputArr,
+      callback,
+    );
+  }
+
+  late final _pHashCompute_AsyncPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Pointer<CvStatus> Function(Mat, CvCallback_1)>>(
+      'pHashCompute_Async');
+  late final _pHashCompute_Async = _pHashCompute_AsyncPtr
+      .asFunction<ffi.Pointer<CvStatus> Function(Mat, CvCallback_1)>();
 
   ffi.Pointer<CvStatus> radialVarianceHashCompare(
     Mat a,
@@ -33670,9 +35468,34 @@ class CvNative {
           ffi.Pointer<CvStatus> Function(
               Mat, Mat, double, int, ffi.Pointer<ffi.Double>)>();
 
+  ffi.Pointer<CvStatus> radialVarianceHashCompare_Async(
+    Mat a,
+    Mat b,
+    double sigma,
+    int numOfAngleLine,
+    CvCallback_1 callback,
+  ) {
+    return _radialVarianceHashCompare_Async(
+      a,
+      b,
+      sigma,
+      numOfAngleLine,
+      callback,
+    );
+  }
+
+  late final _radialVarianceHashCompare_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(Mat, Mat, ffi.Double, ffi.Int,
+              CvCallback_1)>>('radialVarianceHashCompare_Async');
+  late final _radialVarianceHashCompare_Async =
+      _radialVarianceHashCompare_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(
+              Mat, Mat, double, int, CvCallback_1)>();
+
   ffi.Pointer<CvStatus> radialVarianceHashCompute(
     Mat inputArr,
-    Mat outputArr,
+    ffi.Pointer<Mat> outputArr,
     double sigma,
     int numOfAngleLine,
   ) {
@@ -33686,10 +35509,33 @@ class CvNative {
 
   late final _radialVarianceHashComputePtr = _lookup<
       ffi.NativeFunction<
-          ffi.Pointer<CvStatus> Function(
-              Mat, Mat, ffi.Double, ffi.Int)>>('radialVarianceHashCompute');
-  late final _radialVarianceHashCompute = _radialVarianceHashComputePtr
-      .asFunction<ffi.Pointer<CvStatus> Function(Mat, Mat, double, int)>();
+          ffi.Pointer<CvStatus> Function(Mat, ffi.Pointer<Mat>, ffi.Double,
+              ffi.Int)>>('radialVarianceHashCompute');
+  late final _radialVarianceHashCompute =
+      _radialVarianceHashComputePtr.asFunction<
+          ffi.Pointer<CvStatus> Function(Mat, ffi.Pointer<Mat>, double, int)>();
+
+  ffi.Pointer<CvStatus> radialVarianceHashCompute_Async(
+    Mat inputArr,
+    double sigma,
+    int numOfAngleLine,
+    CvCallback_1 callback,
+  ) {
+    return _radialVarianceHashCompute_Async(
+      inputArr,
+      sigma,
+      numOfAngleLine,
+      callback,
+    );
+  }
+
+  late final _radialVarianceHashCompute_AsyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(Mat, ffi.Double, ffi.Int,
+              CvCallback_1)>>('radialVarianceHashCompute_Async');
+  late final _radialVarianceHashCompute_Async =
+      _radialVarianceHashCompute_AsyncPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(Mat, double, int, CvCallback_1)>();
 
   void registerErrorCallback(
     ErrorCallback callback,
diff --git a/src/extra/aruco.cpp b/src/extra/aruco.cpp
index d2612def..b429a9b9 100644
--- a/src/extra/aruco.cpp
+++ b/src/extra/aruco.cpp
@@ -436,10 +436,12 @@ CvStatus *ArucoDrawDetectedMarkers(Mat image, VecVecPoint2f markerCorners, VecIn
   cv::aruco::drawDetectedMarkers(*image.ptr, *markerCorners.ptr, *markerIds.ptr, _borderColor);
   END_WRAP
 }
-CvStatus *ArucoGenerateImageMarker(int dictionaryId, int id, int sidePixels, Mat img, int borderBits)
+CvStatus *ArucoGenerateImageMarker(int dictionaryId, int id, int sidePixels, int borderBits, Mat *img)
 {
   BEGIN_WRAP
   cv::aruco::Dictionary dict = cv::aruco::getPredefinedDictionary(dictionaryId);
-  cv::aruco::generateImageMarker(dict, id, sidePixels, *img.ptr, borderBits);
+  cv::Mat dst;
+  cv::aruco::generateImageMarker(dict, id, sidePixels, dst, borderBits);
+  *img = {new cv::Mat(dst)};
   END_WRAP
 }
diff --git a/src/extra/aruco.h b/src/extra/aruco.h
index 503479ff..a32bf70f 100644
--- a/src/extra/aruco.h
+++ b/src/extra/aruco.h
@@ -123,7 +123,7 @@ CvStatus *ArucoDetector_DetectMarkers(ArucoDetector ad, Mat inputArr, VecVecPoin
 
 CvStatus *ArucoDrawDetectedMarkers(Mat image, VecVecPoint2f markerCorners, VecInt markerIds,
                                    Scalar borderColor);
-CvStatus *ArucoGenerateImageMarker(int dictionaryId, int id, int sidePixels, Mat img, int borderBits);
+CvStatus *ArucoGenerateImageMarker(int dictionaryId, int id, int sidePixels, int borderBits, Mat *img);
 
 #ifdef __cplusplus
 }
diff --git a/src/extra/aruco_async.cpp b/src/extra/aruco_async.cpp
new file mode 100644
index 00000000..27471ffc
--- /dev/null
+++ b/src/extra/aruco_async.cpp
@@ -0,0 +1,531 @@
+#include "aruco_async.h"
+#include "core/types.h"
+
+// Asynchronous functions for ArucoDetectorParameters
+CvStatus *ArucoDetectorParameters_Create_Async(CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    auto params = new cv::aruco::DetectorParameters();
+    callback(new ArucoDetectorParameters{params});
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAdaptiveThreshWinSizeMin_Async(ArucoDetectorParameters ap, int adaptiveThreshWinSizeMin, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->adaptiveThreshWinSizeMin = adaptiveThreshWinSizeMin;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAdaptiveThreshWinSizeMin_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->adaptiveThreshWinSizeMin;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAdaptiveThreshWinSizeMax_Async(ArucoDetectorParameters ap, int adaptiveThreshWinSizeMax, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->adaptiveThreshWinSizeMax = adaptiveThreshWinSizeMax;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAdaptiveThreshWinSizeMax_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->adaptiveThreshWinSizeMax;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAdaptiveThreshWinSizeStep_Async(ArucoDetectorParameters ap, int adaptiveThreshWinSizeStep, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->adaptiveThreshWinSizeStep = adaptiveThreshWinSizeStep;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAdaptiveThreshWinSizeStep_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->adaptiveThreshWinSizeStep;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAdaptiveThreshConstant_Async(ArucoDetectorParameters ap, double adaptiveThreshConstant, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->adaptiveThreshConstant = adaptiveThreshConstant;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAdaptiveThreshConstant_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    double value = ap.ptr->adaptiveThreshConstant;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetMinMarkerPerimeterRate_Async(ArucoDetectorParameters ap, double minMarkerPerimeterRate, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->minMarkerPerimeterRate = minMarkerPerimeterRate;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetMinMarkerPerimeterRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    double value = ap.ptr->minMarkerPerimeterRate;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetMaxMarkerPerimeterRate_Async(ArucoDetectorParameters ap, double maxMarkerPerimeterRate, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->maxMarkerPerimeterRate = maxMarkerPerimeterRate;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetMaxMarkerPerimeterRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    double value = ap.ptr->maxMarkerPerimeterRate;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetPolygonalApproxAccuracyRate_Async(ArucoDetectorParameters ap, double polygonalApproxAccuracyRate, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->polygonalApproxAccuracyRate = polygonalApproxAccuracyRate;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetPolygonalApproxAccuracyRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    double value = ap.ptr->polygonalApproxAccuracyRate;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetMinCornerDistanceRate_Async(ArucoDetectorParameters ap, double minCornerDistanceRate, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->minCornerDistanceRate = minCornerDistanceRate;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetMinCornerDistanceRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    double value = ap.ptr->minCornerDistanceRate;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetMinDistanceToBorder_Async(ArucoDetectorParameters ap, int minDistanceToBorder, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->minDistanceToBorder = minDistanceToBorder;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetMinDistanceToBorder_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->minDistanceToBorder;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetMinMarkerDistanceRate_Async(ArucoDetectorParameters ap, double minMarkerDistanceRate, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->minMarkerDistanceRate = minMarkerDistanceRate;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetMinMarkerDistanceRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    double value = ap.ptr->minMarkerDistanceRate;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetCornerRefinementMethod_Async(ArucoDetectorParameters ap, int cornerRefinementMethod, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->cornerRefinementMethod = cornerRefinementMethod;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetCornerRefinementMethod_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->cornerRefinementMethod;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetCornerRefinementWinSize_Async(ArucoDetectorParameters ap, int cornerRefinementWinSize, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->cornerRefinementWinSize = cornerRefinementWinSize;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetCornerRefinementWinSize_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->cornerRefinementWinSize;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetCornerRefinementMaxIterations_Async(ArucoDetectorParameters ap, int cornerRefinementMaxIterations, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->cornerRefinementMaxIterations = cornerRefinementMaxIterations;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetCornerRefinementMaxIterations_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->cornerRefinementMaxIterations;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetCornerRefinementMinAccuracy_Async(ArucoDetectorParameters ap, double cornerRefinementMinAccuracy, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->cornerRefinementMinAccuracy = cornerRefinementMinAccuracy;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetCornerRefinementMinAccuracy_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    double value = ap.ptr->cornerRefinementMinAccuracy;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetMarkerBorderBits_Async(ArucoDetectorParameters ap, int markerBorderBits, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->markerBorderBits = markerBorderBits;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetMarkerBorderBits_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->markerBorderBits;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetPerspectiveRemovePixelPerCell_Async(ArucoDetectorParameters ap, int perspectiveRemovePixelPerCell, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->perspectiveRemovePixelPerCell = perspectiveRemovePixelPerCell;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetPerspectiveRemovePixelPerCell_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->perspectiveRemovePixelPerCell;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetPerspectiveRemoveIgnoredMarginPerCell_Async(ArucoDetectorParameters ap, double perspectiveRemoveIgnoredMarginPerCell, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->perspectiveRemoveIgnoredMarginPerCell = perspectiveRemoveIgnoredMarginPerCell;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetPerspectiveRemoveIgnoredMarginPerCell_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    double value = ap.ptr->perspectiveRemoveIgnoredMarginPerCell;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetMaxErroneousBitsInBorderRate_Async(ArucoDetectorParameters ap, double maxErroneousBitsInBorderRate, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->maxErroneousBitsInBorderRate = maxErroneousBitsInBorderRate;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetMaxErroneousBitsInBorderRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    double value = ap.ptr->maxErroneousBitsInBorderRate;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetMinOtsuStdDev_Async(ArucoDetectorParameters ap, double minOtsuStdDev, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->minOtsuStdDev = minOtsuStdDev;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetMinOtsuStdDev_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    double value = ap.ptr->minOtsuStdDev;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetErrorCorrectionRate_Async(ArucoDetectorParameters ap, double errorCorrectionRate, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->errorCorrectionRate = errorCorrectionRate;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetErrorCorrectionRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    double value = ap.ptr->errorCorrectionRate;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAprilTagQuadDecimate_Async(ArucoDetectorParameters ap, float aprilTagQuadDecimate, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->aprilTagQuadDecimate = aprilTagQuadDecimate;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAprilTagQuadDecimate_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    float value = ap.ptr->aprilTagQuadDecimate;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAprilTagQuadSigma_Async(ArucoDetectorParameters ap, float aprilTagQuadSigma, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->aprilTagQuadSigma = aprilTagQuadSigma;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAprilTagQuadSigma_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    float value = ap.ptr->aprilTagQuadSigma;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAprilTagMinClusterPixels_Async(ArucoDetectorParameters ap, int aprilTagMinClusterPixels, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->aprilTagMinClusterPixels = aprilTagMinClusterPixels;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAprilTagMinClusterPixels_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->aprilTagMinClusterPixels;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAprilTagMaxNmaxima_Async(ArucoDetectorParameters ap, int aprilTagMaxNmaxima, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->aprilTagMaxNmaxima = aprilTagMaxNmaxima;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAprilTagMaxNmaxima_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->aprilTagMaxNmaxima;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAprilTagCriticalRad_Async(ArucoDetectorParameters ap, float aprilTagCriticalRad, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->aprilTagCriticalRad = aprilTagCriticalRad;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAprilTagCriticalRad_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    float value = ap.ptr->aprilTagCriticalRad;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAprilTagMaxLineFitMse_Async(ArucoDetectorParameters ap, float aprilTagMaxLineFitMse, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->aprilTagMaxLineFitMse = aprilTagMaxLineFitMse;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAprilTagMaxLineFitMse_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    float value = ap.ptr->aprilTagMaxLineFitMse;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiff_Async(ArucoDetectorParameters ap, int aprilTagMinWhiteBlackDiff, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->aprilTagMinWhiteBlackDiff = aprilTagMinWhiteBlackDiff;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAprilTagMinWhiteBlackDiff_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->aprilTagMinWhiteBlackDiff;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetAprilTagDeglitch_Async(ArucoDetectorParameters ap, int aprilTagDeglitch, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->aprilTagDeglitch = aprilTagDeglitch;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetAprilTagDeglitch_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    int value = ap.ptr->aprilTagDeglitch;
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_SetDetectInvertedMarker_Async(ArucoDetectorParameters ap, bool detectInvertedMarker, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    ap.ptr->detectInvertedMarker = detectInvertedMarker;
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoDetectorParameters_GetDetectInvertedMarker_Async(ArucoDetectorParameters ap, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    bool value = ap.ptr->detectInvertedMarker;
+    callback(&value);
+    END_WRAP
+}
+
+// Detector
+CvStatus *ArucoDetector_New_Async(CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    auto detector = new cv::aruco::ArucoDetector();
+    callback(new ArucoDetector{detector});
+    END_WRAP
+}
+
+CvStatus *ArucoDetector_NewWithParams_Async(ArucoDictionary dictionary, ArucoDetectorParameters params, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    auto detector = new cv::aruco::ArucoDetector(*dictionary.ptr, *params.ptr);
+    callback(new ArucoDetector{detector});
+    END_WRAP
+}
+
+CvStatus *ArucoDetector_DetectMarkers_Async(ArucoDetector ad, Mat inputArr, CvCallback_3 callback)
+{
+    BEGIN_WRAP
+    std::vector<std::vector<cv::Point2f>> markerCorners;
+    std::vector<int> markerIds;
+    std::vector<std::vector<cv::Point2f>> rejectedCandidates;
+    ad.ptr->detectMarkers(*inputArr.ptr, markerCorners, markerIds, rejectedCandidates);
+    callback(new VecVecPoint2f{new std::vector<std::vector<cv::Point2f>>(markerCorners)}, new VecInt{new std::vector<int>(markerIds)}, new VecVecPoint2f{new std::vector<std::vector<cv::Point2f>>(rejectedCandidates)});
+    END_WRAP
+}
+
+// Utility Functions
+CvStatus *ArucoDrawDetectedMarkers_Async(Mat image, VecVecPoint2f markerCorners, VecInt markerIds, Scalar borderColor, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    cv::Scalar _borderColor = cv::Scalar(borderColor.val1, borderColor.val2, borderColor.val3);
+    cv::aruco::drawDetectedMarkers(*image.ptr, *markerCorners.ptr, *markerIds.ptr, _borderColor);
+    callback();
+    END_WRAP
+}
+
+CvStatus *ArucoGenerateImageMarker_Async(int dictionaryId, int id, int sidePixels, int borderBits, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    cv::aruco::Dictionary dict = cv::aruco::getPredefinedDictionary(dictionaryId);
+    cv::Mat dst;
+    cv::aruco::generateImageMarker(dict, id, sidePixels, dst, borderBits);
+    callback(new Mat {new cv::Mat(dst)});
+    END_WRAP
+}
+
+CvStatus *getPredefinedDictionary_Async(int dictionaryId, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    auto dict = new cv::aruco::Dictionary(cv::aruco::getPredefinedDictionary(dictionaryId));
+    callback(new ArucoDictionary{dict});
+    END_WRAP
+}
diff --git a/src/extra/aruco_async.h b/src/extra/aruco_async.h
new file mode 100644
index 00000000..81f1b5af
--- /dev/null
+++ b/src/extra/aruco_async.h
@@ -0,0 +1,82 @@
+#pragma once
+#include "core/types.h"
+#include "aruco.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Detector Parameters
+CvStatus *ArucoDetectorParameters_Create_Async(CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAdaptiveThreshWinSizeMin_Async(ArucoDetectorParameters ap, int adaptiveThreshWinSizeMin, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAdaptiveThreshWinSizeMin_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAdaptiveThreshWinSizeMax_Async(ArucoDetectorParameters ap, int adaptiveThreshWinSizeMax, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAdaptiveThreshWinSizeMax_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAdaptiveThreshWinSizeStep_Async(ArucoDetectorParameters ap, int adaptiveThreshWinSizeStep, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAdaptiveThreshWinSizeStep_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAdaptiveThreshConstant_Async(ArucoDetectorParameters ap, double adaptiveThreshConstant, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAdaptiveThreshConstant_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetMinMarkerPerimeterRate_Async(ArucoDetectorParameters ap, double minMarkerPerimeterRate, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetMinMarkerPerimeterRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetMaxMarkerPerimeterRate_Async(ArucoDetectorParameters ap, double maxMarkerPerimeterRate, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetMaxMarkerPerimeterRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetPolygonalApproxAccuracyRate_Async(ArucoDetectorParameters ap, double polygonalApproxAccuracyRate, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetPolygonalApproxAccuracyRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetMinCornerDistanceRate_Async(ArucoDetectorParameters ap, double minCornerDistanceRate, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetMinCornerDistanceRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetMinDistanceToBorder_Async(ArucoDetectorParameters ap, int minDistanceToBorder, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetMinDistanceToBorder_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetMinMarkerDistanceRate_Async(ArucoDetectorParameters ap, double minMarkerDistanceRate, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetMinMarkerDistanceRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetCornerRefinementMethod_Async(ArucoDetectorParameters ap, int cornerRefinementMethod, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetCornerRefinementMethod_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetCornerRefinementWinSize_Async(ArucoDetectorParameters ap, int cornerRefinementWinSize, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetCornerRefinementWinSize_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetCornerRefinementMaxIterations_Async(ArucoDetectorParameters ap, int cornerRefinementMaxIterations, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetCornerRefinementMaxIterations_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetCornerRefinementMinAccuracy_Async(ArucoDetectorParameters ap, double cornerRefinementMinAccuracy, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetCornerRefinementMinAccuracy_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetMarkerBorderBits_Async(ArucoDetectorParameters ap, int markerBorderBits, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetMarkerBorderBits_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetPerspectiveRemovePixelPerCell_Async(ArucoDetectorParameters ap, int perspectiveRemovePixelPerCell, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetPerspectiveRemovePixelPerCell_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetPerspectiveRemoveIgnoredMarginPerCell_Async(ArucoDetectorParameters ap, double perspectiveRemoveIgnoredMarginPerCell, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetPerspectiveRemoveIgnoredMarginPerCell_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetMaxErroneousBitsInBorderRate_Async(ArucoDetectorParameters ap, double maxErroneousBitsInBorderRate, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetMaxErroneousBitsInBorderRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetMinOtsuStdDev_Async(ArucoDetectorParameters ap, double minOtsuStdDev, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetMinOtsuStdDev_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetErrorCorrectionRate_Async(ArucoDetectorParameters ap, double errorCorrectionRate, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetErrorCorrectionRate_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAprilTagQuadDecimate_Async(ArucoDetectorParameters ap, float aprilTagQuadDecimate, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAprilTagQuadDecimate_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAprilTagQuadSigma_Async(ArucoDetectorParameters ap, float aprilTagQuadSigma, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAprilTagQuadSigma_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAprilTagMinClusterPixels_Async(ArucoDetectorParameters ap, int aprilTagMinClusterPixels, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAprilTagMinClusterPixels_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAprilTagMaxNmaxima_Async(ArucoDetectorParameters ap, int aprilTagMaxNmaxima, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAprilTagMaxNmaxima_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAprilTagCriticalRad_Async(ArucoDetectorParameters ap, float aprilTagCriticalRad, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAprilTagCriticalRad_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAprilTagMaxLineFitMse_Async(ArucoDetectorParameters ap, float aprilTagMaxLineFitMse, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAprilTagMaxLineFitMse_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAprilTagMinWhiteBlackDiff_Async(ArucoDetectorParameters ap, int aprilTagMinWhiteBlackDiff, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAprilTagMinWhiteBlackDiff_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetAprilTagDeglitch_Async(ArucoDetectorParameters ap, int aprilTagDeglitch, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetAprilTagDeglitch_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+CvStatus *ArucoDetectorParameters_SetDetectInvertedMarker_Async(ArucoDetectorParameters ap, bool detectInvertedMarker, CvCallback_0 callback);
+CvStatus *ArucoDetectorParameters_GetDetectInvertedMarker_Async(ArucoDetectorParameters ap, CvCallback_1 callback);
+
+// Detector
+CvStatus *ArucoDetector_New_Async(CvCallback_1 callback);
+CvStatus *ArucoDetector_NewWithParams_Async(ArucoDictionary dictionary, ArucoDetectorParameters params, CvCallback_1 callback);
+CvStatus *ArucoDetector_DetectMarkers_Async(ArucoDetector ad, Mat inputArr, CvCallback_3 callback);
+
+// Utility Functions
+CvStatus *ArucoDrawDetectedMarkers_Async(Mat image, VecVecPoint2f markerCorners, VecInt markerIds, Scalar borderColor, CvCallback_0 callback);
+CvStatus *ArucoGenerateImageMarker_Async(int dictionaryId, int id, int sidePixels, int borderBits, CvCallback_1 callback);
+CvStatus *getPredefinedDictionary_Async(int dictionaryId, CvCallback_1 callback);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/extra/img_hash.cpp b/src/extra/img_hash.cpp
index 47470623..ff40bd13 100644
--- a/src/extra/img_hash.cpp
+++ b/src/extra/img_hash.cpp
@@ -1,114 +1,112 @@
 #include "img_hash.h"
 
-CvStatus *pHashCompute(Mat inputArr, Mat outputArr)
-{
+CvStatus *pHashCompute(Mat inputArr, Mat *outputArr) {
   BEGIN_WRAP
-  cv::img_hash::pHash(*inputArr.ptr, *outputArr.ptr);
+  cv::Mat dst;
+  cv::img_hash::pHash(*inputArr.ptr, dst);
+  *outputArr = {new cv::Mat(dst)};
   END_WRAP
 }
-CvStatus *pHashCompare(Mat a, Mat b, double *rval)
-{
+CvStatus *pHashCompare(Mat a, Mat b, double *rval) {
   BEGIN_WRAP
   *rval = cv::img_hash::PHash::create()->compare(*a.ptr, *b.ptr);
   END_WRAP
 }
 
-CvStatus *averageHashCompute(Mat inputArr, Mat outputArr)
-{
+CvStatus *averageHashCompute(Mat inputArr, Mat *outputArr) {
   BEGIN_WRAP
-  cv::img_hash::averageHash(*inputArr.ptr, *outputArr.ptr);
+  cv::Mat dst;
+  cv::img_hash::averageHash(*inputArr.ptr, dst);
+  *outputArr = {new cv::Mat(dst)};
   END_WRAP
 }
-CvStatus *averageHashCompare(Mat a, Mat b, double *rval)
-{
+CvStatus *averageHashCompare(Mat a, Mat b, double *rval) {
   BEGIN_WRAP
   *rval = cv::img_hash::AverageHash::create()->compare(*a.ptr, *b.ptr);
   END_WRAP
 }
 
-CvStatus *BlockMeanHash_Create(int mode, BlockMeanHash *rval)
-{
+CvStatus *BlockMeanHash_Create(int mode, BlockMeanHash *rval) {
   BEGIN_WRAP
   *rval = {new cv::Ptr<cv::img_hash::BlockMeanHash>(cv::img_hash::BlockMeanHash::create(mode))};
   END_WRAP
 }
-CvStatus *BlockMeanHash_GetMean(BlockMeanHash self, double **rval, int *length)
-{
+CvStatus *BlockMeanHash_GetMean(BlockMeanHash self, double **rval, int *length) {
   BEGIN_WRAP
   auto m = (*self.ptr)->getMean();
   *rval = m.data();
   *length = m.size();
   END_WRAP
 }
-CvStatus *BlockMeanHash_SetMode(BlockMeanHash self, int mode)
-{
+CvStatus *BlockMeanHash_SetMode(BlockMeanHash self, int mode) {
   BEGIN_WRAP(*self.ptr)->setMode(mode);
   END_WRAP
 }
-void BlockMeanHash_Close(BlockMeanHashPtr self)
-{
+void BlockMeanHash_Close(BlockMeanHashPtr self) {
   self->ptr->reset();
   CVD_FREE(self);
 }
 
-CvStatus *BlockMeanHash_Compute(BlockMeanHash self, Mat inputArr, Mat outputArr)
-{
-  BEGIN_WRAP(self.ptr)->get()->compute(*inputArr.ptr, *outputArr.ptr);
+CvStatus *BlockMeanHash_Compute(BlockMeanHash self, Mat inputArr, Mat *outputArr) {
+  BEGIN_WRAP
+  cv::Mat dst;
+  (self.ptr)->get()->compute(*inputArr.ptr, dst);
+  *outputArr = {new cv::Mat(dst)};
   END_WRAP
 }
-CvStatus *BlockMeanHash_Compare(BlockMeanHash self, Mat hashOne, Mat hashTwo, double *rval)
-{
+CvStatus *BlockMeanHash_Compare(BlockMeanHash self, Mat hashOne, Mat hashTwo, double *rval) {
   BEGIN_WRAP
   *rval = (self.ptr)->get()->compare(*hashOne.ptr, *hashTwo.ptr);
   END_WRAP
 }
-CvStatus *blockMeanHashCompute(Mat inputArr, Mat outputArr, int mode)
-{
+CvStatus *blockMeanHashCompute(Mat inputArr, Mat *outputArr, int mode) {
   BEGIN_WRAP
-  cv::img_hash::blockMeanHash(*inputArr.ptr, *outputArr.ptr, mode);
+  cv::Mat dst;
+  cv::img_hash::blockMeanHash(*inputArr.ptr, dst, mode);
+  *outputArr = {new cv::Mat(dst)};
   END_WRAP
 }
-CvStatus *blockMeanHashCompare(Mat a, Mat b, int mode, double *rval)
-{
+CvStatus *blockMeanHashCompare(Mat a, Mat b, int mode, double *rval) {
   BEGIN_WRAP
   *rval = cv::img_hash::BlockMeanHash::create(mode)->compare(*a.ptr, *b.ptr);
   END_WRAP
 }
 
-CvStatus *colorMomentHashCompute(Mat inputArr, Mat outputArr)
-{
+CvStatus *colorMomentHashCompute(Mat inputArr, Mat *outputArr) {
   BEGIN_WRAP
-  cv::img_hash::colorMomentHash(*inputArr.ptr, *outputArr.ptr);
+  cv::Mat dst;
+  cv::img_hash::colorMomentHash(*inputArr.ptr, dst);
+  *outputArr = {new cv::Mat(dst)};
   END_WRAP
 }
-CvStatus *colorMomentHashCompare(Mat a, Mat b, double *rval)
-{
+CvStatus *colorMomentHashCompare(Mat a, Mat b, double *rval) {
   BEGIN_WRAP
   *rval = cv::img_hash::ColorMomentHash::create()->compare(*a.ptr, *b.ptr);
   END_WRAP
 }
 
-CvStatus *marrHildrethHashCompute(Mat inputArr, Mat outputArr, float alpha, float scale)
-{
+CvStatus *marrHildrethHashCompute(Mat inputArr, Mat *outputArr, float alpha, float scale) {
   BEGIN_WRAP
-  cv::img_hash::marrHildrethHash(*inputArr.ptr, *outputArr.ptr, alpha, scale);
+  cv::Mat dst;
+  cv::img_hash::marrHildrethHash(*inputArr.ptr, dst, alpha, scale);
+  *outputArr = {new cv::Mat(dst)};
   END_WRAP
 }
-CvStatus *marrHildrethHashCompare(Mat a, Mat b, float alpha, float scale, double *rval)
-{
+CvStatus *marrHildrethHashCompare(Mat a, Mat b, float alpha, float scale, double *rval) {
   BEGIN_WRAP
   *rval = cv::img_hash::MarrHildrethHash::create(alpha, scale)->compare(*a.ptr, *b.ptr);
   END_WRAP
 }
 
-CvStatus *radialVarianceHashCompute(Mat inputArr, Mat outputArr, double sigma, int numOfAngleLine)
-{
+CvStatus *
+radialVarianceHashCompute(Mat inputArr, Mat *outputArr, double sigma, int numOfAngleLine) {
   BEGIN_WRAP
-  cv::img_hash::radialVarianceHash(*inputArr.ptr, *outputArr.ptr, sigma, numOfAngleLine);
+  cv::Mat dst;
+  cv::img_hash::radialVarianceHash(*inputArr.ptr, dst, sigma, numOfAngleLine);
+  *outputArr = {new cv::Mat(dst)};
   END_WRAP
 }
-CvStatus *radialVarianceHashCompare(Mat a, Mat b, double sigma, int numOfAngleLine, double *rval)
-{
+CvStatus *radialVarianceHashCompare(Mat a, Mat b, double sigma, int numOfAngleLine, double *rval) {
   BEGIN_WRAP
   *rval = cv::img_hash::RadialVarianceHash::create(sigma, numOfAngleLine)->compare(*a.ptr, *b.ptr);
   END_WRAP
diff --git a/src/extra/img_hash.h b/src/extra/img_hash.h
index b326e289..593490f6 100644
--- a/src/extra/img_hash.h
+++ b/src/extra/img_hash.h
@@ -38,28 +38,28 @@ enum {
   BLOCK_MEAN_HASH_MODE_1 = 1
 };
 
-CvStatus *pHashCompute(Mat inputArr, Mat outputArr);
+CvStatus *pHashCompute(Mat inputArr, Mat *outputArr);
 CvStatus *pHashCompare(Mat a, Mat b, double *rval);
 
-CvStatus *averageHashCompute(Mat inputArr, Mat outputArr);
+CvStatus *averageHashCompute(Mat inputArr, Mat *outputArr);
 CvStatus *averageHashCompare(Mat a, Mat b, double *rval);
 
 CvStatus *BlockMeanHash_Create(int mode, BlockMeanHash *rval);
 CvStatus *BlockMeanHash_GetMean(BlockMeanHash self, double **rval, int *length);
 CvStatus *BlockMeanHash_SetMode(BlockMeanHash self, int mode);
-void      BlockMeanHash_Close(BlockMeanHashPtr self);
-CvStatus *BlockMeanHash_Compute(BlockMeanHash self, Mat inputArr, Mat outputArr);
+void BlockMeanHash_Close(BlockMeanHashPtr self);
+CvStatus *BlockMeanHash_Compute(BlockMeanHash self, Mat inputArr, Mat *outputArr);
 CvStatus *BlockMeanHash_Compare(BlockMeanHash self, Mat hashOne, Mat hashTwo, double *rval);
-CvStatus *blockMeanHashCompute(Mat inputArr, Mat outputArr, int mode);
+CvStatus *blockMeanHashCompute(Mat inputArr, Mat *outputArr, int mode);
 CvStatus *blockMeanHashCompare(Mat a, Mat b, int mode, double *rval);
 
-CvStatus *colorMomentHashCompute(Mat inputArr, Mat outputArr);
+CvStatus *colorMomentHashCompute(Mat inputArr, Mat *outputArr);
 CvStatus *colorMomentHashCompare(Mat a, Mat b, double *rval);
 
-CvStatus *marrHildrethHashCompute(Mat inputArr, Mat outputArr, float alpha, float scale);
+CvStatus *marrHildrethHashCompute(Mat inputArr, Mat *outputArr, float alpha, float scale);
 CvStatus *marrHildrethHashCompare(Mat a, Mat b, float alpha, float scale, double *rval);
 
-CvStatus *radialVarianceHashCompute(Mat inputArr, Mat outputArr, double sigma, int numOfAngleLine);
+CvStatus *radialVarianceHashCompute(Mat inputArr, Mat *outputArr, double sigma, int numOfAngleLine);
 CvStatus *radialVarianceHashCompare(Mat a, Mat b, double sigma, int numOfAngleLine, double *rval);
 
 #ifdef __cplusplus
diff --git a/src/extra/img_hash_async.cpp b/src/extra/img_hash_async.cpp
new file mode 100644
index 00000000..20a4bc5a
--- /dev/null
+++ b/src/extra/img_hash_async.cpp
@@ -0,0 +1,115 @@
+#include "img_hash_async.h"
+#include "core/types.h"
+
+// Asynchronous functions for Image Hashing
+
+CvStatus *pHashCompute_Async(Mat inputArr,  CvCallback_1 callback) {
+    BEGIN_WRAP
+    cv::Mat dst;
+    cv::img_hash::pHash(*inputArr.ptr, dst);
+    callback(new Mat{new cv::Mat(dst)});
+    END_WRAP
+}
+
+CvStatus *pHashCompare_Async(Mat a, Mat b, CvCallback_1 callback) {
+    BEGIN_WRAP
+    double result = cv::img_hash::PHash::create()->compare(*a.ptr, *b.ptr);
+    callback(new double(result));
+    END_WRAP
+}
+
+CvStatus *averageHashCompute_Async(Mat inputArr,  CvCallback_1 callback) {
+    BEGIN_WRAP
+    cv::Mat dst;
+    cv::img_hash::averageHash(*inputArr.ptr, dst);
+    callback(new Mat{new cv::Mat(dst)});
+    END_WRAP
+}
+
+CvStatus *averageHashCompare_Async(Mat a, Mat b, CvCallback_1 callback) {
+    BEGIN_WRAP
+    double result = cv::img_hash::AverageHash::create()->compare(*a.ptr, *b.ptr);
+    callback(new double(result));
+    END_WRAP
+}
+
+CvStatus *BlockMeanHash_Create_Async(int mode, CvCallback_1 callback) {
+    BEGIN_WRAP
+    auto hash = new cv::Ptr<cv::img_hash::BlockMeanHash>(cv::img_hash::BlockMeanHash::create(mode));
+    callback(new BlockMeanHash{hash});
+    END_WRAP
+}
+
+CvStatus *BlockMeanHash_GetMean_Async(BlockMeanHash self, CvCallback_1 callback) {
+    BEGIN_WRAP
+    auto vec = self.ptr->get()->getMean();
+    callback(new VecDouble{new std::vector<double>(vec)});
+    END_WRAP
+}
+
+CvStatus *BlockMeanHash_SetMode_Async(BlockMeanHash self, int mode, CvCallback_0 callback) {
+    BEGIN_WRAP
+    (*self.ptr)->setMode(mode);
+    callback();
+    END_WRAP
+}
+
+CvStatus *BlockMeanHash_Compute_Async(BlockMeanHash self, Mat inputArr,  CvCallback_1 callback) {
+    BEGIN_WRAP
+    cv::Mat dst;
+    self.ptr->get()->compute(*inputArr.ptr, dst);
+    callback(new Mat{new cv::Mat(dst)});
+    END_WRAP
+}
+
+CvStatus *BlockMeanHash_Compare_Async(BlockMeanHash self, Mat hashOne, Mat hashTwo, CvCallback_1 callback) {
+    BEGIN_WRAP
+    double result = self.ptr->get()->compare(*hashOne.ptr, *hashTwo.ptr);
+    callback(new double(result));
+    END_WRAP
+}
+
+CvStatus *colorMomentHashCompute_Async(Mat inputArr,  CvCallback_1 callback) {
+    BEGIN_WRAP
+    cv::Mat dst;
+    cv::img_hash::colorMomentHash(*inputArr.ptr, dst);
+    callback(new Mat{new cv::Mat(dst)});
+    END_WRAP
+}
+
+CvStatus *colorMomentHashCompare_Async(Mat a, Mat b, CvCallback_1 callback) {
+    BEGIN_WRAP
+    double result = cv::img_hash::ColorMomentHash::create()->compare(*a.ptr, *b.ptr);
+    callback(new double(result));
+    END_WRAP
+}
+
+CvStatus *marrHildrethHashCompute_Async(Mat inputArr,  float alpha, float scale, CvCallback_1 callback) {
+    BEGIN_WRAP
+    cv::Mat dst;
+    cv::img_hash::marrHildrethHash(*inputArr.ptr, dst, alpha, scale);
+    callback(new Mat{new cv::Mat(dst)});
+    END_WRAP
+}
+
+CvStatus *marrHildrethHashCompare_Async(Mat a, Mat b, float alpha, float scale, CvCallback_1 callback) {
+    BEGIN_WRAP
+    double result = cv::img_hash::MarrHildrethHash::create(alpha, scale)->compare(*a.ptr, *b.ptr);
+    callback(new double(result));
+    END_WRAP
+}
+
+CvStatus *radialVarianceHashCompute_Async(Mat inputArr,  double sigma, int numOfAngleLine, CvCallback_1 callback) {
+    BEGIN_WRAP
+    cv::Mat dst;
+    cv::img_hash::radialVarianceHash(*inputArr.ptr, dst, sigma, numOfAngleLine);
+    callback(new Mat{new cv::Mat(dst)});
+    END_WRAP
+}
+
+CvStatus *radialVarianceHashCompare_Async(Mat a, Mat b, double sigma, int numOfAngleLine, CvCallback_1 callback) {
+    BEGIN_WRAP
+    double result = cv::img_hash::RadialVarianceHash::create(sigma, numOfAngleLine)->compare(*a.ptr, *b.ptr);
+    callback(new double(result));
+    END_WRAP
+}
diff --git a/src/extra/img_hash_async.h b/src/extra/img_hash_async.h
new file mode 100644
index 00000000..55961a85
--- /dev/null
+++ b/src/extra/img_hash_async.h
@@ -0,0 +1,29 @@
+#pragma once
+#include "core/types.h"
+#include "img_hash.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+CvStatus *pHashCompute_Async(Mat inputArr,  CvCallback_1 callback);
+CvStatus *pHashCompare_Async(Mat a, Mat b, CvCallback_1 callback);
+CvStatus *averageHashCompute_Async(Mat inputArr,  CvCallback_1 callback);
+CvStatus *averageHashCompare_Async(Mat a, Mat b, CvCallback_1 callback);
+
+CvStatus *BlockMeanHash_Create_Async(int mode, CvCallback_1 callback);
+CvStatus *BlockMeanHash_GetMean_Async(BlockMeanHash self, CvCallback_1 callback);
+CvStatus *BlockMeanHash_SetMode_Async(BlockMeanHash self, int mode, CvCallback_0 callback);
+CvStatus *BlockMeanHash_Compute_Async(BlockMeanHash self, Mat inputArr,  CvCallback_1 callback);
+CvStatus *BlockMeanHash_Compare_Async(BlockMeanHash self, Mat hashOne, Mat hashTwo, CvCallback_1 callback);
+
+CvStatus *colorMomentHashCompute_Async(Mat inputArr,  CvCallback_1 callback);
+CvStatus *colorMomentHashCompare_Async(Mat a, Mat b, CvCallback_1 callback);
+CvStatus *marrHildrethHashCompute_Async(Mat inputArr,  float alpha, float scale, CvCallback_1 callback);
+CvStatus *marrHildrethHashCompare_Async(Mat a, Mat b, float alpha, float scale, CvCallback_1 callback);
+CvStatus *radialVarianceHashCompute_Async(Mat inputArr,  double sigma, int numOfAngleLine, CvCallback_1 callback);
+CvStatus *radialVarianceHashCompare_Async(Mat a, Mat b, double sigma, int numOfAngleLine, CvCallback_1 callback);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/extra/wechat_qrcode_async.cpp b/src/extra/wechat_qrcode_async.cpp
new file mode 100644
index 00000000..394eb898
--- /dev/null
+++ b/src/extra/wechat_qrcode_async.cpp
@@ -0,0 +1,49 @@
+#include "wechat_qrcode_async.h"
+#include "core/types.h"
+
+CvStatus *WeChatQRCode_New_Async(CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    auto qrcode = new cv::wechat_qrcode::WeChatQRCode();
+    callback(new WeChatQRCode{qrcode});
+    END_WRAP
+}
+
+CvStatus *WeChatQRCode_NewWithParams_Async(const char *detector_prototxt_path, const char *detector_caffe_model_path, const char *super_resolution_prototxt_path, const char *super_resolution_caffe_model_path, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    auto qrcode = new cv::wechat_qrcode::WeChatQRCode(detector_prototxt_path, detector_caffe_model_path, super_resolution_prototxt_path, super_resolution_caffe_model_path);
+    callback(new WeChatQRCode{qrcode});
+    END_WRAP
+}
+
+CvStatus *WeChatQRCode_DetectAndDecode_Async(WeChatQRCode *self, Mat img, CvCallback_2 callback)
+{
+    BEGIN_WRAP
+    std::vector<cv::Mat> points;
+    auto strings = self->ptr->detectAndDecode(*img.ptr, points);
+    std::vector<std::vector<char>> cstrings;
+    cstrings.reserve(strings.size());
+    for (const auto &s : strings)
+    {
+        cstrings.push_back(std::vector<char>(s.begin(), s.end()));
+    }
+    callback(new VecVecChar{new std::vector<std::vector<char>>(cstrings)}, new VecMat{new std::vector<cv::Mat>(points)});
+    END_WRAP
+}
+
+CvStatus *WeChatQRCode_GetScaleFactor_Async(WeChatQRCode *self, CvCallback_1 callback)
+{
+    BEGIN_WRAP
+    float value = self->ptr->getScaleFactor();
+    callback(&value);
+    END_WRAP
+}
+
+CvStatus *WeChatQRCode_SetScaleFactor_Async(WeChatQRCode *self, float scale_factor, CvCallback_0 callback)
+{
+    BEGIN_WRAP
+    self->ptr->setScaleFactor(scale_factor);
+    callback();
+    END_WRAP
+}
diff --git a/src/extra/wechat_qrcode_async.h b/src/extra/wechat_qrcode_async.h
new file mode 100644
index 00000000..050d64ed
--- /dev/null
+++ b/src/extra/wechat_qrcode_async.h
@@ -0,0 +1,18 @@
+#pragma once
+#include "core/types.h"
+#include "wechat_qrcode.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    CvStatus *WeChatQRCode_New_Async(CvCallback_1 callback);
+    CvStatus *WeChatQRCode_NewWithParams_Async(const char *detector_prototxt_path, const char *detector_caffe_model_path, const char *super_resolution_prototxt_path, const char *super_resolution_caffe_model_path, CvCallback_1 callback);
+    CvStatus *WeChatQRCode_DetectAndDecode_Async(WeChatQRCode *self, Mat img, CvCallback_2 callback);
+    CvStatus *WeChatQRCode_GetScaleFactor_Async(WeChatQRCode *self, CvCallback_1 callback);
+    CvStatus *WeChatQRCode_SetScaleFactor_Async(WeChatQRCode *self, float scale_factor, CvCallback_0 callback);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/test/contrib/aruco_async_test.dart b/test/contrib/aruco_async_test.dart
new file mode 100644
index 00000000..acef9f0d
--- /dev/null
+++ b/test/contrib/aruco_async_test.dart
@@ -0,0 +1,66 @@
+// ignore_for_file: constant_identifier_names
+import 'package:opencv_dart/opencv_dart.dart' as cv;
+import 'package:test/test.dart';
+
+const arucoImage6x6_250 = "test/images/aruco_6X6_250_6.png";
+const arucoImage6x6_250_contour = "test/images/aruco_6X6_250_6_contour.png";
+const arucoImage6x6_250_1 = "test/images/aruco_6X6_250_1.png";
+
+void main() async {
+  test('cv.ArucoDetector', () async {
+    final img = cv.imread(arucoImage6x6_250);
+    expect(img.isEmpty, false);
+
+    final dict = cv.ArucoDictionary.predefined(cv.PredefinedDictionaryType.DICT_6X6_250);
+    final params = cv.ArucoDetectorParameters.empty();
+    final detector = await cv.ArucoDetectorAsync.createAsync(dict, params);
+
+    final (_, ids, _) = await detector.detectMarkersAsync(img);
+    expect(ids, isNotEmpty);
+
+    dict.dispose();
+    params.dispose();
+    img.dispose();
+    detector.dispose();
+  });
+
+  test('cv.arucoDrawDetectedMarkers', () async {
+    final img = cv.imread(arucoImage6x6_250);
+    expect(img.isEmpty, false);
+    final imgExpected = cv.imread(arucoImage6x6_250_contour);
+    expect(imgExpected.isEmpty, false);
+
+    final dict = cv.ArucoDictionary.predefined(cv.PredefinedDictionaryType.DICT_6X6_250);
+    final params = cv.ArucoDetectorParameters.empty();
+    final detector = await cv.ArucoDetectorAsync.createAsync(dict, params);
+
+    final (corners, ids, _) = await detector.detectMarkersAsync(img);
+    expect(corners.length, greaterThan(0));
+    await cv.arucoDrawDetectedMarkersAsync(
+      img,
+      corners,
+      ids,
+      cv.Scalar(200, 0, 0, 0),
+    );
+    var diff = cv.Mat.empty();
+    cv.absDiff(img, imgExpected, diff);
+    diff = cv.cvtColor(diff, cv.COLOR_BGR2GRAY);
+    expect(cv.countNonZero(diff), 0);
+  });
+
+  test('cv.arucoGenerateImageMarker', () async {
+    final imgExpected = cv.imread(arucoImage6x6_250_1, flags: cv.IMREAD_GRAYSCALE);
+    expect(imgExpected.isEmpty, false);
+
+    final img = await cv.arucoGenerateImageMarkerAsync(
+      cv.PredefinedDictionaryType.DICT_6X6_250,
+      1,
+      200,
+      1,
+    );
+
+    final diff = cv.Mat.empty();
+    cv.absDiff(img, imgExpected, diff);
+    expect(cv.countNonZero(diff), 0);
+  });
+}
diff --git a/test/contrib/aruco_test.dart b/test/contrib/aruco_test.dart
index 09d3a50a..fc795c87 100644
--- a/test/contrib/aruco_test.dart
+++ b/test/contrib/aruco_test.dart
@@ -47,8 +47,7 @@ void main() async {
     final imgExpected = cv.imread(arucoImage6x6_250_1, flags: cv.IMREAD_GRAYSCALE);
     expect(imgExpected.isEmpty, false);
 
-    final img = cv.Mat.empty();
-    cv.arucoGenerateImageMarker(cv.PredefinedDictionaryType.DICT_6X6_250, 1, 200, img, 1);
+    final img = cv.arucoGenerateImageMarker(cv.PredefinedDictionaryType.DICT_6X6_250, 1, 200, 1);
 
     final diff = cv.Mat.empty();
     cv.absDiff(img, imgExpected, diff);
diff --git a/test/contrib/img_hash_async_test.dart b/test/contrib/img_hash_async_test.dart
new file mode 100644
index 00000000..dcc9dcf4
--- /dev/null
+++ b/test/contrib/img_hash_async_test.dart
@@ -0,0 +1,89 @@
+import 'package:opencv_dart/opencv_dart.dart' as cv;
+import 'package:test/test.dart';
+
+const testImage = "test/images/space_shuttle.jpg";
+const testImage2 = "test/images/toy.jpg";
+
+Future<cv.Mat> computeHashAsync(String imagePath, cv.ImgHashBase hashAlgorithm) async {
+  final img = cv.imread(imagePath, flags: cv.IMREAD_COLOR);
+  expect(img.isEmpty, false);
+
+  final cv.Mat dst = await hashAlgorithm.computeAsync(img);
+  expect(dst.isEmpty, false);
+
+  return dst;
+}
+
+Future<void> testHashAsync(cv.ImgHashBase hashAlgorithm) async {
+  final hash1 = await computeHashAsync(testImage, hashAlgorithm);
+  expect(hash1.isEmpty, false);
+
+  final hash2 = await computeHashAsync(testImage2, hashAlgorithm);
+  expect(hash2.isEmpty, false);
+
+  // // The range and meaning of this value varies between algorithms, and
+  // // there doesn't seem to be a well defined set of default thresholds, so
+  // // "anything but zero" is the minimum smoke test.
+  final similarity = await hashAlgorithm.compareAsync(hash1, hash2);
+  expect(similarity, isNot(equals(0)));
+}
+
+void main() async {
+  test('cv.PHash', () async => await testHashAsync(cv.PHash()));
+  test('cv.AverageHash', () async => testHashAsync(cv.AverageHash()));
+  test('cv.BlockMeanHash', () async => testHashAsync(cv.BlockMeanHash()));
+  test('cv.ColorMomentHash', () async => testHashAsync(cv.ColorMomentHash()));
+  test('cv.NewMarrHildrethHash', () async => testHashAsync(cv.NewMarrHildrethHash()));
+  test('cv.NewRadialVarianceHash', () async => testHashAsync(cv.NewRadialVarianceHash()));
+
+  test("cv.BlockMeanHash more", () async {
+    final bmh = cv.BlockMeanHash();
+    final img = cv.Mat.ones(256, 256, cv.MatType.CV_8UC1);
+    for (var i = 0; i < img.rows; i++) {
+      for (var j = 0; j < img.cols; j++) {
+        img.set<cv.U8>(i, j, i + j);
+      }
+    }
+    final hash = await bmh.computeAsync(img);
+    final expectedHash = [
+      0,
+      255,
+      128,
+      127,
+      192,
+      63,
+      224,
+      31,
+      240,
+      15,
+      248,
+      7,
+      252,
+      3,
+      254,
+      1,
+      255,
+      0,
+      127,
+      128,
+      63,
+      192,
+      31,
+      224,
+      15,
+      240,
+      7,
+      248,
+      3,
+      252,
+      1,
+      254,
+    ];
+    expect(hash.toList()[0], expectedHash);
+    final mean = await bmh.getMeanAsync();
+    bmh.mode = cv.BLOCK_MEAN_HASH_MODE_1;
+    expect(mean.length, greaterThan(0));
+
+    bmh.dispose();
+  });
+}
diff --git a/test/contrib/wechat_qrcode_async_test.dart b/test/contrib/wechat_qrcode_async_test.dart
new file mode 100644
index 00000000..3fbd9060
--- /dev/null
+++ b/test/contrib/wechat_qrcode_async_test.dart
@@ -0,0 +1,35 @@
+import 'package:opencv_dart/opencv_dart.dart' as cv;
+import 'package:test/test.dart';
+
+void main() {
+  test('cv.WeChatQRCode.empty', () async {
+    final qr = await cv.WeChatQRCodeAsync.emptyAsync();
+    expect(qr.ptr, isNotNull);
+    final (res, points) = await qr.detectAndDecodeAsync(cv.imread("test/images/qrcode.png"));
+    expect(res.length, 1);
+    expect(res.first, "Hello World!");
+    expect(points.length, 1);
+
+    qr.dispose();
+  });
+
+  test('cv.WeChatQRCode', tags: ["no-local-files"], () async {
+    final qr = await cv.WeChatQRCodeAsync.createAsync(
+      "test/models/detect.prototxt",
+      "test/models/detect.caffemodel",
+      "test/models/sr.prototxt",
+      "test/models/sr.caffemodel",
+    );
+    expect(qr.ptr, isNotNull);
+    final (res, points) = await qr.detectAndDecodeAsync(cv.imread("test/images/multi_qrcodes.png"));
+    expect(res.length, 2);
+    expect(points.length, 2);
+    expect(res, ["bar", "foo"]);
+
+    expect(qr.scaleFactor, closeTo(-1.0, 1e-3));
+    qr.scaleFactor = 0.5;
+    expect(qr.scaleFactor, closeTo(0.5, 1e-3));
+    qr.scaleFactor = 1.5;
+    expect(qr.scaleFactor, closeTo(-1.0, 1e-3));
+  });
+}