// AUTO GENERATED FILE, DO NOT EDIT.
// Generated by `flutter_rust_bridge`@ 1.77.1.
// ignore_for_file: non_constant_identifier_names, unused_element, duplicate_ignore, directives_ordering, curly_braces_in_flow_control_structures, unnecessary_lambdas, slash_for_doc_comments, prefer_const_literals_to_create_immutables, implicit_dynamic_list_literal, duplicate_import, unused_import, unnecessary_import, prefer_single_quotes, prefer_const_constructors, use_super_parameters, always_use_package_imports, annotate_overrides, invalid_use_of_protected_member, constant_identifier_names, invalid_use_of_internal_member, prefer_is_empty, unnecessary_const

import 'dart:convert';
import 'dart:async';
import 'package:meta/meta.dart';
import 'package:flutter_rust_bridge/flutter_rust_bridge.dart';
import 'package:uuid/uuid.dart';

import 'dart:ffi' as ffi;

abstract class AppCoreApi {
  Future<RwLockGeoMapInfo> parseMapPackage(
      {required Uint8List data, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kParseMapPackageConstMeta;

  Future<String> runMapPackageMapExtOpaque(
      {required RwLockGeoMapInfo mapPackage, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunMapPackageMapExtOpaqueConstMeta;

  Future<void> runMapPackageSetDstSizeOpaque(
      {required RwLockGeoMapInfo mapPackage,
      required Size dstSize,
      dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunMapPackageSetDstSizeOpaqueConstMeta;

  Future<Size> runMapPackageGetDstSizeOpaque(
      {required RwLockGeoMapInfo mapPackage, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunMapPackageGetDstSizeOpaqueConstMeta;

  Future<Position> runMapPackagePicToPositionOpaque(
      {required RwLockGeoMapInfo mapPackage,
      required Offset onPic,
      dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunMapPackagePicToPositionOpaqueConstMeta;

  Future<Offset> runMapPackagePositionToPicOpaque(
      {required RwLockGeoMapInfo mapPackage,
      required Position position,
      dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunMapPackagePositionToPicOpaqueConstMeta;

  Future<Uint8List> runMapPackageMapImageDataOpaque(
      {required RwLockGeoMapInfo mapPackage, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunMapPackageMapImageDataOpaqueConstMeta;

  Future<ZoneType?> runMapPackageIsInHotZoneOpaque(
      {required RwLockGeoMapInfo mapPackage,
      required Position position,
      dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunMapPackageIsInHotZoneOpaqueConstMeta;

  double distanceMeterBetween(
      {required Position p1, required Position p2, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kDistanceMeterBetweenConstMeta;

  Future<RwLockExercise> newExercise({dynamic hint});

  FlutterRustBridgeTaskConstMeta get kNewExerciseConstMeta;

  Future<void> runExerciseSet(
      {required RwLockExercise exercise,
      required int age,
      required Sex sex,
      required double weightKg,
      required double heightCm,
      required double rhr,
      dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseSetConstMeta;

  Future<void> runExerciseHrPush(
      {required RwLockExercise exercise, required HR hr, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrPushConstMeta;

  Future<void> runExerciseHrListAdd(
      {required RwLockExercise exercise,
      required List<HR> hrList,
      dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrListAddConstMeta;

  Future<void> runExerciseClear(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseClearConstMeta;

  /// 心率折线图， x： 时间（ms）
  Future<List<ChartPoint>> runExerciseChartHrHistory(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseChartHrHistoryConstMeta;

  /// 计算EI图表数据， x： 时间（ms）
  Future<List<ChartPoint>> runExerciseChartEi(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseChartEiConstMeta;

  /// 计算5分钟EI图表数据， x： 时间（ms）
  Future<List<ChartPoint>> runExerciseChartEi5Min(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseChartEi5MinConstMeta;

  Future<int> runExerciseHrMin(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrMinConstMeta;

  Future<int> runExerciseHrMax(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrMaxConstMeta;

  Future<int> runExerciseHrMean(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrMeanConstMeta;

  /// 计算心率百分比 %
  Future<double> runExerciseHrPercent(
      {required RwLockExercise exercise, required int hr, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrPercentConstMeta;

  /// 累计卡路里（KCal）
  Future<double> runExerciseKcal(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseKcalConstMeta;

  /// 累计运动卡路里（exercise KCal）
  Future<double> runExerciseExerciseKcal(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseExerciseKcalConstMeta;

  /// CK
  Future<double> runExerciseCk(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseCkConstMeta;

  Future<double> runExerciseEi(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseEiConstMeta;

  Future<List<CalHrPercentRange>> runExerciseHrPercentRangeList(
      {required RwLockExercise exercise, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrPercentRangeListConstMeta;

  Future<EncryptData> encryptMethodCrypto(
      {required Crypto that, required Uint8List data, dynamic hint});

  FlutterRustBridgeTaskConstMeta get kEncryptMethodCryptoConstMeta;

  Future<Uint8List> decryptMethodCrypto(
      {required Crypto that,
      required Uint8List nonce,
      required Uint8List data,
      dynamic hint});

  FlutterRustBridgeTaskConstMeta get kDecryptMethodCryptoConstMeta;

  DropFnType get dropOpaqueRwLockExercise;
  ShareFnType get shareOpaqueRwLockExercise;
  OpaqueTypeFinalizer get RwLockExerciseFinalizer;

  DropFnType get dropOpaqueRwLockGeoMapInfo;
  ShareFnType get shareOpaqueRwLockGeoMapInfo;
  OpaqueTypeFinalizer get RwLockGeoMapInfoFinalizer;
}

@sealed
class RwLockExercise extends FrbOpaque {
  final AppCoreApi bridge;
  RwLockExercise.fromRaw(int ptr, int size, this.bridge)
      : super.unsafe(ptr, size);
  @override
  DropFnType get dropFn => bridge.dropOpaqueRwLockExercise;

  @override
  ShareFnType get shareFn => bridge.shareOpaqueRwLockExercise;

  @override
  OpaqueTypeFinalizer get staticFinalizer => bridge.RwLockExerciseFinalizer;
}

@sealed
class RwLockGeoMapInfo extends FrbOpaque {
  final AppCoreApi bridge;
  RwLockGeoMapInfo.fromRaw(int ptr, int size, this.bridge)
      : super.unsafe(ptr, size);
  @override
  DropFnType get dropFn => bridge.dropOpaqueRwLockGeoMapInfo;

  @override
  ShareFnType get shareFn => bridge.shareOpaqueRwLockGeoMapInfo;

  @override
  OpaqueTypeFinalizer get staticFinalizer => bridge.RwLockGeoMapInfoFinalizer;
}

class CalHrPercentRange {
  final double start;
  final double end;
  final double percent;

  const CalHrPercentRange({
    required this.start,
    required this.end,
    required this.percent,
  });
}

class ChartPoint {
  final double x;
  final double y;

  const ChartPoint({
    required this.x,
    required this.y,
  });
}

class Crypto {
  final AppCoreApi bridge;

  const Crypto({
    required this.bridge,
  });

  Future<EncryptData> encrypt({required Uint8List data, dynamic hint}) =>
      bridge.encryptMethodCrypto(
        that: this,
        data: data,
      );

  Future<Uint8List> decrypt(
          {required Uint8List nonce, required Uint8List data, dynamic hint}) =>
      bridge.decryptMethodCrypto(
        that: this,
        nonce: nonce,
        data: data,
      );
}

class EncryptData {
  final Uint8List nonce;
  final Uint8List data;

  const EncryptData({
    required this.nonce,
    required this.data,
  });
}

class HR {
  final int timeMs;
  final int hr;

  const HR({
    required this.timeMs,
    required this.hr,
  });
}

class Offset {
  final double x;
  final double y;

  const Offset({
    required this.x,
    required this.y,
  });
}

class Position {
  final double latitude;
  final double longitude;

  const Position({
    required this.latitude,
    required this.longitude,
  });
}

enum Sex {
  Male,
  Female,
}

class Size {
  final double width;
  final double height;

  const Size({
    required this.width,
    required this.height,
  });
}

enum ZoneType {
  Road,
  River,
  Lake,
  ParkingLot,
  ForbiddenZone,
  Lawn,
}

class AppCoreApiImpl implements AppCoreApi {
  final AppCoreApiPlatform _platform;
  factory AppCoreApiImpl(ExternalLibrary dylib) =>
      AppCoreApiImpl.raw(AppCoreApiPlatform(dylib));

  /// Only valid on web/WASM platforms.
  factory AppCoreApiImpl.wasm(FutureOr<WasmModule> module) =>
      AppCoreApiImpl(module as ExternalLibrary);
  AppCoreApiImpl.raw(this._platform);
  Future<RwLockGeoMapInfo> parseMapPackage(
      {required Uint8List data, dynamic hint}) {
    var arg0 = _platform.api2wire_uint_8_list(data);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner.wire_parse_map_package(port_, arg0),
      parseSuccessData: _wire2api_RwLockGeoMapInfo,
      constMeta: kParseMapPackageConstMeta,
      argValues: [data],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kParseMapPackageConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "parse_map_package",
        argNames: ["data"],
      );

  Future<String> runMapPackageMapExtOpaque(
      {required RwLockGeoMapInfo mapPackage, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockGeoMapInfo(mapPackage);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_run_map_package_map_ext_opaque(port_, arg0),
      parseSuccessData: _wire2api_String,
      constMeta: kRunMapPackageMapExtOpaqueConstMeta,
      argValues: [mapPackage],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunMapPackageMapExtOpaqueConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_map_package_map_ext_opaque",
        argNames: ["mapPackage"],
      );

  Future<void> runMapPackageSetDstSizeOpaque(
      {required RwLockGeoMapInfo mapPackage,
      required Size dstSize,
      dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockGeoMapInfo(mapPackage);
    var arg1 = _platform.api2wire_box_autoadd_size(dstSize);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner
          .wire_run_map_package_set_dst_size_opaque(port_, arg0, arg1),
      parseSuccessData: _wire2api_unit,
      constMeta: kRunMapPackageSetDstSizeOpaqueConstMeta,
      argValues: [mapPackage, dstSize],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunMapPackageSetDstSizeOpaqueConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_map_package_set_dst_size_opaque",
        argNames: ["mapPackage", "dstSize"],
      );

  Future<Size> runMapPackageGetDstSizeOpaque(
      {required RwLockGeoMapInfo mapPackage, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockGeoMapInfo(mapPackage);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_run_map_package_get_dst_size_opaque(port_, arg0),
      parseSuccessData: _wire2api_size,
      constMeta: kRunMapPackageGetDstSizeOpaqueConstMeta,
      argValues: [mapPackage],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunMapPackageGetDstSizeOpaqueConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_map_package_get_dst_size_opaque",
        argNames: ["mapPackage"],
      );

  Future<Position> runMapPackagePicToPositionOpaque(
      {required RwLockGeoMapInfo mapPackage,
      required Offset onPic,
      dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockGeoMapInfo(mapPackage);
    var arg1 = _platform.api2wire_box_autoadd_offset(onPic);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner
          .wire_run_map_package_pic_to_position_opaque(port_, arg0, arg1),
      parseSuccessData: _wire2api_position,
      constMeta: kRunMapPackagePicToPositionOpaqueConstMeta,
      argValues: [mapPackage, onPic],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta
      get kRunMapPackagePicToPositionOpaqueConstMeta =>
          const FlutterRustBridgeTaskConstMeta(
            debugName: "run_map_package_pic_to_position_opaque",
            argNames: ["mapPackage", "onPic"],
          );

  Future<Offset> runMapPackagePositionToPicOpaque(
      {required RwLockGeoMapInfo mapPackage,
      required Position position,
      dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockGeoMapInfo(mapPackage);
    var arg1 = _platform.api2wire_box_autoadd_position(position);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner
          .wire_run_map_package_position_to_pic_opaque(port_, arg0, arg1),
      parseSuccessData: _wire2api_offset,
      constMeta: kRunMapPackagePositionToPicOpaqueConstMeta,
      argValues: [mapPackage, position],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta
      get kRunMapPackagePositionToPicOpaqueConstMeta =>
          const FlutterRustBridgeTaskConstMeta(
            debugName: "run_map_package_position_to_pic_opaque",
            argNames: ["mapPackage", "position"],
          );

  Future<Uint8List> runMapPackageMapImageDataOpaque(
      {required RwLockGeoMapInfo mapPackage, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockGeoMapInfo(mapPackage);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner
          .wire_run_map_package_map_image_data_opaque(port_, arg0),
      parseSuccessData: _wire2api_uint_8_list,
      constMeta: kRunMapPackageMapImageDataOpaqueConstMeta,
      argValues: [mapPackage],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta
      get kRunMapPackageMapImageDataOpaqueConstMeta =>
          const FlutterRustBridgeTaskConstMeta(
            debugName: "run_map_package_map_image_data_opaque",
            argNames: ["mapPackage"],
          );

  Future<ZoneType?> runMapPackageIsInHotZoneOpaque(
      {required RwLockGeoMapInfo mapPackage,
      required Position position,
      dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockGeoMapInfo(mapPackage);
    var arg1 = _platform.api2wire_box_autoadd_position(position);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner
          .wire_run_map_package_is_in_hot_zone_opaque(port_, arg0, arg1),
      parseSuccessData: _wire2api_opt_box_autoadd_zone_type,
      constMeta: kRunMapPackageIsInHotZoneOpaqueConstMeta,
      argValues: [mapPackage, position],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunMapPackageIsInHotZoneOpaqueConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_map_package_is_in_hot_zone_opaque",
        argNames: ["mapPackage", "position"],
      );

  double distanceMeterBetween(
      {required Position p1, required Position p2, dynamic hint}) {
    var arg0 = _platform.api2wire_box_autoadd_position(p1);
    var arg1 = _platform.api2wire_box_autoadd_position(p2);
    return _platform.executeSync(FlutterRustBridgeSyncTask(
      callFfi: () => _platform.inner.wire_distance_meter_between(arg0, arg1),
      parseSuccessData: _wire2api_f64,
      constMeta: kDistanceMeterBetweenConstMeta,
      argValues: [p1, p2],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kDistanceMeterBetweenConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "distance_meter_between",
        argNames: ["p1", "p2"],
      );

  Future<RwLockExercise> newExercise({dynamic hint}) {
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner.wire_new_exercise(port_),
      parseSuccessData: _wire2api_RwLockExercise,
      constMeta: kNewExerciseConstMeta,
      argValues: [],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kNewExerciseConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "new_exercise",
        argNames: [],
      );

  Future<void> runExerciseSet(
      {required RwLockExercise exercise,
      required int age,
      required Sex sex,
      required double weightKg,
      required double heightCm,
      required double rhr,
      dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    var arg1 = api2wire_i32(age);
    var arg2 = api2wire_sex(sex);
    var arg3 = api2wire_f64(weightKg);
    var arg4 = api2wire_f64(heightCm);
    var arg5 = api2wire_f64(rhr);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner
          .wire_run_exercise_set(port_, arg0, arg1, arg2, arg3, arg4, arg5),
      parseSuccessData: _wire2api_unit,
      constMeta: kRunExerciseSetConstMeta,
      argValues: [exercise, age, sex, weightKg, heightCm, rhr],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseSetConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_set",
        argNames: ["exercise", "age", "sex", "weightKg", "heightCm", "rhr"],
      );

  Future<void> runExerciseHrPush(
      {required RwLockExercise exercise, required HR hr, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    var arg1 = _platform.api2wire_box_autoadd_hr(hr);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_run_exercise_hr_push(port_, arg0, arg1),
      parseSuccessData: _wire2api_unit,
      constMeta: kRunExerciseHrPushConstMeta,
      argValues: [exercise, hr],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrPushConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_hr_push",
        argNames: ["exercise", "hr"],
      );

  Future<void> runExerciseHrListAdd(
      {required RwLockExercise exercise,
      required List<HR> hrList,
      dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    var arg1 = _platform.api2wire_list_hr(hrList);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_run_exercise_hr_list_add(port_, arg0, arg1),
      parseSuccessData: _wire2api_unit,
      constMeta: kRunExerciseHrListAddConstMeta,
      argValues: [exercise, hrList],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrListAddConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_hr_list_add",
        argNames: ["exercise", "hrList"],
      );

  Future<void> runExerciseClear(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner.wire_run_exercise_clear(port_, arg0),
      parseSuccessData: _wire2api_unit,
      constMeta: kRunExerciseClearConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseClearConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_clear",
        argNames: ["exercise"],
      );

  Future<List<ChartPoint>> runExerciseChartHrHistory(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_run_exercise_chart_hr_history(port_, arg0),
      parseSuccessData: _wire2api_list_chart_point,
      constMeta: kRunExerciseChartHrHistoryConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseChartHrHistoryConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_chart_hr_history",
        argNames: ["exercise"],
      );

  Future<List<ChartPoint>> runExerciseChartEi(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_run_exercise_chart_ei(port_, arg0),
      parseSuccessData: _wire2api_list_chart_point,
      constMeta: kRunExerciseChartEiConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseChartEiConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_chart_ei",
        argNames: ["exercise"],
      );

  Future<List<ChartPoint>> runExerciseChartEi5Min(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_run_exercise_chart_ei_5min(port_, arg0),
      parseSuccessData: _wire2api_list_chart_point,
      constMeta: kRunExerciseChartEi5MinConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseChartEi5MinConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_chart_ei_5min",
        argNames: ["exercise"],
      );

  Future<int> runExerciseHrMin(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner.wire_run_exercise_hr_min(port_, arg0),
      parseSuccessData: _wire2api_i32,
      constMeta: kRunExerciseHrMinConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrMinConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_hr_min",
        argNames: ["exercise"],
      );

  Future<int> runExerciseHrMax(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner.wire_run_exercise_hr_max(port_, arg0),
      parseSuccessData: _wire2api_i32,
      constMeta: kRunExerciseHrMaxConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrMaxConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_hr_max",
        argNames: ["exercise"],
      );

  Future<int> runExerciseHrMean(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_run_exercise_hr_mean(port_, arg0),
      parseSuccessData: _wire2api_i32,
      constMeta: kRunExerciseHrMeanConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrMeanConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_hr_mean",
        argNames: ["exercise"],
      );

  Future<double> runExerciseHrPercent(
      {required RwLockExercise exercise, required int hr, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    var arg1 = api2wire_i32(hr);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_run_exercise_hr_percent(port_, arg0, arg1),
      parseSuccessData: _wire2api_f64,
      constMeta: kRunExerciseHrPercentConstMeta,
      argValues: [exercise, hr],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrPercentConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_hr_percent",
        argNames: ["exercise", "hr"],
      );

  Future<double> runExerciseKcal(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner.wire_run_exercise_kcal(port_, arg0),
      parseSuccessData: _wire2api_f64,
      constMeta: kRunExerciseKcalConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseKcalConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_kcal",
        argNames: ["exercise"],
      );

  Future<double> runExerciseExerciseKcal(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_run_exercise_exercise_kcal(port_, arg0),
      parseSuccessData: _wire2api_f64,
      constMeta: kRunExerciseExerciseKcalConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseExerciseKcalConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_exercise_kcal",
        argNames: ["exercise"],
      );

  Future<double> runExerciseCk(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner.wire_run_exercise_ck(port_, arg0),
      parseSuccessData: _wire2api_f64,
      constMeta: kRunExerciseCkConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseCkConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_ck",
        argNames: ["exercise"],
      );

  Future<double> runExerciseEi(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) => _platform.inner.wire_run_exercise_ei(port_, arg0),
      parseSuccessData: _wire2api_f64,
      constMeta: kRunExerciseEiConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseEiConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_ei",
        argNames: ["exercise"],
      );

  Future<List<CalHrPercentRange>> runExerciseHrPercentRangeList(
      {required RwLockExercise exercise, dynamic hint}) {
    var arg0 = _platform.api2wire_RwLockExercise(exercise);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_run_exercise_hr_percent_range_list(port_, arg0),
      parseSuccessData: _wire2api_list_cal_hr_percent_range,
      constMeta: kRunExerciseHrPercentRangeListConstMeta,
      argValues: [exercise],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kRunExerciseHrPercentRangeListConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "run_exercise_hr_percent_range_list",
        argNames: ["exercise"],
      );

  Future<EncryptData> encryptMethodCrypto(
      {required Crypto that, required Uint8List data, dynamic hint}) {
    var arg0 = _platform.api2wire_box_autoadd_crypto(that);
    var arg1 = _platform.api2wire_uint_8_list(data);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_encrypt__method__Crypto(port_, arg0, arg1),
      parseSuccessData: _wire2api_encrypt_data,
      constMeta: kEncryptMethodCryptoConstMeta,
      argValues: [that, data],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kEncryptMethodCryptoConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "encrypt__method__Crypto",
        argNames: ["that", "data"],
      );

  Future<Uint8List> decryptMethodCrypto(
      {required Crypto that,
      required Uint8List nonce,
      required Uint8List data,
      dynamic hint}) {
    var arg0 = _platform.api2wire_box_autoadd_crypto(that);
    var arg1 = _platform.api2wire_uint_8_list(nonce);
    var arg2 = _platform.api2wire_uint_8_list(data);
    return _platform.executeNormal(FlutterRustBridgeTask(
      callFfi: (port_) =>
          _platform.inner.wire_decrypt__method__Crypto(port_, arg0, arg1, arg2),
      parseSuccessData: _wire2api_uint_8_list,
      constMeta: kDecryptMethodCryptoConstMeta,
      argValues: [that, nonce, data],
      hint: hint,
    ));
  }

  FlutterRustBridgeTaskConstMeta get kDecryptMethodCryptoConstMeta =>
      const FlutterRustBridgeTaskConstMeta(
        debugName: "decrypt__method__Crypto",
        argNames: ["that", "nonce", "data"],
      );

  DropFnType get dropOpaqueRwLockExercise =>
      _platform.inner.drop_opaque_RwLockExercise;
  ShareFnType get shareOpaqueRwLockExercise =>
      _platform.inner.share_opaque_RwLockExercise;
  OpaqueTypeFinalizer get RwLockExerciseFinalizer =>
      _platform.RwLockExerciseFinalizer;

  DropFnType get dropOpaqueRwLockGeoMapInfo =>
      _platform.inner.drop_opaque_RwLockGeoMapInfo;
  ShareFnType get shareOpaqueRwLockGeoMapInfo =>
      _platform.inner.share_opaque_RwLockGeoMapInfo;
  OpaqueTypeFinalizer get RwLockGeoMapInfoFinalizer =>
      _platform.RwLockGeoMapInfoFinalizer;

  void dispose() {
    _platform.dispose();
  }
// Section: wire2api

  RwLockExercise _wire2api_RwLockExercise(dynamic raw) {
    return RwLockExercise.fromRaw(raw[0], raw[1], this);
  }

  RwLockGeoMapInfo _wire2api_RwLockGeoMapInfo(dynamic raw) {
    return RwLockGeoMapInfo.fromRaw(raw[0], raw[1], this);
  }

  String _wire2api_String(dynamic raw) {
    return raw as String;
  }

  ZoneType _wire2api_box_autoadd_zone_type(dynamic raw) {
    return _wire2api_zone_type(raw);
  }

  CalHrPercentRange _wire2api_cal_hr_percent_range(dynamic raw) {
    final arr = raw as List<dynamic>;
    if (arr.length != 3)
      throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
    return CalHrPercentRange(
      start: _wire2api_f64(arr[0]),
      end: _wire2api_f64(arr[1]),
      percent: _wire2api_f64(arr[2]),
    );
  }

  ChartPoint _wire2api_chart_point(dynamic raw) {
    final arr = raw as List<dynamic>;
    if (arr.length != 2)
      throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
    return ChartPoint(
      x: _wire2api_f64(arr[0]),
      y: _wire2api_f64(arr[1]),
    );
  }

  EncryptData _wire2api_encrypt_data(dynamic raw) {
    final arr = raw as List<dynamic>;
    if (arr.length != 2)
      throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
    return EncryptData(
      nonce: _wire2api_uint_8_list(arr[0]),
      data: _wire2api_uint_8_list(arr[1]),
    );
  }

  double _wire2api_f64(dynamic raw) {
    return raw as double;
  }

  int _wire2api_i32(dynamic raw) {
    return raw as int;
  }

  List<CalHrPercentRange> _wire2api_list_cal_hr_percent_range(dynamic raw) {
    return (raw as List<dynamic>).map(_wire2api_cal_hr_percent_range).toList();
  }

  List<ChartPoint> _wire2api_list_chart_point(dynamic raw) {
    return (raw as List<dynamic>).map(_wire2api_chart_point).toList();
  }

  Offset _wire2api_offset(dynamic raw) {
    final arr = raw as List<dynamic>;
    if (arr.length != 2)
      throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
    return Offset(
      x: _wire2api_f64(arr[0]),
      y: _wire2api_f64(arr[1]),
    );
  }

  ZoneType? _wire2api_opt_box_autoadd_zone_type(dynamic raw) {
    return raw == null ? null : _wire2api_box_autoadd_zone_type(raw);
  }

  Position _wire2api_position(dynamic raw) {
    final arr = raw as List<dynamic>;
    if (arr.length != 2)
      throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
    return Position(
      latitude: _wire2api_f64(arr[0]),
      longitude: _wire2api_f64(arr[1]),
    );
  }

  Size _wire2api_size(dynamic raw) {
    final arr = raw as List<dynamic>;
    if (arr.length != 2)
      throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
    return Size(
      width: _wire2api_f64(arr[0]),
      height: _wire2api_f64(arr[1]),
    );
  }

  int _wire2api_u8(dynamic raw) {
    return raw as int;
  }

  Uint8List _wire2api_uint_8_list(dynamic raw) {
    return raw as Uint8List;
  }

  void _wire2api_unit(dynamic raw) {
    return;
  }

  ZoneType _wire2api_zone_type(dynamic raw) {
    return ZoneType.values[raw as int];
  }
}

// Section: api2wire

@protected
double api2wire_f64(double raw) {
  return raw;
}

@protected
int api2wire_i32(int raw) {
  return raw;
}

@protected
int api2wire_sex(Sex raw) {
  return api2wire_i32(raw.index);
}

@protected
int api2wire_u8(int raw) {
  return raw;
}

// Section: finalizer

class AppCoreApiPlatform extends FlutterRustBridgeBase<AppCoreApiWire> {
  AppCoreApiPlatform(ffi.DynamicLibrary dylib) : super(AppCoreApiWire(dylib));

// Section: api2wire

  @protected
  wire_RwLockExercise api2wire_RwLockExercise(RwLockExercise raw) {
    final ptr = inner.new_RwLockExercise();
    _api_fill_to_wire_RwLockExercise(raw, ptr);
    return ptr;
  }

  @protected
  wire_RwLockGeoMapInfo api2wire_RwLockGeoMapInfo(RwLockGeoMapInfo raw) {
    final ptr = inner.new_RwLockGeoMapInfo();
    _api_fill_to_wire_RwLockGeoMapInfo(raw, ptr);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_Crypto> api2wire_box_autoadd_crypto(Crypto raw) {
    final ptr = inner.new_box_autoadd_crypto_0();
    return ptr;
  }

  @protected
  ffi.Pointer<wire_HR> api2wire_box_autoadd_hr(HR raw) {
    final ptr = inner.new_box_autoadd_hr_0();
    _api_fill_to_wire_hr(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_Offset> api2wire_box_autoadd_offset(Offset raw) {
    final ptr = inner.new_box_autoadd_offset_0();
    _api_fill_to_wire_offset(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_Position> api2wire_box_autoadd_position(Position raw) {
    final ptr = inner.new_box_autoadd_position_0();
    _api_fill_to_wire_position(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_Size> api2wire_box_autoadd_size(Size raw) {
    final ptr = inner.new_box_autoadd_size_0();
    _api_fill_to_wire_size(raw, ptr.ref);
    return ptr;
  }

  @protected
  int api2wire_i64(int raw) {
    return raw;
  }

  @protected
  ffi.Pointer<wire_list_hr> api2wire_list_hr(List<HR> raw) {
    final ans = inner.new_list_hr_0(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      _api_fill_to_wire_hr(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_uint_8_list> api2wire_uint_8_list(Uint8List raw) {
    final ans = inner.new_uint_8_list_0(raw.length);
    ans.ref.ptr.asTypedList(raw.length).setAll(0, raw);
    return ans;
  }
// Section: finalizer

  late final OpaqueTypeFinalizer _RwLockExerciseFinalizer =
      OpaqueTypeFinalizer(inner._drop_opaque_RwLockExercisePtr);
  OpaqueTypeFinalizer get RwLockExerciseFinalizer => _RwLockExerciseFinalizer;
  late final OpaqueTypeFinalizer _RwLockGeoMapInfoFinalizer =
      OpaqueTypeFinalizer(inner._drop_opaque_RwLockGeoMapInfoPtr);
  OpaqueTypeFinalizer get RwLockGeoMapInfoFinalizer =>
      _RwLockGeoMapInfoFinalizer;
// Section: api_fill_to_wire

  void _api_fill_to_wire_RwLockExercise(
      RwLockExercise apiObj, wire_RwLockExercise wireObj) {
    wireObj.ptr = apiObj.shareOrMove();
  }

  void _api_fill_to_wire_RwLockGeoMapInfo(
      RwLockGeoMapInfo apiObj, wire_RwLockGeoMapInfo wireObj) {
    wireObj.ptr = apiObj.shareOrMove();
  }

  void _api_fill_to_wire_box_autoadd_hr(
      HR apiObj, ffi.Pointer<wire_HR> wireObj) {
    _api_fill_to_wire_hr(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_offset(
      Offset apiObj, ffi.Pointer<wire_Offset> wireObj) {
    _api_fill_to_wire_offset(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_position(
      Position apiObj, ffi.Pointer<wire_Position> wireObj) {
    _api_fill_to_wire_position(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_size(
      Size apiObj, ffi.Pointer<wire_Size> wireObj) {
    _api_fill_to_wire_size(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_crypto(Crypto apiObj, wire_Crypto wireObj) {}

  void _api_fill_to_wire_hr(HR apiObj, wire_HR wireObj) {
    wireObj.time_ms = api2wire_i64(apiObj.timeMs);
    wireObj.hr = api2wire_u8(apiObj.hr);
  }

  void _api_fill_to_wire_offset(Offset apiObj, wire_Offset wireObj) {
    wireObj.x = api2wire_f64(apiObj.x);
    wireObj.y = api2wire_f64(apiObj.y);
  }

  void _api_fill_to_wire_position(Position apiObj, wire_Position wireObj) {
    wireObj.latitude = api2wire_f64(apiObj.latitude);
    wireObj.longitude = api2wire_f64(apiObj.longitude);
  }

  void _api_fill_to_wire_size(Size apiObj, wire_Size wireObj) {
    wireObj.width = api2wire_f64(apiObj.width);
    wireObj.height = api2wire_f64(apiObj.height);
  }
}

// ignore_for_file: camel_case_types, non_constant_identifier_names, avoid_positional_boolean_parameters, annotate_overrides, constant_identifier_names

// AUTO GENERATED FILE, DO NOT EDIT.
//
// Generated by `package:ffigen`.
// ignore_for_file: type=lint

/// generated by flutter_rust_bridge
class AppCoreApiWire implements FlutterRustBridgeWireBase {
  @internal
  late final dartApi = DartApiDl(init_frb_dart_api_dl);

  /// Holds the symbol lookup function.
  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
      _lookup;

  /// The symbols are looked up in [dynamicLibrary].
  AppCoreApiWire(ffi.DynamicLibrary dynamicLibrary)
      : _lookup = dynamicLibrary.lookup;

  /// The symbols are looked up with [lookup].
  AppCoreApiWire.fromLookup(
      ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
          lookup)
      : _lookup = lookup;

  void store_dart_post_cobject(
    DartPostCObjectFnType ptr,
  ) {
    return _store_dart_post_cobject(
      ptr,
    );
  }

  late final _store_dart_post_cobjectPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(DartPostCObjectFnType)>>(
          'store_dart_post_cobject');
  late final _store_dart_post_cobject = _store_dart_post_cobjectPtr
      .asFunction<void Function(DartPostCObjectFnType)>();

  Object get_dart_object(
    int ptr,
  ) {
    return _get_dart_object(
      ptr,
    );
  }

  late final _get_dart_objectPtr =
      _lookup<ffi.NativeFunction<ffi.Handle Function(ffi.UintPtr)>>(
          'get_dart_object');
  late final _get_dart_object =
      _get_dart_objectPtr.asFunction<Object Function(int)>();

  void drop_dart_object(
    int ptr,
  ) {
    return _drop_dart_object(
      ptr,
    );
  }

  late final _drop_dart_objectPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.UintPtr)>>(
          'drop_dart_object');
  late final _drop_dart_object =
      _drop_dart_objectPtr.asFunction<void Function(int)>();

  int new_dart_opaque(
    Object handle,
  ) {
    return _new_dart_opaque(
      handle,
    );
  }

  late final _new_dart_opaquePtr =
      _lookup<ffi.NativeFunction<ffi.UintPtr Function(ffi.Handle)>>(
          'new_dart_opaque');
  late final _new_dart_opaque =
      _new_dart_opaquePtr.asFunction<int Function(Object)>();

  int init_frb_dart_api_dl(
    ffi.Pointer<ffi.Void> obj,
  ) {
    return _init_frb_dart_api_dl(
      obj,
    );
  }

  late final _init_frb_dart_api_dlPtr =
      _lookup<ffi.NativeFunction<ffi.IntPtr Function(ffi.Pointer<ffi.Void>)>>(
          'init_frb_dart_api_dl');
  late final _init_frb_dart_api_dl = _init_frb_dart_api_dlPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  void wire_parse_map_package(
    int port_,
    ffi.Pointer<wire_uint_8_list> data,
  ) {
    return _wire_parse_map_package(
      port_,
      data,
    );
  }

  late final _wire_parse_map_packagePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_parse_map_package');
  late final _wire_parse_map_package = _wire_parse_map_packagePtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_run_map_package_map_ext_opaque(
    int port_,
    wire_RwLockGeoMapInfo map_package,
  ) {
    return _wire_run_map_package_map_ext_opaque(
      port_,
      map_package,
    );
  }

  late final _wire_run_map_package_map_ext_opaquePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              wire_RwLockGeoMapInfo)>>('wire_run_map_package_map_ext_opaque');
  late final _wire_run_map_package_map_ext_opaque =
      _wire_run_map_package_map_ext_opaquePtr
          .asFunction<void Function(int, wire_RwLockGeoMapInfo)>();

  void wire_run_map_package_set_dst_size_opaque(
    int port_,
    wire_RwLockGeoMapInfo map_package,
    ffi.Pointer<wire_Size> dst_size,
  ) {
    return _wire_run_map_package_set_dst_size_opaque(
      port_,
      map_package,
      dst_size,
    );
  }

  late final _wire_run_map_package_set_dst_size_opaquePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  ffi.Int64, wire_RwLockGeoMapInfo, ffi.Pointer<wire_Size>)>>(
      'wire_run_map_package_set_dst_size_opaque');
  late final _wire_run_map_package_set_dst_size_opaque =
      _wire_run_map_package_set_dst_size_opaquePtr.asFunction<
          void Function(int, wire_RwLockGeoMapInfo, ffi.Pointer<wire_Size>)>();

  void wire_run_map_package_get_dst_size_opaque(
    int port_,
    wire_RwLockGeoMapInfo map_package,
  ) {
    return _wire_run_map_package_get_dst_size_opaque(
      port_,
      map_package,
    );
  }

  late final _wire_run_map_package_get_dst_size_opaquePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, wire_RwLockGeoMapInfo)>>(
      'wire_run_map_package_get_dst_size_opaque');
  late final _wire_run_map_package_get_dst_size_opaque =
      _wire_run_map_package_get_dst_size_opaquePtr
          .asFunction<void Function(int, wire_RwLockGeoMapInfo)>();

  void wire_run_map_package_pic_to_position_opaque(
    int port_,
    wire_RwLockGeoMapInfo map_package,
    ffi.Pointer<wire_Offset> on_pic,
  ) {
    return _wire_run_map_package_pic_to_position_opaque(
      port_,
      map_package,
      on_pic,
    );
  }

  late final _wire_run_map_package_pic_to_position_opaquePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  ffi.Int64, wire_RwLockGeoMapInfo, ffi.Pointer<wire_Offset>)>>(
      'wire_run_map_package_pic_to_position_opaque');
  late final _wire_run_map_package_pic_to_position_opaque =
      _wire_run_map_package_pic_to_position_opaquePtr.asFunction<
          void Function(
              int, wire_RwLockGeoMapInfo, ffi.Pointer<wire_Offset>)>();

  void wire_run_map_package_position_to_pic_opaque(
    int port_,
    wire_RwLockGeoMapInfo map_package,
    ffi.Pointer<wire_Position> position,
  ) {
    return _wire_run_map_package_position_to_pic_opaque(
      port_,
      map_package,
      position,
    );
  }

  late final _wire_run_map_package_position_to_pic_opaquePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, wire_RwLockGeoMapInfo,
                  ffi.Pointer<wire_Position>)>>(
      'wire_run_map_package_position_to_pic_opaque');
  late final _wire_run_map_package_position_to_pic_opaque =
      _wire_run_map_package_position_to_pic_opaquePtr.asFunction<
          void Function(
              int, wire_RwLockGeoMapInfo, ffi.Pointer<wire_Position>)>();

  void wire_run_map_package_map_image_data_opaque(
    int port_,
    wire_RwLockGeoMapInfo map_package,
  ) {
    return _wire_run_map_package_map_image_data_opaque(
      port_,
      map_package,
    );
  }

  late final _wire_run_map_package_map_image_data_opaquePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, wire_RwLockGeoMapInfo)>>(
      'wire_run_map_package_map_image_data_opaque');
  late final _wire_run_map_package_map_image_data_opaque =
      _wire_run_map_package_map_image_data_opaquePtr
          .asFunction<void Function(int, wire_RwLockGeoMapInfo)>();

  void wire_run_map_package_is_in_hot_zone_opaque(
    int port_,
    wire_RwLockGeoMapInfo map_package,
    ffi.Pointer<wire_Position> position,
  ) {
    return _wire_run_map_package_is_in_hot_zone_opaque(
      port_,
      map_package,
      position,
    );
  }

  late final _wire_run_map_package_is_in_hot_zone_opaquePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, wire_RwLockGeoMapInfo,
                  ffi.Pointer<wire_Position>)>>(
      'wire_run_map_package_is_in_hot_zone_opaque');
  late final _wire_run_map_package_is_in_hot_zone_opaque =
      _wire_run_map_package_is_in_hot_zone_opaquePtr.asFunction<
          void Function(
              int, wire_RwLockGeoMapInfo, ffi.Pointer<wire_Position>)>();

  WireSyncReturn wire_distance_meter_between(
    ffi.Pointer<wire_Position> p1,
    ffi.Pointer<wire_Position> p2,
  ) {
    return _wire_distance_meter_between(
      p1,
      p2,
    );
  }

  late final _wire_distance_meter_betweenPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_Position>,
              ffi.Pointer<wire_Position>)>>('wire_distance_meter_between');
  late final _wire_distance_meter_between =
      _wire_distance_meter_betweenPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_Position>, ffi.Pointer<wire_Position>)>();

  void wire_new_exercise(
    int port_,
  ) {
    return _wire_new_exercise(
      port_,
    );
  }

  late final _wire_new_exercisePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_new_exercise');
  late final _wire_new_exercise =
      _wire_new_exercisePtr.asFunction<void Function(int)>();

  void wire_run_exercise_set(
    int port_,
    wire_RwLockExercise exercise,
    int age,
    int sex,
    double weight_kg,
    double height_cm,
    double rhr,
  ) {
    return _wire_run_exercise_set(
      port_,
      exercise,
      age,
      sex,
      weight_kg,
      height_cm,
      rhr,
    );
  }

  late final _wire_run_exercise_setPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              wire_RwLockExercise,
              ffi.Int32,
              ffi.Int32,
              ffi.Double,
              ffi.Double,
              ffi.Double)>>('wire_run_exercise_set');
  late final _wire_run_exercise_set = _wire_run_exercise_setPtr.asFunction<
      void Function(
          int, wire_RwLockExercise, int, int, double, double, double)>();

  void wire_run_exercise_hr_push(
    int port_,
    wire_RwLockExercise exercise,
    ffi.Pointer<wire_HR> hr,
  ) {
    return _wire_run_exercise_hr_push(
      port_,
      exercise,
      hr,
    );
  }

  late final _wire_run_exercise_hr_pushPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, wire_RwLockExercise,
              ffi.Pointer<wire_HR>)>>('wire_run_exercise_hr_push');
  late final _wire_run_exercise_hr_push =
      _wire_run_exercise_hr_pushPtr.asFunction<
          void Function(int, wire_RwLockExercise, ffi.Pointer<wire_HR>)>();

  void wire_run_exercise_hr_list_add(
    int port_,
    wire_RwLockExercise exercise,
    ffi.Pointer<wire_list_hr> hr_list,
  ) {
    return _wire_run_exercise_hr_list_add(
      port_,
      exercise,
      hr_list,
    );
  }

  late final _wire_run_exercise_hr_list_addPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, wire_RwLockExercise,
              ffi.Pointer<wire_list_hr>)>>('wire_run_exercise_hr_list_add');
  late final _wire_run_exercise_hr_list_add =
      _wire_run_exercise_hr_list_addPtr.asFunction<
          void Function(int, wire_RwLockExercise, ffi.Pointer<wire_list_hr>)>();

  void wire_run_exercise_clear(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_clear(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_clearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, wire_RwLockExercise)>>('wire_run_exercise_clear');
  late final _wire_run_exercise_clear = _wire_run_exercise_clearPtr
      .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_run_exercise_chart_hr_history(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_chart_hr_history(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_chart_hr_historyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              wire_RwLockExercise)>>('wire_run_exercise_chart_hr_history');
  late final _wire_run_exercise_chart_hr_history =
      _wire_run_exercise_chart_hr_historyPtr
          .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_run_exercise_chart_ei(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_chart_ei(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_chart_eiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, wire_RwLockExercise)>>('wire_run_exercise_chart_ei');
  late final _wire_run_exercise_chart_ei = _wire_run_exercise_chart_eiPtr
      .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_run_exercise_chart_ei_5min(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_chart_ei_5min(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_chart_ei_5minPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              wire_RwLockExercise)>>('wire_run_exercise_chart_ei_5min');
  late final _wire_run_exercise_chart_ei_5min =
      _wire_run_exercise_chart_ei_5minPtr
          .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_run_exercise_hr_min(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_hr_min(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_hr_minPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, wire_RwLockExercise)>>('wire_run_exercise_hr_min');
  late final _wire_run_exercise_hr_min = _wire_run_exercise_hr_minPtr
      .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_run_exercise_hr_max(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_hr_max(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_hr_maxPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, wire_RwLockExercise)>>('wire_run_exercise_hr_max');
  late final _wire_run_exercise_hr_max = _wire_run_exercise_hr_maxPtr
      .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_run_exercise_hr_mean(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_hr_mean(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_hr_meanPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, wire_RwLockExercise)>>('wire_run_exercise_hr_mean');
  late final _wire_run_exercise_hr_mean = _wire_run_exercise_hr_meanPtr
      .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_run_exercise_hr_percent(
    int port_,
    wire_RwLockExercise exercise,
    int hr,
  ) {
    return _wire_run_exercise_hr_percent(
      port_,
      exercise,
      hr,
    );
  }

  late final _wire_run_exercise_hr_percentPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, wire_RwLockExercise,
              ffi.Int32)>>('wire_run_exercise_hr_percent');
  late final _wire_run_exercise_hr_percent = _wire_run_exercise_hr_percentPtr
      .asFunction<void Function(int, wire_RwLockExercise, int)>();

  void wire_run_exercise_kcal(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_kcal(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_kcalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, wire_RwLockExercise)>>('wire_run_exercise_kcal');
  late final _wire_run_exercise_kcal = _wire_run_exercise_kcalPtr
      .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_run_exercise_exercise_kcal(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_exercise_kcal(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_exercise_kcalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              wire_RwLockExercise)>>('wire_run_exercise_exercise_kcal');
  late final _wire_run_exercise_exercise_kcal =
      _wire_run_exercise_exercise_kcalPtr
          .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_run_exercise_ck(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_ck(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_ckPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, wire_RwLockExercise)>>('wire_run_exercise_ck');
  late final _wire_run_exercise_ck = _wire_run_exercise_ckPtr
      .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_run_exercise_ei(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_ei(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_eiPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, wire_RwLockExercise)>>('wire_run_exercise_ei');
  late final _wire_run_exercise_ei = _wire_run_exercise_eiPtr
      .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_run_exercise_hr_percent_range_list(
    int port_,
    wire_RwLockExercise exercise,
  ) {
    return _wire_run_exercise_hr_percent_range_list(
      port_,
      exercise,
    );
  }

  late final _wire_run_exercise_hr_percent_range_listPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              wire_RwLockExercise)>>('wire_run_exercise_hr_percent_range_list');
  late final _wire_run_exercise_hr_percent_range_list =
      _wire_run_exercise_hr_percent_range_listPtr
          .asFunction<void Function(int, wire_RwLockExercise)>();

  void wire_encrypt__method__Crypto(
    int port_,
    ffi.Pointer<wire_Crypto> that,
    ffi.Pointer<wire_uint_8_list> data,
  ) {
    return _wire_encrypt__method__Crypto(
      port_,
      that,
      data,
    );
  }

  late final _wire_encrypt__method__CryptoPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_Crypto>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_encrypt__method__Crypto');
  late final _wire_encrypt__method__Crypto =
      _wire_encrypt__method__CryptoPtr.asFunction<
          void Function(
              int, ffi.Pointer<wire_Crypto>, ffi.Pointer<wire_uint_8_list>)>();

  void wire_decrypt__method__Crypto(
    int port_,
    ffi.Pointer<wire_Crypto> that,
    ffi.Pointer<wire_uint_8_list> nonce,
    ffi.Pointer<wire_uint_8_list> data,
  ) {
    return _wire_decrypt__method__Crypto(
      port_,
      that,
      nonce,
      data,
    );
  }

  late final _wire_decrypt__method__CryptoPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_Crypto>,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_decrypt__method__Crypto');
  late final _wire_decrypt__method__Crypto =
      _wire_decrypt__method__CryptoPtr.asFunction<
          void Function(int, ffi.Pointer<wire_Crypto>,
              ffi.Pointer<wire_uint_8_list>, ffi.Pointer<wire_uint_8_list>)>();

  wire_RwLockExercise new_RwLockExercise() {
    return _new_RwLockExercise();
  }

  late final _new_RwLockExercisePtr =
      _lookup<ffi.NativeFunction<wire_RwLockExercise Function()>>(
          'new_RwLockExercise');
  late final _new_RwLockExercise =
      _new_RwLockExercisePtr.asFunction<wire_RwLockExercise Function()>();

  wire_RwLockGeoMapInfo new_RwLockGeoMapInfo() {
    return _new_RwLockGeoMapInfo();
  }

  late final _new_RwLockGeoMapInfoPtr =
      _lookup<ffi.NativeFunction<wire_RwLockGeoMapInfo Function()>>(
          'new_RwLockGeoMapInfo');
  late final _new_RwLockGeoMapInfo =
      _new_RwLockGeoMapInfoPtr.asFunction<wire_RwLockGeoMapInfo Function()>();

  ffi.Pointer<wire_Crypto> new_box_autoadd_crypto_0() {
    return _new_box_autoadd_crypto_0();
  }

  late final _new_box_autoadd_crypto_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_Crypto> Function()>>(
          'new_box_autoadd_crypto_0');
  late final _new_box_autoadd_crypto_0 = _new_box_autoadd_crypto_0Ptr
      .asFunction<ffi.Pointer<wire_Crypto> Function()>();

  ffi.Pointer<wire_HR> new_box_autoadd_hr_0() {
    return _new_box_autoadd_hr_0();
  }

  late final _new_box_autoadd_hr_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_HR> Function()>>(
          'new_box_autoadd_hr_0');
  late final _new_box_autoadd_hr_0 =
      _new_box_autoadd_hr_0Ptr.asFunction<ffi.Pointer<wire_HR> Function()>();

  ffi.Pointer<wire_Offset> new_box_autoadd_offset_0() {
    return _new_box_autoadd_offset_0();
  }

  late final _new_box_autoadd_offset_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_Offset> Function()>>(
          'new_box_autoadd_offset_0');
  late final _new_box_autoadd_offset_0 = _new_box_autoadd_offset_0Ptr
      .asFunction<ffi.Pointer<wire_Offset> Function()>();

  ffi.Pointer<wire_Position> new_box_autoadd_position_0() {
    return _new_box_autoadd_position_0();
  }

  late final _new_box_autoadd_position_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_Position> Function()>>(
          'new_box_autoadd_position_0');
  late final _new_box_autoadd_position_0 = _new_box_autoadd_position_0Ptr
      .asFunction<ffi.Pointer<wire_Position> Function()>();

  ffi.Pointer<wire_Size> new_box_autoadd_size_0() {
    return _new_box_autoadd_size_0();
  }

  late final _new_box_autoadd_size_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_Size> Function()>>(
          'new_box_autoadd_size_0');
  late final _new_box_autoadd_size_0 = _new_box_autoadd_size_0Ptr
      .asFunction<ffi.Pointer<wire_Size> Function()>();

  ffi.Pointer<wire_list_hr> new_list_hr_0(
    int len,
  ) {
    return _new_list_hr_0(
      len,
    );
  }

  late final _new_list_hr_0Ptr = _lookup<
          ffi.NativeFunction<ffi.Pointer<wire_list_hr> Function(ffi.Int32)>>(
      'new_list_hr_0');
  late final _new_list_hr_0 =
      _new_list_hr_0Ptr.asFunction<ffi.Pointer<wire_list_hr> Function(int)>();

  ffi.Pointer<wire_uint_8_list> new_uint_8_list_0(
    int len,
  ) {
    return _new_uint_8_list_0(
      len,
    );
  }

  late final _new_uint_8_list_0Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<wire_uint_8_list> Function(
              ffi.Int32)>>('new_uint_8_list_0');
  late final _new_uint_8_list_0 = _new_uint_8_list_0Ptr
      .asFunction<ffi.Pointer<wire_uint_8_list> Function(int)>();

  void drop_opaque_RwLockExercise(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _drop_opaque_RwLockExercise(
      ptr,
    );
  }

  late final _drop_opaque_RwLockExercisePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'drop_opaque_RwLockExercise');
  late final _drop_opaque_RwLockExercise = _drop_opaque_RwLockExercisePtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> share_opaque_RwLockExercise(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _share_opaque_RwLockExercise(
      ptr,
    );
  }

  late final _share_opaque_RwLockExercisePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('share_opaque_RwLockExercise');
  late final _share_opaque_RwLockExercise = _share_opaque_RwLockExercisePtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  void drop_opaque_RwLockGeoMapInfo(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _drop_opaque_RwLockGeoMapInfo(
      ptr,
    );
  }

  late final _drop_opaque_RwLockGeoMapInfoPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'drop_opaque_RwLockGeoMapInfo');
  late final _drop_opaque_RwLockGeoMapInfo = _drop_opaque_RwLockGeoMapInfoPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> share_opaque_RwLockGeoMapInfo(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _share_opaque_RwLockGeoMapInfo(
      ptr,
    );
  }

  late final _share_opaque_RwLockGeoMapInfoPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('share_opaque_RwLockGeoMapInfo');
  late final _share_opaque_RwLockGeoMapInfo = _share_opaque_RwLockGeoMapInfoPtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  void free_WireSyncReturn(
    WireSyncReturn ptr,
  ) {
    return _free_WireSyncReturn(
      ptr,
    );
  }

  late final _free_WireSyncReturnPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(WireSyncReturn)>>(
          'free_WireSyncReturn');
  late final _free_WireSyncReturn =
      _free_WireSyncReturnPtr.asFunction<void Function(WireSyncReturn)>();
}

final class _Dart_Handle extends ffi.Opaque {}

final class wire_uint_8_list extends ffi.Struct {
  external ffi.Pointer<ffi.Uint8> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_RwLockGeoMapInfo extends ffi.Struct {
  external ffi.Pointer<ffi.Void> ptr;
}

final class wire_Size extends ffi.Struct {
  @ffi.Double()
  external double width;

  @ffi.Double()
  external double height;
}

final class wire_Offset extends ffi.Struct {
  @ffi.Double()
  external double x;

  @ffi.Double()
  external double y;
}

final class wire_Position extends ffi.Struct {
  @ffi.Double()
  external double latitude;

  @ffi.Double()
  external double longitude;
}

final class wire_RwLockExercise extends ffi.Struct {
  external ffi.Pointer<ffi.Void> ptr;
}

final class wire_HR extends ffi.Struct {
  @ffi.Int64()
  external int time_ms;

  @ffi.Uint8()
  external int hr;
}

final class wire_list_hr extends ffi.Struct {
  external ffi.Pointer<wire_HR> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_Crypto extends ffi.Opaque {}

typedef DartPostCObjectFnType = ffi.Pointer<
    ffi.NativeFunction<
        ffi.Bool Function(DartPort port_id, ffi.Pointer<ffi.Void> message)>>;
typedef DartPort = ffi.Int64;