// ignore_for_file: non_constant_identifier_names, camel_case_types, missing_return, unused_import, unused_local_variable, dead_code, unnecessary_cast
//////////////////////////////////////////////////////////
// GENERATED BY FLUTTIFY. DO NOT EDIT IT.
//////////////////////////////////////////////////////////

import 'dart:typed_data';

import 'package:amap_map_fluttify/src/ios/ios.export.g.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';

import 'package:foundation_fluttify/foundation_fluttify.dart';
import 'package:core_location_fluttify/core_location_fluttify.dart';
import 'package:amap_core_fluttify/amap_core_fluttify.dart';
import 'package:amap_search_fluttify/amap_search_fluttify.dart';
import 'package:amap_location_fluttify/amap_location_fluttify.dart';

class MAMapView extends UIView  {
  //region constants
  static const String name__ = 'MAMapView';

  @override
  final String tag__ = 'amap_map_fluttify';

  
  //endregion

  //region creators
  static Future<MAMapView> create__({ bool init = true /* ios only */ }) async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod(
      'ObjectFactory::createMAMapView',
      {'init': init}
    );
    return AmapMapFluttifyIOSAs<MAMapView>(__result__)!;
  }
  
  static Future<List<MAMapView>> create_batch__(int length, { bool init = true /* ios only */ }) async {
    assert(true);
    final __result_batch__ = await  kAmapMapFluttifyChannel.invokeListMethod(
      'ObjectFactory::create_batchMAMapView',
      {'length': length, 'init': init}
    );
    return __result_batch__
        ?.map((it) => AmapMapFluttifyIOSAs<MAMapView>(it))
        .where((element) => element !=null)
        .cast<MAMapView>()
        .toList() ?? <MAMapView>[];
  }
  
  //endregion

  //region getters
  static Future<bool?> get_static_metalEnabled() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_metalEnabled", );
    return __result__;
  }
  
  static Future<bool?> get_static_terrainEnabled() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_terrainEnabled", );
    return __result__;
  }
  
  Future<MAMapType?> get_mapType() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_mapType", {'__this__': this});
    return (__result__ as int).toMAMapType();
  }
  
  Future<CLLocationCoordinate2D?> get_centerCoordinate() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_centerCoordinate", {'__this__': this});
    return AmapMapFluttifyIOSAs<CLLocationCoordinate2D>(__result__);
  }
  
  Future<MACoordinateRegion?> get_region() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_region", {'__this__': this});
    return AmapMapFluttifyIOSAs<MACoordinateRegion>(__result__);
  }
  
  Future<MAMapRect?> get_visibleMapRect() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_visibleMapRect", {'__this__': this});
    return AmapMapFluttifyIOSAs<MAMapRect>(__result__);
  }
  
  Future<MACoordinateRegion?> get_limitRegion() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_limitRegion", {'__this__': this});
    return AmapMapFluttifyIOSAs<MACoordinateRegion>(__result__);
  }
  
  Future<MAMapRect?> get_limitMapRect() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_limitMapRect", {'__this__': this});
    return AmapMapFluttifyIOSAs<MAMapRect>(__result__);
  }
  
  Future<double?> get_zoomLevel() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_zoomLevel", {'__this__': this});
    return __result__;
  }
  
  Future<double?> get_minZoomLevel() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_minZoomLevel", {'__this__': this});
    return __result__;
  }
  
  Future<double?> get_maxZoomLevel() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_maxZoomLevel", {'__this__': this});
    return __result__;
  }
  
  Future<double?> get_rotationDegree() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_rotationDegree", {'__this__': this});
    return __result__;
  }
  
  Future<double?> get_cameraDegree() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_cameraDegree", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_zoomingInPivotsAroundAnchorPoint() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_zoomingInPivotsAroundAnchorPoint", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_zoomEnabled() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isZoomEnabled", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_scrollEnabled() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isScrollEnabled", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_rotateEnabled() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isRotateEnabled", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_rotateCameraEnabled() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isRotateCameraEnabled", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_showsBuildings() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isShowsBuildings", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_showsLabels() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isShowsLabels", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_showTraffic() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isShowTraffic", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_touchPOIEnabled() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_touchPOIEnabled", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_showsCompass() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_showsCompass", {'__this__': this});
    return __result__;
  }
  
  Future<CGPoint?> get_compassOrigin() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_compassOrigin", {'__this__': this});
    return AmapMapFluttifyIOSAs<CGPoint>(__result__);
  }
  
  Future<CGSize?> get_compassSize() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_compassSize", {'__this__': this});
    return AmapMapFluttifyIOSAs<CGSize>(__result__);
  }
  
  Future<bool?> get_showsScale() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_showsScale", {'__this__': this});
    return __result__;
  }
  
  Future<CGPoint?> get_scaleOrigin() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_scaleOrigin", {'__this__': this});
    return AmapMapFluttifyIOSAs<CGPoint>(__result__);
  }
  
  Future<CGSize?> get_scaleSize() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_scaleSize", {'__this__': this});
    return AmapMapFluttifyIOSAs<CGSize>(__result__);
  }
  
  Future<CGPoint?> get_logoCenter() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_logoCenter", {'__this__': this});
    return AmapMapFluttifyIOSAs<CGPoint>(__result__);
  }
  
  Future<CGSize?> get_logoSize() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_logoSize", {'__this__': this});
    return AmapMapFluttifyIOSAs<CGSize>(__result__);
  }
  
  Future<double?> get_metersPerPointForCurrentZoom() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_metersPerPointForCurrentZoom", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_isAbroad() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isAbroad", {'__this__': this});
    return __result__;
  }
  
  Future<int?> get_maxRenderFrame() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_maxRenderFrame", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_isAllowDecreaseFrame() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isAllowDecreaseFrame", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_openGLESDisabled() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_openGLESDisabled", {'__this__': this});
    return __result__;
  }
  
  Future<bool?> get_renderringDisabled() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_renderringDisabled", {'__this__': this});
    return __result__;
  }
  
  Future<CGPoint?> get_screenAnchor() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_screenAnchor", {'__this__': this});
    return AmapMapFluttifyIOSAs<CGPoint>(__result__);
  }
  
  Future<num?> get_showsWorldMap() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isShowsWorldMap", {'__this__': this});
    return __result__;
  }
  
  Future<num?> get_mapLanguage() async {
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_mapLanguage", {'__this__': this});
    return __result__;
  }
  
  //endregion

  //region setters
  Future<void> set_delegate(MAMapViewDelegate? delegate) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_delegate', <String, dynamic>{'__this__': this, "delegate": delegate});
  }
  
  Future<void> set_mapType(MAMapType? mapType) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_mapType', <String, dynamic>{'__this__': this, "mapType": mapType?.toValue()});
  }
  
  Future<void> set_centerCoordinate(CLLocationCoordinate2D? centerCoordinate) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_centerCoordinate', <String, dynamic>{'__this__': this, "centerCoordinate": centerCoordinate});
  }
  
  Future<void> set_region(MACoordinateRegion? region) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_region', <String, dynamic>{'__this__': this, "region": region});
  }
  
  Future<void> set_visibleMapRect(MAMapRect? visibleMapRect) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_visibleMapRect', <String, dynamic>{'__this__': this, "visibleMapRect": visibleMapRect});
  }
  
  Future<void> set_limitRegion(MACoordinateRegion? limitRegion) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_limitRegion', <String, dynamic>{'__this__': this, "limitRegion": limitRegion});
  }
  
  Future<void> set_limitMapRect(MAMapRect? limitMapRect) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_limitMapRect', <String, dynamic>{'__this__': this, "limitMapRect": limitMapRect});
  }
  
  Future<void> set_zoomLevel(double? zoomLevel) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_zoomLevel', <String, dynamic>{'__this__': this, "zoomLevel": zoomLevel});
  }
  
  Future<void> set_minZoomLevel(double? minZoomLevel) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_minZoomLevel', <String, dynamic>{'__this__': this, "minZoomLevel": minZoomLevel});
  }
  
  Future<void> set_maxZoomLevel(double? maxZoomLevel) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_maxZoomLevel', <String, dynamic>{'__this__': this, "maxZoomLevel": maxZoomLevel});
  }
  
  Future<void> set_rotationDegree(double? rotationDegree) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_rotationDegree', <String, dynamic>{'__this__': this, "rotationDegree": rotationDegree});
  }
  
  Future<void> set_cameraDegree(double? cameraDegree) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_cameraDegree', <String, dynamic>{'__this__': this, "cameraDegree": cameraDegree});
  }
  
  Future<void> set_zoomingInPivotsAroundAnchorPoint(bool? zoomingInPivotsAroundAnchorPoint) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_zoomingInPivotsAroundAnchorPoint', <String, dynamic>{'__this__': this, "zoomingInPivotsAroundAnchorPoint": zoomingInPivotsAroundAnchorPoint});
  }
  
  Future<void> set_zoomEnabled(bool? zoomEnabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_zoomEnabled', <String, dynamic>{'__this__': this, "zoomEnabled": zoomEnabled});
  }
  
  Future<void> set_scrollEnabled(bool? scrollEnabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_scrollEnabled', <String, dynamic>{'__this__': this, "scrollEnabled": scrollEnabled});
  }
  
  Future<void> set_rotateEnabled(bool? rotateEnabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_rotateEnabled', <String, dynamic>{'__this__': this, "rotateEnabled": rotateEnabled});
  }
  
  Future<void> set_rotateCameraEnabled(bool? rotateCameraEnabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_rotateCameraEnabled', <String, dynamic>{'__this__': this, "rotateCameraEnabled": rotateCameraEnabled});
  }
  
  Future<void> set_showsBuildings(bool? showsBuildings) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showsBuildings', <String, dynamic>{'__this__': this, "showsBuildings": showsBuildings});
  }
  
  Future<void> set_showsLabels(bool? showsLabels) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showsLabels', <String, dynamic>{'__this__': this, "showsLabels": showsLabels});
  }
  
  Future<void> set_showTraffic(bool? showTraffic) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showTraffic', <String, dynamic>{'__this__': this, "showTraffic": showTraffic});
  }
  
  Future<void> set_touchPOIEnabled(bool? touchPOIEnabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_touchPOIEnabled', <String, dynamic>{'__this__': this, "touchPOIEnabled": touchPOIEnabled});
  }
  
  Future<void> set_showsCompass(bool? showsCompass) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showsCompass', <String, dynamic>{'__this__': this, "showsCompass": showsCompass});
  }
  
  Future<void> set_compassOrigin(CGPoint? compassOrigin) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_compassOrigin', <String, dynamic>{'__this__': this, "compassOrigin": compassOrigin});
  }
  
  Future<void> set_showsScale(bool? showsScale) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showsScale', <String, dynamic>{'__this__': this, "showsScale": showsScale});
  }
  
  Future<void> set_scaleOrigin(CGPoint? scaleOrigin) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_scaleOrigin', <String, dynamic>{'__this__': this, "scaleOrigin": scaleOrigin});
  }
  
  Future<void> set_logoCenter(CGPoint? logoCenter) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_logoCenter', <String, dynamic>{'__this__': this, "logoCenter": logoCenter});
  }
  
  Future<void> set_maxRenderFrame(int? maxRenderFrame) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_maxRenderFrame', <String, dynamic>{'__this__': this, "maxRenderFrame": maxRenderFrame});
  }
  
  Future<void> set_isAllowDecreaseFrame(bool? isAllowDecreaseFrame) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_isAllowDecreaseFrame', <String, dynamic>{'__this__': this, "isAllowDecreaseFrame": isAllowDecreaseFrame});
  }
  
  Future<void> set_openGLESDisabled(bool? openGLESDisabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_openGLESDisabled', <String, dynamic>{'__this__': this, "openGLESDisabled": openGLESDisabled});
  }
  
  Future<void> set_renderringDisabled(bool? renderringDisabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_renderringDisabled', <String, dynamic>{'__this__': this, "renderringDisabled": renderringDisabled});
  }
  
  Future<void> set_screenAnchor(CGPoint? screenAnchor) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_screenAnchor', <String, dynamic>{'__this__': this, "screenAnchor": screenAnchor});
  }
  
  Future<void> set_showsWorldMap(num? showsWorldMap) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showsWorldMap', <String, dynamic>{'__this__': this, "showsWorldMap": showsWorldMap});
  }
  
  Future<void> set_mapLanguage(num? mapLanguage) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_mapLanguage', <String, dynamic>{'__this__': this, "mapLanguage": mapLanguage});
  }
  
  //endregion

  //region methods
  
  Future<void> setRegion_animated(MACoordinateRegion? region, bool? animated) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setRegion([\'animated\':$animated])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setRegion_animated', {"region": region, "animated": animated, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<MACoordinateRegion?> regionThatFits(MACoordinateRegion? region) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::regionThatFits([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::regionThatFits', {"region": region, "__this__": this});
  
  
    // handle native call
  
  
    return AmapMapFluttifyIOSAs<MACoordinateRegion>(__result__);
  }
  
  
  Future<void> setVisibleMapRect_animated(MAMapRect? mapRect, bool? animated) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setVisibleMapRect([\'animated\':$animated])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setVisibleMapRect_animated', {"mapRect": mapRect, "animated": animated, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<MAMapRect?> mapRectThatFits(MAMapRect? mapRect) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::mapRectThatFits([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::mapRectThatFits', {"mapRect": mapRect, "__this__": this});
  
  
    // handle native call
  
  
    return AmapMapFluttifyIOSAs<MAMapRect>(__result__);
  }
  
  
  Future<MAMapRect?> mapRectThatFits_edgePadding(MAMapRect? mapRect, UIEdgeInsets? insets) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::mapRectThatFits([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::mapRectThatFits_edgePadding', {"mapRect": mapRect, "insets": insets, "__this__": this});
  
  
    // handle native call
  
  
    return AmapMapFluttifyIOSAs<MAMapRect>(__result__);
  }
  
  
  Future<void> setVisibleMapRect_edgePadding_animated(MAMapRect? mapRect, UIEdgeInsets? insets, bool? animated) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setVisibleMapRect([\'animated\':$animated])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setVisibleMapRect_edgePadding_animated', {"mapRect": mapRect, "insets": insets, "animated": animated, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> setVisibleMapRect_edgePadding_animated_duration(MAMapRect? mapRect, UIEdgeInsets? insets, bool? animated, double? duration) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setVisibleMapRect([\'animated\':$animated, \'duration\':$duration])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setVisibleMapRect_edgePadding_animated_duration', {"mapRect": mapRect, "insets": insets, "animated": animated, "duration": duration, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> setCenterCoordinate_animated(CLLocationCoordinate2D? coordinate, bool? animated) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setCenterCoordinate([\'animated\':$animated])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setCenterCoordinate_animated', {"coordinate": coordinate, "animated": animated, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> setZoomLevel_animated(double? zoomLevel, bool? animated) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setZoomLevel([\'zoomLevel\':$zoomLevel, \'animated\':$animated])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setZoomLevel_animated', {"zoomLevel": zoomLevel, "animated": animated, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> setZoomLevel_atPivot_animated(double? zoomLevel, CGPoint? pivot, bool? animated) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setZoomLevel([\'zoomLevel\':$zoomLevel, \'animated\':$animated])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setZoomLevel_atPivot_animated', {"zoomLevel": zoomLevel, "pivot": pivot, "animated": animated, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> setRotationDegree_animated_duration(double? rotationDegree, bool? animated, double? duration) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setRotationDegree([\'rotationDegree\':$rotationDegree, \'animated\':$animated, \'duration\':$duration])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setRotationDegree_animated_duration', {"rotationDegree": rotationDegree, "animated": animated, "duration": duration, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> setCameraDegree_animated_duration(double? cameraDegree, bool? animated, double? duration) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setCameraDegree([\'cameraDegree\':$cameraDegree, \'animated\':$animated, \'duration\':$duration])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setCameraDegree_animated_duration', {"cameraDegree": cameraDegree, "animated": animated, "duration": duration, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<MAMapStatus?> getMapStatus() async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::getMapStatus([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::getMapStatus', {"__this__": this});
  
  
    // handle native call
  
  
    return AmapMapFluttifyIOSAs<MAMapStatus>(__result__);
  }
  
  
  Future<void> setMapStatus_animated(MAMapStatus? status, bool? animated) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setMapStatus([\'animated\':$animated])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setMapStatus_animated', {"status": status, "animated": animated, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> setMapStatus_animated_duration(MAMapStatus? status, bool? animated, double? duration) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setMapStatus([\'animated\':$animated, \'duration\':$duration])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setMapStatus_animated_duration', {"status": status, "animated": animated, "duration": duration, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> setCompassImage(UIImage? image) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setCompassImage([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setCompassImage', {"image": image, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<UIImage?> takeSnapshotInRect(CGRect? rect) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::takeSnapshotInRect([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::takeSnapshotInRect', {"rect": rect, "__this__": this});
  
  
    // handle native call
  
  
    return AmapMapFluttifyIOSAs<UIImage>(__result__);
  }
  
  
  Future<void> takeSnapshotInRect_withCompletionBlock(CGRect? rect, void Function(UIImage? resultImage, int? state) block) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::takeSnapshotInRect([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::takeSnapshotInRect_withCompletionBlock', {"rect": rect, "__this__": this});
  
  
    // handle native call
    MethodChannel('void|UIImage*#resultImage,NSInteger#state::Callback@$refId', kAmapMapFluttifyMethodCodec)
        .setMethodCallHandler((methodCall) async {
          try {
            final args = methodCall.arguments as Map;
            switch (methodCall.method) {
              case 'void|UIImage*#resultImage,NSInteger#state_':
                // print log
                if (fluttifyLogEnabled) {
                  debugPrint('fluttify-dart-callback: block([\'resultImage\':${args['resultImage']}, \'state\':${args['state']}])');
                }
          
                // handle the native call
                block(AmapMapFluttifyIOSAs<UIImage>(args['resultImage']), args['state']);
                break;
              default:
                throw MissingPluginException('方法${methodCall.method}未实现');
                break;
            }
          } catch (e) {
            debugPrint(e.toString());
            rethrow;
          }
        });
  
    return __result__;
  }
  
  
  Future<void> takeSnapshotInRect_timeoutInterval_completionBlock(CGRect? rect, double? timeout, void Function(UIImage? resultImage, int? state) block) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::takeSnapshotInRect([\'timeout\':$timeout])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::takeSnapshotInRect_timeoutInterval_completionBlock', {"rect": rect, "timeout": timeout, "__this__": this});
  
  
    // handle native call
    MethodChannel('void|UIImage*#resultImage,NSInteger#state::Callback@$refId', kAmapMapFluttifyMethodCodec)
        .setMethodCallHandler((methodCall) async {
          try {
            final args = methodCall.arguments as Map;
            switch (methodCall.method) {
              case 'void|UIImage*#resultImage,NSInteger#state_':
                // print log
                if (fluttifyLogEnabled) {
                  debugPrint('fluttify-dart-callback: block([\'resultImage\':${args['resultImage']}, \'state\':${args['state']}])');
                }
          
                // handle the native call
                block(AmapMapFluttifyIOSAs<UIImage>(args['resultImage']), args['state']);
                break;
              default:
                throw MissingPluginException('方法${methodCall.method}未实现');
                break;
            }
          } catch (e) {
            debugPrint(e.toString());
            rethrow;
          }
        });
  
    return __result__;
  }
  
  
  Future<double?> metersPerPointForZoomLevel(double? zoomLevel) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::metersPerPointForZoomLevel([\'zoomLevel\':$zoomLevel])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::metersPerPointForZoomLevel', {"zoomLevel": zoomLevel, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<CGPoint?> convertCoordinate_toPointToView(CLLocationCoordinate2D? coordinate, UIView? view) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::convertCoordinate([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::convertCoordinate_toPointToView', {"coordinate": coordinate, "view": view, "__this__": this});
  
  
    // handle native call
  
  
    return AmapMapFluttifyIOSAs<CGPoint>(__result__);
  }
  
  
  Future<CLLocationCoordinate2D?> convertPoint_toCoordinateFromView(CGPoint? point, UIView? view) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::convertPoint([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::convertPoint_toCoordinateFromView', {"point": point, "view": view, "__this__": this});
  
  
    // handle native call
  
  
    return AmapMapFluttifyIOSAs<CLLocationCoordinate2D>(__result__);
  }
  
  
  Future<CGRect?> convertRegion_toRectToView(MACoordinateRegion? region, UIView? view) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::convertRegion([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::convertRegion_toRectToView', {"region": region, "view": view, "__this__": this});
  
  
    // handle native call
  
  
    return AmapMapFluttifyIOSAs<CGRect>(__result__);
  }
  
  
  Future<MACoordinateRegion?> convertRect_toRegionFromView(CGRect? rect, UIView? view) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::convertRect([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::convertRect_toRegionFromView', {"rect": rect, "view": view, "__this__": this});
  
  
    // handle native call
  
  
    return AmapMapFluttifyIOSAs<MACoordinateRegion>(__result__);
  }
  
  
  Future<void> reloadMap() async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::reloadMap([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::reloadMap', {"__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> clearDisk() async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::clearDisk([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::clearDisk', {"__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> reloadInternalTexture() async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::reloadInternalTexture([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::reloadInternalTexture', {"__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<String?> mapContentApprovalNumber() async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::mapContentApprovalNumber([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::mapContentApprovalNumber', {"__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<String?> satelliteImageApprovalNumber() async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::satelliteImageApprovalNumber([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::satelliteImageApprovalNumber', {"__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<String?> terrainApprovalNumber() async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::terrainApprovalNumber([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::terrainApprovalNumber', {"__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> forceRefresh() async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::forceRefresh([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::forceRefresh', {"__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  Future<void> setConstructingRoadEnable(bool? enabled) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView@$refId::setConstructingRoadEnable([\'enabled\':$enabled])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setConstructingRoadEnable', {"enabled": enabled, "__this__": this});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  static Future<void> updatePrivacyShow_privacyInfo(AMapPrivacyShowStatus? showStatus, AMapPrivacyInfoStatus? containStatus) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView::updatePrivacyShow([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::updatePrivacyShow_privacyInfo', {"showStatus": showStatus?.toValue(), "containStatus": containStatus?.toValue()});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  
  static Future<void> updatePrivacyAgree(AMapPrivacyAgreeStatus? agreeStatus) async {
    // print log
    if (fluttifyLogEnabled) {
      debugPrint('fluttify-dart: MAMapView::updatePrivacyAgree([])');
    }
  
    // invoke native method
    final __result__ = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::updatePrivacyAgree', {"agreeStatus": agreeStatus?.toValue()});
  
  
    // handle native call
  
  
    return __result__;
  }
  
  //endregion

  @override
  String toString() {
    return 'MAMapView{refId: $refId, runtimeType: $runtimeType, tag__: $tag__}';
  }
}

extension MAMapView_Batch on List<MAMapView?> {
  String? get refId {
    if (isEmpty) return null;
    return first?.refId;
  }

  //region getters
  Future<List<bool?>> get_static_metalEnabled_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_metalEnabled_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_static_terrainEnabled_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_terrainEnabled_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<MAMapType?>> get_mapType_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_mapType_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => (__result__ as int).toMAMapType()).cast<MAMapType?>().toList();
  }
  
  Future<List<CLLocationCoordinate2D?>> get_centerCoordinate_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_centerCoordinate_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<CLLocationCoordinate2D>(__result__)).cast<CLLocationCoordinate2D?>().toList();
  }
  
  Future<List<MACoordinateRegion?>> get_region_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_region_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<MACoordinateRegion>(__result__)).cast<MACoordinateRegion?>().toList();
  }
  
  Future<List<MAMapRect?>> get_visibleMapRect_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_visibleMapRect_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<MAMapRect>(__result__)).cast<MAMapRect?>().toList();
  }
  
  Future<List<MACoordinateRegion?>> get_limitRegion_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_limitRegion_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<MACoordinateRegion>(__result__)).cast<MACoordinateRegion?>().toList();
  }
  
  Future<List<MAMapRect?>> get_limitMapRect_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_limitMapRect_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<MAMapRect>(__result__)).cast<MAMapRect?>().toList();
  }
  
  Future<List<double?>> get_zoomLevel_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_zoomLevel_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<double?>().toList();
  }
  
  Future<List<double?>> get_minZoomLevel_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_minZoomLevel_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<double?>().toList();
  }
  
  Future<List<double?>> get_maxZoomLevel_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_maxZoomLevel_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<double?>().toList();
  }
  
  Future<List<double?>> get_rotationDegree_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_rotationDegree_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<double?>().toList();
  }
  
  Future<List<double?>> get_cameraDegree_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_cameraDegree_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<double?>().toList();
  }
  
  Future<List<bool?>> get_zoomingInPivotsAroundAnchorPoint_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_zoomingInPivotsAroundAnchorPoint_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_zoomEnabled_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isZoomEnabled_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_scrollEnabled_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isScrollEnabled_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_rotateEnabled_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isRotateEnabled_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_rotateCameraEnabled_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isRotateCameraEnabled_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_showsBuildings_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isShowsBuildings_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_showsLabels_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isShowsLabels_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_showTraffic_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isShowTraffic_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_touchPOIEnabled_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_touchPOIEnabled_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_showsCompass_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_showsCompass_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<CGPoint?>> get_compassOrigin_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_compassOrigin_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<CGPoint>(__result__)).cast<CGPoint?>().toList();
  }
  
  Future<List<CGSize?>> get_compassSize_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_compassSize_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<CGSize>(__result__)).cast<CGSize?>().toList();
  }
  
  Future<List<bool?>> get_showsScale_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_showsScale_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<CGPoint?>> get_scaleOrigin_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_scaleOrigin_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<CGPoint>(__result__)).cast<CGPoint?>().toList();
  }
  
  Future<List<CGSize?>> get_scaleSize_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_scaleSize_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<CGSize>(__result__)).cast<CGSize?>().toList();
  }
  
  Future<List<CGPoint?>> get_logoCenter_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_logoCenter_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<CGPoint>(__result__)).cast<CGPoint?>().toList();
  }
  
  Future<List<CGSize?>> get_logoSize_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_logoSize_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<CGSize>(__result__)).cast<CGSize?>().toList();
  }
  
  Future<List<double?>> get_metersPerPointForCurrentZoom_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_metersPerPointForCurrentZoom_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<double?>().toList();
  }
  
  Future<List<bool?>> get_isAbroad_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isAbroad_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<int?>> get_maxRenderFrame_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_maxRenderFrame_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<int?>().toList();
  }
  
  Future<List<bool?>> get_isAllowDecreaseFrame_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isAllowDecreaseFrame_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_openGLESDisabled_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_openGLESDisabled_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<bool?>> get_renderringDisabled_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_renderringDisabled_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<bool?>().toList();
  }
  
  Future<List<CGPoint?>> get_screenAnchor_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_screenAnchor_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<CGPoint>(__result__)).cast<CGPoint?>().toList();
  }
  
  Future<List<num?>> get_showsWorldMap_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_isShowsWorldMap_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<num?>().toList();
  }
  
  Future<List<num?>> get_mapLanguage_batch() async {
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod("MAMapView::get_mapLanguage_batch", [for (final __item__ in this) {'__this__': __item__}]);
    return (resultBatch as List).map((__result__) => __result__).cast<num?>().toList();
  }
  
  //endregion

  //region setters
  Future<void> set_mapType_batch(List<MAMapType?> mapType) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_mapType_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "mapType": mapType[__i__]?.toValue()}]);
  
  
  }
  
  Future<void> set_centerCoordinate_batch(List<CLLocationCoordinate2D?> centerCoordinate) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_centerCoordinate_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "centerCoordinate": centerCoordinate[__i__]}]);
  
  
  }
  
  Future<void> set_region_batch(List<MACoordinateRegion?> region) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_region_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "region": region[__i__]}]);
  
  
  }
  
  Future<void> set_visibleMapRect_batch(List<MAMapRect?> visibleMapRect) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_visibleMapRect_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "visibleMapRect": visibleMapRect[__i__]}]);
  
  
  }
  
  Future<void> set_limitRegion_batch(List<MACoordinateRegion?> limitRegion) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_limitRegion_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "limitRegion": limitRegion[__i__]}]);
  
  
  }
  
  Future<void> set_limitMapRect_batch(List<MAMapRect?> limitMapRect) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_limitMapRect_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "limitMapRect": limitMapRect[__i__]}]);
  
  
  }
  
  Future<void> set_zoomLevel_batch(List<double?> zoomLevel) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_zoomLevel_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "zoomLevel": zoomLevel[__i__]}]);
  
  
  }
  
  Future<void> set_minZoomLevel_batch(List<double?> minZoomLevel) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_minZoomLevel_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "minZoomLevel": minZoomLevel[__i__]}]);
  
  
  }
  
  Future<void> set_maxZoomLevel_batch(List<double?> maxZoomLevel) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_maxZoomLevel_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "maxZoomLevel": maxZoomLevel[__i__]}]);
  
  
  }
  
  Future<void> set_rotationDegree_batch(List<double?> rotationDegree) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_rotationDegree_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "rotationDegree": rotationDegree[__i__]}]);
  
  
  }
  
  Future<void> set_cameraDegree_batch(List<double?> cameraDegree) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_cameraDegree_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "cameraDegree": cameraDegree[__i__]}]);
  
  
  }
  
  Future<void> set_zoomingInPivotsAroundAnchorPoint_batch(List<bool?> zoomingInPivotsAroundAnchorPoint) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_zoomingInPivotsAroundAnchorPoint_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "zoomingInPivotsAroundAnchorPoint": zoomingInPivotsAroundAnchorPoint[__i__]}]);
  
  
  }
  
  Future<void> set_zoomEnabled_batch(List<bool?> zoomEnabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_zoomEnabled_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "zoomEnabled": zoomEnabled[__i__]}]);
  
  
  }
  
  Future<void> set_scrollEnabled_batch(List<bool?> scrollEnabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_scrollEnabled_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "scrollEnabled": scrollEnabled[__i__]}]);
  
  
  }
  
  Future<void> set_rotateEnabled_batch(List<bool?> rotateEnabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_rotateEnabled_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "rotateEnabled": rotateEnabled[__i__]}]);
  
  
  }
  
  Future<void> set_rotateCameraEnabled_batch(List<bool?> rotateCameraEnabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_rotateCameraEnabled_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "rotateCameraEnabled": rotateCameraEnabled[__i__]}]);
  
  
  }
  
  Future<void> set_showsBuildings_batch(List<bool?> showsBuildings) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showsBuildings_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "showsBuildings": showsBuildings[__i__]}]);
  
  
  }
  
  Future<void> set_showsLabels_batch(List<bool?> showsLabels) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showsLabels_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "showsLabels": showsLabels[__i__]}]);
  
  
  }
  
  Future<void> set_showTraffic_batch(List<bool?> showTraffic) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showTraffic_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "showTraffic": showTraffic[__i__]}]);
  
  
  }
  
  Future<void> set_touchPOIEnabled_batch(List<bool?> touchPOIEnabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_touchPOIEnabled_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "touchPOIEnabled": touchPOIEnabled[__i__]}]);
  
  
  }
  
  Future<void> set_showsCompass_batch(List<bool?> showsCompass) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showsCompass_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "showsCompass": showsCompass[__i__]}]);
  
  
  }
  
  Future<void> set_compassOrigin_batch(List<CGPoint?> compassOrigin) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_compassOrigin_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "compassOrigin": compassOrigin[__i__]}]);
  
  
  }
  
  Future<void> set_showsScale_batch(List<bool?> showsScale) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showsScale_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "showsScale": showsScale[__i__]}]);
  
  
  }
  
  Future<void> set_scaleOrigin_batch(List<CGPoint?> scaleOrigin) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_scaleOrigin_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "scaleOrigin": scaleOrigin[__i__]}]);
  
  
  }
  
  Future<void> set_logoCenter_batch(List<CGPoint?> logoCenter) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_logoCenter_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "logoCenter": logoCenter[__i__]}]);
  
  
  }
  
  Future<void> set_maxRenderFrame_batch(List<int?> maxRenderFrame) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_maxRenderFrame_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "maxRenderFrame": maxRenderFrame[__i__]}]);
  
  
  }
  
  Future<void> set_isAllowDecreaseFrame_batch(List<bool?> isAllowDecreaseFrame) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_isAllowDecreaseFrame_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "isAllowDecreaseFrame": isAllowDecreaseFrame[__i__]}]);
  
  
  }
  
  Future<void> set_openGLESDisabled_batch(List<bool?> openGLESDisabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_openGLESDisabled_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "openGLESDisabled": openGLESDisabled[__i__]}]);
  
  
  }
  
  Future<void> set_renderringDisabled_batch(List<bool?> renderringDisabled) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_renderringDisabled_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "renderringDisabled": renderringDisabled[__i__]}]);
  
  
  }
  
  Future<void> set_screenAnchor_batch(List<CGPoint?> screenAnchor) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_screenAnchor_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "screenAnchor": screenAnchor[__i__]}]);
  
  
  }
  
  Future<void> set_showsWorldMap_batch(List<num?> showsWorldMap) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_showsWorldMap_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "showsWorldMap": showsWorldMap[__i__]}]);
  
  
  }
  
  Future<void> set_mapLanguage_batch(List<num?> mapLanguage) async {
    await kAmapMapFluttifyChannel.invokeMethod('MAMapView::set_mapLanguage_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {'__this__': this[__i__], "mapLanguage": mapLanguage[__i__]}]);
  
  
  }
  
  //endregion

  //region methods
  
  Future<List<void>> setRegion_animated_batch(List<MACoordinateRegion?> region, List<bool?> animated) async {
    assert(region.length == animated.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setRegion_animated_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"region": region[__i__], "animated": animated[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<MACoordinateRegion?>> regionThatFits_batch(List<MACoordinateRegion?> region) async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::regionThatFits_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"region": region[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<MACoordinateRegion>(__result__)).cast<MACoordinateRegion?>().toList();
  }
  
  
  Future<List<void>> setVisibleMapRect_animated_batch(List<MAMapRect?> mapRect, List<bool?> animated) async {
    assert(mapRect.length == animated.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setVisibleMapRect_animated_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"mapRect": mapRect[__i__], "animated": animated[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<MAMapRect?>> mapRectThatFits_batch(List<MAMapRect?> mapRect) async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::mapRectThatFits_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"mapRect": mapRect[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<MAMapRect>(__result__)).cast<MAMapRect?>().toList();
  }
  
  
  Future<List<MAMapRect?>> mapRectThatFits_edgePadding_batch(List<MAMapRect?> mapRect, List<UIEdgeInsets?> insets) async {
    assert(mapRect.length == insets.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::mapRectThatFits_edgePadding_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"mapRect": mapRect[__i__], "insets": insets[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<MAMapRect>(__result__)).cast<MAMapRect?>().toList();
  }
  
  
  Future<List<void>> setVisibleMapRect_edgePadding_animated_batch(List<MAMapRect?> mapRect, List<UIEdgeInsets?> insets, List<bool?> animated) async {
    assert(mapRect.length == insets.length && insets.length == animated.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setVisibleMapRect_edgePadding_animated_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"mapRect": mapRect[__i__], "insets": insets[__i__], "animated": animated[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<void>> setVisibleMapRect_edgePadding_animated_duration_batch(List<MAMapRect?> mapRect, List<UIEdgeInsets?> insets, List<bool?> animated, List<double?> duration) async {
    assert(mapRect.length == insets.length && insets.length == animated.length && animated.length == duration.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setVisibleMapRect_edgePadding_animated_duration_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"mapRect": mapRect[__i__], "insets": insets[__i__], "animated": animated[__i__], "duration": duration[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<void>> setCenterCoordinate_animated_batch(List<CLLocationCoordinate2D?> coordinate, List<bool?> animated) async {
    assert(coordinate.length == animated.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setCenterCoordinate_animated_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"coordinate": coordinate[__i__], "animated": animated[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<void>> setZoomLevel_animated_batch(List<double?> zoomLevel, List<bool?> animated) async {
    assert(zoomLevel.length == animated.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setZoomLevel_animated_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"zoomLevel": zoomLevel[__i__], "animated": animated[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<void>> setZoomLevel_atPivot_animated_batch(List<double?> zoomLevel, List<CGPoint?> pivot, List<bool?> animated) async {
    assert(zoomLevel.length == pivot.length && pivot.length == animated.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setZoomLevel_atPivot_animated_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"zoomLevel": zoomLevel[__i__], "pivot": pivot[__i__], "animated": animated[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<void>> setRotationDegree_animated_duration_batch(List<double?> rotationDegree, List<bool?> animated, List<double?> duration) async {
    assert(rotationDegree.length == animated.length && animated.length == duration.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setRotationDegree_animated_duration_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"rotationDegree": rotationDegree[__i__], "animated": animated[__i__], "duration": duration[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<void>> setCameraDegree_animated_duration_batch(List<double?> cameraDegree, List<bool?> animated, List<double?> duration) async {
    assert(cameraDegree.length == animated.length && animated.length == duration.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setCameraDegree_animated_duration_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"cameraDegree": cameraDegree[__i__], "animated": animated[__i__], "duration": duration[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<MAMapStatus?>> getMapStatus_batch() async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::getMapStatus_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<MAMapStatus>(__result__)).cast<MAMapStatus?>().toList();
  }
  
  
  Future<List<void>> setMapStatus_animated_batch(List<MAMapStatus?> status, List<bool?> animated) async {
    assert(status.length == animated.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setMapStatus_animated_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"status": status[__i__], "animated": animated[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<void>> setMapStatus_animated_duration_batch(List<MAMapStatus?> status, List<bool?> animated, List<double?> duration) async {
    assert(status.length == animated.length && animated.length == duration.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setMapStatus_animated_duration_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"status": status[__i__], "animated": animated[__i__], "duration": duration[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<void>> setCompassImage_batch(List<UIImage?> image) async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setCompassImage_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"image": image[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<UIImage?>> takeSnapshotInRect_batch(List<CGRect?> rect) async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::takeSnapshotInRect_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"rect": rect[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<UIImage>(__result__)).cast<UIImage?>().toList();
  }
  
  
  Future<List<double?>> metersPerPointForZoomLevel_batch(List<double?> zoomLevel) async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::metersPerPointForZoomLevel_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"zoomLevel": zoomLevel[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<double?>().toList();
  }
  
  
  Future<List<CGPoint?>> convertCoordinate_toPointToView_batch(List<CLLocationCoordinate2D?> coordinate, List<UIView?> view) async {
    assert(coordinate.length == view.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::convertCoordinate_toPointToView_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"coordinate": coordinate[__i__], "view": view[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<CGPoint>(__result__)).cast<CGPoint?>().toList();
  }
  
  
  Future<List<CLLocationCoordinate2D?>> convertPoint_toCoordinateFromView_batch(List<CGPoint?> point, List<UIView?> view) async {
    assert(point.length == view.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::convertPoint_toCoordinateFromView_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"point": point[__i__], "view": view[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<CLLocationCoordinate2D>(__result__)).cast<CLLocationCoordinate2D?>().toList();
  }
  
  
  Future<List<CGRect?>> convertRegion_toRectToView_batch(List<MACoordinateRegion?> region, List<UIView?> view) async {
    assert(region.length == view.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::convertRegion_toRectToView_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"region": region[__i__], "view": view[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<CGRect>(__result__)).cast<CGRect?>().toList();
  }
  
  
  Future<List<MACoordinateRegion?>> convertRect_toRegionFromView_batch(List<CGRect?> rect, List<UIView?> view) async {
    assert(rect.length == view.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::convertRect_toRegionFromView_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"rect": rect[__i__], "view": view[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => AmapMapFluttifyIOSAs<MACoordinateRegion>(__result__)).cast<MACoordinateRegion?>().toList();
  }
  
  
  Future<List<void>> reloadMap_batch() async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::reloadMap_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<void>> clearDisk_batch() async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::clearDisk_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<void>> reloadInternalTexture_batch() async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::reloadInternalTexture_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<String?>> mapContentApprovalNumber_batch() async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::mapContentApprovalNumber_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<String?>().toList();
  }
  
  
  Future<List<String?>> satelliteImageApprovalNumber_batch() async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::satelliteImageApprovalNumber_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<String?>().toList();
  }
  
  
  Future<List<String?>> terrainApprovalNumber_batch() async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::terrainApprovalNumber_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<String?>().toList();
  }
  
  
  Future<List<void>> forceRefresh_batch() async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::forceRefresh_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  Future<List<void>> setConstructingRoadEnable_batch(List<bool?> enabled) async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::setConstructingRoadEnable_batch', [for (int __i__ = 0; __i__ < this.length; __i__++) {"enabled": enabled[__i__], "__this__": this[__i__]}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  static Future<List<void>> updatePrivacyShow_privacyInfo_batch(List<AMapPrivacyShowStatus?> showStatus, List<AMapPrivacyInfoStatus?> containStatus) async {
    assert(showStatus.length == containStatus.length);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::updatePrivacyShow_privacyInfo_batch', [for (int __i__ = 0; __i__ < showStatus.length; __i__++) {"showStatus": showStatus[__i__]?.toValue(), "containStatus": containStatus[__i__]?.toValue()}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  
  static Future<List<void>> updatePrivacyAgree_batch(List<AMapPrivacyAgreeStatus?> agreeStatus) async {
    assert(true);
  
    // invoke native method
    final resultBatch = await kAmapMapFluttifyChannel.invokeMethod('MAMapView::updatePrivacyAgree_batch', [for (int __i__ = 0; __i__ < agreeStatus.length; __i__++) {"agreeStatus": agreeStatus[__i__]?.toValue()}]);
  
  
    return (resultBatch as List).map((__result__) => __result__).cast<void>().toList();
  }
  
  //endregion
}