// AUTO GENERATED FILE, DO NOT EDIT.
// Generated by `flutter_rust_bridge`.

// 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, prefer_single_quotes, prefer_const_constructors

import 'dart:convert';
import 'dart:typed_data';
import 'package:freezed_annotation/freezed_annotation.dart';

import 'dart:convert';
import 'dart:typed_data';
import 'package:flutter_rust_bridge/flutter_rust_bridge.dart';
import 'dart:ffi' as ffi;

part 'generated_bridge.freezed.dart';

abstract class Rustdesk {
  /// FFI for rustdesk core's main entry.
  /// Return true if the app should continue running with UI(possibly Flutter), false if the app should exit.
  Future<bool> rustdeskCoreMain({dynamic hint});

  Stream<String> startGlobalEventStream(
      {required String appType, dynamic hint});

  Future<void> stopGlobalEventStream({required String appType, dynamic hint});

  Future<void> hostStopSystemKeyPropagate(
      {required bool stopped, dynamic hint});

  String sessionAddSync(
      {required String id,
      required bool isFileTransfer,
      required bool isPortForward,
      dynamic hint});

  Stream<EventToUI> sessionStart({required String id, dynamic hint});

  Future<bool?> sessionGetRemember({required String id, dynamic hint});

  Future<bool?> sessionGetToggleOption(
      {required String id, required String arg, dynamic hint});

  bool sessionGetToggleOptionSync(
      {required String id, required String arg, dynamic hint});

  Future<String?> sessionGetOption(
      {required String id, required String arg, dynamic hint});

  Future<void> sessionLogin(
      {required String id,
      required String password,
      required bool remember,
      dynamic hint});

  Future<void> sessionClose({required String id, dynamic hint});

  Future<void> sessionRefresh({required String id, dynamic hint});

  Future<void> sessionReconnect({required String id, dynamic hint});

  Future<void> sessionToggleOption(
      {required String id, required String value, dynamic hint});

  Future<String?> sessionGetImageQuality({required String id, dynamic hint});

  Future<void> sessionSetImageQuality(
      {required String id, required String value, dynamic hint});

  Future<Int32List?> sessionGetCustomImageQuality(
      {required String id, dynamic hint});

  Future<void> sessionSetCustomImageQuality(
      {required String id, required int value, dynamic hint});

  Future<void> sessionLockScreen({required String id, dynamic hint});

  Future<void> sessionCtrlAltDel({required String id, dynamic hint});

  Future<void> sessionSwitchDisplay(
      {required String id, required int value, dynamic hint});

  Future<void> sessionInputKey(
      {required String id,
      required String name,
      required bool down,
      required bool press,
      required bool alt,
      required bool ctrl,
      required bool shift,
      required bool command,
      dynamic hint});

  Future<void> sessionInputString(
      {required String id, required String value, dynamic hint});

  Future<void> sessionSendChat(
      {required String id, required String text, dynamic hint});

  Future<void> sessionPeerOption(
      {required String id,
      required String name,
      required String value,
      dynamic hint});

  Future<String> sessionGetPeerOption(
      {required String id, required String name, dynamic hint});

  Future<void> sessionInputOsPassword(
      {required String id, required String value, dynamic hint});

  Future<void> sessionReadRemoteDir(
      {required String id,
      required String path,
      required bool includeHidden,
      dynamic hint});

  Future<void> sessionSendFiles(
      {required String id,
      required int actId,
      required String path,
      required String to,
      required int fileNum,
      required bool includeHidden,
      required bool isRemote,
      dynamic hint});

  Future<void> sessionSetConfirmOverrideFile(
      {required String id,
      required int actId,
      required int fileNum,
      required bool needOverride,
      required bool remember,
      required bool isUpload,
      dynamic hint});

  Future<void> sessionRemoveFile(
      {required String id,
      required int actId,
      required String path,
      required int fileNum,
      required bool isRemote,
      dynamic hint});

  Future<void> sessionReadDirRecursive(
      {required String id,
      required int actId,
      required String path,
      required bool isRemote,
      required bool showHidden,
      dynamic hint});

  Future<void> sessionRemoveAllEmptyDirs(
      {required String id,
      required int actId,
      required String path,
      required bool isRemote,
      dynamic hint});

  Future<void> sessionCancelJob(
      {required String id, required int actId, dynamic hint});

  Future<void> sessionCreateDir(
      {required String id,
      required int actId,
      required String path,
      required bool isRemote,
      dynamic hint});

  Future<String> sessionReadLocalDirSync(
      {required String id,
      required String path,
      required bool showHidden,
      dynamic hint});

  Future<String> sessionGetPlatform(
      {required String id, required bool isRemote, dynamic hint});

  Future<void> sessionLoadLastTransferJobs({required String id, dynamic hint});

  Future<void> sessionAddJob(
      {required String id,
      required int actId,
      required String path,
      required String to,
      required int fileNum,
      required bool includeHidden,
      required bool isRemote,
      dynamic hint});

  Future<void> sessionResumeJob(
      {required String id,
      required int actId,
      required bool isRemote,
      dynamic hint});

  Future<List<String>> mainGetSoundInputs({dynamic hint});

  Future<void> mainChangeId({required String newId, dynamic hint});

  Future<String> mainGetAsyncStatus({dynamic hint});

  Future<String> mainGetOption({required String key, dynamic hint});

  Future<void> mainSetOption(
      {required String key, required String value, dynamic hint});

  Future<String> mainGetOptions({dynamic hint});

  Future<void> mainSetOptions({required String json, dynamic hint});

  Future<String> mainTestIfValidServer({required String server, dynamic hint});

  Future<void> mainSetSocks(
      {required String proxy,
      required String username,
      required String password,
      dynamic hint});

  Future<List<String>> mainGetSocks({dynamic hint});

  Future<String> mainGetAppName({dynamic hint});

  Future<String> mainGetLicense({dynamic hint});

  Future<String> mainGetVersion({dynamic hint});

  Future<List<String>> mainGetFav({dynamic hint});

  Future<void> mainStoreFav({required List<String> favs, dynamic hint});

  Future<String> mainGetPeer({required String id, dynamic hint});

  Future<String> mainGetLanPeers({dynamic hint});

  Future<String> mainGetConnectStatus({dynamic hint});

  Future<void> mainCheckConnectStatus({dynamic hint});

  Future<bool> mainIsUsingPublicServer({dynamic hint});

  Future<void> mainDiscover({dynamic hint});

  Future<bool> mainHasRendezvousService({dynamic hint});

  Future<String> mainGetApiServer({dynamic hint});

  Future<void> mainPostRequest(
      {required String url,
      required String body,
      required String header,
      dynamic hint});

  Future<String> mainGetLocalOption({required String key, dynamic hint});

  Future<void> mainSetLocalOption(
      {required String key, required String value, dynamic hint});

  Future<String> mainGetMyId({dynamic hint});

  Future<String> mainGetUuid({dynamic hint});

  Future<String> mainGetPeerOption(
      {required String id, required String key, dynamic hint});

  Future<void> mainSetPeerOption(
      {required String id,
      required String key,
      required String value,
      dynamic hint});

  Future<void> mainForgetPassword({required String id, dynamic hint});

  Future<String> mainGetRecentPeers({dynamic hint});

  Future<void> mainLoadRecentPeers({dynamic hint});

  Future<void> mainLoadFavPeers({dynamic hint});

  Future<void> mainLoadLanPeers({dynamic hint});

  Future<void> sessionAddPortForward(
      {required String id,
      required int localPort,
      required String remoteHost,
      required int remotePort,
      dynamic hint});

  Future<void> sessionRemovePortForward(
      {required String id, required int localPort, dynamic hint});

  Future<String> mainGetLastRemoteId({dynamic hint});

  Future<String> mainGetSoftwareUpdateUrl({dynamic hint});

  Future<String> mainGetHomeDir({dynamic hint});

  Future<String> mainGetLangs({dynamic hint});

  Future<String> mainGetTemporaryPassword({dynamic hint});

  Future<String> mainGetPermanentPassword({dynamic hint});

  Future<int> mainGetOnlineStatue({dynamic hint});

  Future<String> mainGetClientsState({dynamic hint});

  Future<String?> mainCheckClientsLength({required int length, dynamic hint});

  Future<void> mainInit({required String appDir, dynamic hint});

  Future<void> mainDeviceId({required String id, dynamic hint});

  Future<void> mainDeviceName({required String name, dynamic hint});

  Future<void> mainRemovePeer({required String id, dynamic hint});

  Future<bool> mainHasHwcodec({dynamic hint});

  Future<void> sessionSendMouse(
      {required String id, required String msg, dynamic hint});

  Future<void> sessionRestartRemoteDevice({required String id, dynamic hint});

  Future<void> mainSetHomeDir({required String home, dynamic hint});

  Future<void> mainStopService({dynamic hint});

  Future<void> mainStartService({dynamic hint});

  Future<void> mainUpdateTemporaryPassword({dynamic hint});

  Future<void> mainSetPermanentPassword(
      {required String password, dynamic hint});

  Future<bool> mainCheckSuperUserPermission({dynamic hint});

  Future<void> mainCheckMouseTime({dynamic hint});

  Future<double> mainGetMouseTime({dynamic hint});

  Future<void> cmSendChat(
      {required int connId, required String msg, dynamic hint});

  Future<void> cmLoginRes(
      {required int connId, required bool res, dynamic hint});

  Future<void> cmCloseConnection({required int connId, dynamic hint});

  Future<void> cmCheckClickTime({required int connId, dynamic hint});

  Future<double> cmGetClickTime({dynamic hint});

  Future<void> cmSwitchPermission(
      {required int connId,
      required String name,
      required bool enabled,
      dynamic hint});

  Future<String> mainGetIcon({dynamic hint});

  Future<void> queryOnlines({required List<String> ids, dynamic hint});
}

@freezed
class EventToUI with _$EventToUI {
  const factory EventToUI.event(
    String field0,
  ) = Event;
  const factory EventToUI.rgba(
    Uint8List field0,
  ) = Rgba;
}

class RustdeskImpl extends FlutterRustBridgeBase<RustdeskWire>
    implements Rustdesk {
  factory RustdeskImpl(ffi.DynamicLibrary dylib) =>
      RustdeskImpl.raw(RustdeskWire(dylib));

  RustdeskImpl.raw(RustdeskWire inner) : super(inner);

  Future<bool> rustdeskCoreMain({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_rustdesk_core_main(port_),
        parseSuccessData: _wire2api_bool,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "rustdesk_core_main",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Stream<String> startGlobalEventStream(
          {required String appType, dynamic hint}) =>
      executeStream(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_start_global_event_stream(
            port_, _api2wire_String(appType)),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "start_global_event_stream",
          argNames: ["appType"],
        ),
        argValues: [appType],
        hint: hint,
      ));

  Future<void> stopGlobalEventStream({required String appType, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_stop_global_event_stream(
            port_, _api2wire_String(appType)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "stop_global_event_stream",
          argNames: ["appType"],
        ),
        argValues: [appType],
        hint: hint,
      ));

  Future<void> hostStopSystemKeyPropagate(
          {required bool stopped, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_host_stop_system_key_propagate(port_, stopped),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "host_stop_system_key_propagate",
          argNames: ["stopped"],
        ),
        argValues: [stopped],
        hint: hint,
      ));

  String sessionAddSync(
          {required String id,
          required bool isFileTransfer,
          required bool isPortForward,
          dynamic hint}) =>
      executeSync(FlutterRustBridgeSyncTask(
        callFfi: () => inner.wire_session_add_sync(
            _api2wire_String(id), isFileTransfer, isPortForward),
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_add_sync",
          argNames: ["id", "isFileTransfer", "isPortForward"],
        ),
        argValues: [id, isFileTransfer, isPortForward],
        hint: hint,
      ));

  Stream<EventToUI> sessionStart({required String id, dynamic hint}) =>
      executeStream(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_session_start(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_event_to_ui,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_start",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<bool?> sessionGetRemember({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_session_get_remember(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_opt_box_autoadd_bool,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_get_remember",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<bool?> sessionGetToggleOption(
          {required String id, required String arg, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_get_toggle_option(
            port_, _api2wire_String(id), _api2wire_String(arg)),
        parseSuccessData: _wire2api_opt_box_autoadd_bool,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_get_toggle_option",
          argNames: ["id", "arg"],
        ),
        argValues: [id, arg],
        hint: hint,
      ));

  bool sessionGetToggleOptionSync(
          {required String id, required String arg, dynamic hint}) =>
      executeSync(FlutterRustBridgeSyncTask(
        callFfi: () => inner.wire_session_get_toggle_option_sync(
            _api2wire_String(id), _api2wire_String(arg)),
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_get_toggle_option_sync",
          argNames: ["id", "arg"],
        ),
        argValues: [id, arg],
        hint: hint,
      ));

  Future<String?> sessionGetOption(
          {required String id, required String arg, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_get_option(
            port_, _api2wire_String(id), _api2wire_String(arg)),
        parseSuccessData: _wire2api_opt_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_get_option",
          argNames: ["id", "arg"],
        ),
        argValues: [id, arg],
        hint: hint,
      ));

  Future<void> sessionLogin(
          {required String id,
          required String password,
          required bool remember,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_login(
            port_, _api2wire_String(id), _api2wire_String(password), remember),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_login",
          argNames: ["id", "password", "remember"],
        ),
        argValues: [id, password, remember],
        hint: hint,
      ));

  Future<void> sessionClose({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_session_close(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_close",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<void> sessionRefresh({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_session_refresh(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_refresh",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<void> sessionReconnect({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_session_reconnect(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_reconnect",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<void> sessionToggleOption(
          {required String id, required String value, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_toggle_option(
            port_, _api2wire_String(id), _api2wire_String(value)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_toggle_option",
          argNames: ["id", "value"],
        ),
        argValues: [id, value],
        hint: hint,
      ));

  Future<String?> sessionGetImageQuality({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_session_get_image_quality(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_opt_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_get_image_quality",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<void> sessionSetImageQuality(
          {required String id, required String value, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_set_image_quality(
            port_, _api2wire_String(id), _api2wire_String(value)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_set_image_quality",
          argNames: ["id", "value"],
        ),
        argValues: [id, value],
        hint: hint,
      ));

  Future<Int32List?> sessionGetCustomImageQuality(
          {required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_get_custom_image_quality(
            port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_opt_int_32_list,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_get_custom_image_quality",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<void> sessionSetCustomImageQuality(
          {required String id, required int value, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_set_custom_image_quality(
            port_, _api2wire_String(id), _api2wire_i32(value)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_set_custom_image_quality",
          argNames: ["id", "value"],
        ),
        argValues: [id, value],
        hint: hint,
      ));

  Future<void> sessionLockScreen({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_session_lock_screen(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_lock_screen",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<void> sessionCtrlAltDel({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_session_ctrl_alt_del(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_ctrl_alt_del",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<void> sessionSwitchDisplay(
          {required String id, required int value, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_switch_display(
            port_, _api2wire_String(id), _api2wire_i32(value)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_switch_display",
          argNames: ["id", "value"],
        ),
        argValues: [id, value],
        hint: hint,
      ));

  Future<void> sessionInputKey(
          {required String id,
          required String name,
          required bool down,
          required bool press,
          required bool alt,
          required bool ctrl,
          required bool shift,
          required bool command,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_input_key(
            port_,
            _api2wire_String(id),
            _api2wire_String(name),
            down,
            press,
            alt,
            ctrl,
            shift,
            command),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_input_key",
          argNames: [
            "id",
            "name",
            "down",
            "press",
            "alt",
            "ctrl",
            "shift",
            "command"
          ],
        ),
        argValues: [id, name, down, press, alt, ctrl, shift, command],
        hint: hint,
      ));

  Future<void> sessionInputString(
          {required String id, required String value, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_input_string(
            port_, _api2wire_String(id), _api2wire_String(value)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_input_string",
          argNames: ["id", "value"],
        ),
        argValues: [id, value],
        hint: hint,
      ));

  Future<void> sessionSendChat(
          {required String id, required String text, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_send_chat(
            port_, _api2wire_String(id), _api2wire_String(text)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_send_chat",
          argNames: ["id", "text"],
        ),
        argValues: [id, text],
        hint: hint,
      ));

  Future<void> sessionPeerOption(
          {required String id,
          required String name,
          required String value,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_peer_option(
            port_,
            _api2wire_String(id),
            _api2wire_String(name),
            _api2wire_String(value)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_peer_option",
          argNames: ["id", "name", "value"],
        ),
        argValues: [id, name, value],
        hint: hint,
      ));

  Future<String> sessionGetPeerOption(
          {required String id, required String name, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_get_peer_option(
            port_, _api2wire_String(id), _api2wire_String(name)),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_get_peer_option",
          argNames: ["id", "name"],
        ),
        argValues: [id, name],
        hint: hint,
      ));

  Future<void> sessionInputOsPassword(
          {required String id, required String value, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_input_os_password(
            port_, _api2wire_String(id), _api2wire_String(value)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_input_os_password",
          argNames: ["id", "value"],
        ),
        argValues: [id, value],
        hint: hint,
      ));

  Future<void> sessionReadRemoteDir(
          {required String id,
          required String path,
          required bool includeHidden,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_read_remote_dir(
            port_, _api2wire_String(id), _api2wire_String(path), includeHidden),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_read_remote_dir",
          argNames: ["id", "path", "includeHidden"],
        ),
        argValues: [id, path, includeHidden],
        hint: hint,
      ));

  Future<void> sessionSendFiles(
          {required String id,
          required int actId,
          required String path,
          required String to,
          required int fileNum,
          required bool includeHidden,
          required bool isRemote,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_send_files(
            port_,
            _api2wire_String(id),
            _api2wire_i32(actId),
            _api2wire_String(path),
            _api2wire_String(to),
            _api2wire_i32(fileNum),
            includeHidden,
            isRemote),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_send_files",
          argNames: [
            "id",
            "actId",
            "path",
            "to",
            "fileNum",
            "includeHidden",
            "isRemote"
          ],
        ),
        argValues: [id, actId, path, to, fileNum, includeHidden, isRemote],
        hint: hint,
      ));

  Future<void> sessionSetConfirmOverrideFile(
          {required String id,
          required int actId,
          required int fileNum,
          required bool needOverride,
          required bool remember,
          required bool isUpload,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_set_confirm_override_file(
            port_,
            _api2wire_String(id),
            _api2wire_i32(actId),
            _api2wire_i32(fileNum),
            needOverride,
            remember,
            isUpload),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_set_confirm_override_file",
          argNames: [
            "id",
            "actId",
            "fileNum",
            "needOverride",
            "remember",
            "isUpload"
          ],
        ),
        argValues: [id, actId, fileNum, needOverride, remember, isUpload],
        hint: hint,
      ));

  Future<void> sessionRemoveFile(
          {required String id,
          required int actId,
          required String path,
          required int fileNum,
          required bool isRemote,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_remove_file(
            port_,
            _api2wire_String(id),
            _api2wire_i32(actId),
            _api2wire_String(path),
            _api2wire_i32(fileNum),
            isRemote),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_remove_file",
          argNames: ["id", "actId", "path", "fileNum", "isRemote"],
        ),
        argValues: [id, actId, path, fileNum, isRemote],
        hint: hint,
      ));

  Future<void> sessionReadDirRecursive(
          {required String id,
          required int actId,
          required String path,
          required bool isRemote,
          required bool showHidden,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_read_dir_recursive(
            port_,
            _api2wire_String(id),
            _api2wire_i32(actId),
            _api2wire_String(path),
            isRemote,
            showHidden),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_read_dir_recursive",
          argNames: ["id", "actId", "path", "isRemote", "showHidden"],
        ),
        argValues: [id, actId, path, isRemote, showHidden],
        hint: hint,
      ));

  Future<void> sessionRemoveAllEmptyDirs(
          {required String id,
          required int actId,
          required String path,
          required bool isRemote,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_remove_all_empty_dirs(
            port_,
            _api2wire_String(id),
            _api2wire_i32(actId),
            _api2wire_String(path),
            isRemote),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_remove_all_empty_dirs",
          argNames: ["id", "actId", "path", "isRemote"],
        ),
        argValues: [id, actId, path, isRemote],
        hint: hint,
      ));

  Future<void> sessionCancelJob(
          {required String id, required int actId, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_cancel_job(
            port_, _api2wire_String(id), _api2wire_i32(actId)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_cancel_job",
          argNames: ["id", "actId"],
        ),
        argValues: [id, actId],
        hint: hint,
      ));

  Future<void> sessionCreateDir(
          {required String id,
          required int actId,
          required String path,
          required bool isRemote,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_create_dir(
            port_,
            _api2wire_String(id),
            _api2wire_i32(actId),
            _api2wire_String(path),
            isRemote),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_create_dir",
          argNames: ["id", "actId", "path", "isRemote"],
        ),
        argValues: [id, actId, path, isRemote],
        hint: hint,
      ));

  Future<String> sessionReadLocalDirSync(
          {required String id,
          required String path,
          required bool showHidden,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_read_local_dir_sync(
            port_, _api2wire_String(id), _api2wire_String(path), showHidden),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_read_local_dir_sync",
          argNames: ["id", "path", "showHidden"],
        ),
        argValues: [id, path, showHidden],
        hint: hint,
      ));

  Future<String> sessionGetPlatform(
          {required String id, required bool isRemote, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_get_platform(
            port_, _api2wire_String(id), isRemote),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_get_platform",
          argNames: ["id", "isRemote"],
        ),
        argValues: [id, isRemote],
        hint: hint,
      ));

  Future<void> sessionLoadLastTransferJobs(
          {required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_load_last_transfer_jobs(
            port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_load_last_transfer_jobs",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<void> sessionAddJob(
          {required String id,
          required int actId,
          required String path,
          required String to,
          required int fileNum,
          required bool includeHidden,
          required bool isRemote,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_add_job(
            port_,
            _api2wire_String(id),
            _api2wire_i32(actId),
            _api2wire_String(path),
            _api2wire_String(to),
            _api2wire_i32(fileNum),
            includeHidden,
            isRemote),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_add_job",
          argNames: [
            "id",
            "actId",
            "path",
            "to",
            "fileNum",
            "includeHidden",
            "isRemote"
          ],
        ),
        argValues: [id, actId, path, to, fileNum, includeHidden, isRemote],
        hint: hint,
      ));

  Future<void> sessionResumeJob(
          {required String id,
          required int actId,
          required bool isRemote,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_resume_job(
            port_, _api2wire_String(id), _api2wire_i32(actId), isRemote),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_resume_job",
          argNames: ["id", "actId", "isRemote"],
        ),
        argValues: [id, actId, isRemote],
        hint: hint,
      ));

  Future<List<String>> mainGetSoundInputs({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_sound_inputs(port_),
        parseSuccessData: _wire2api_StringList,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_sound_inputs",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainChangeId({required String newId, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_change_id(port_, _api2wire_String(newId)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_change_id",
          argNames: ["newId"],
        ),
        argValues: [newId],
        hint: hint,
      ));

  Future<String> mainGetAsyncStatus({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_async_status(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_async_status",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetOption({required String key, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_get_option(port_, _api2wire_String(key)),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_option",
          argNames: ["key"],
        ),
        argValues: [key],
        hint: hint,
      ));

  Future<void> mainSetOption(
          {required String key, required String value, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_set_option(
            port_, _api2wire_String(key), _api2wire_String(value)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_set_option",
          argNames: ["key", "value"],
        ),
        argValues: [key, value],
        hint: hint,
      ));

  Future<String> mainGetOptions({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_options(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_options",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainSetOptions({required String json, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_set_options(port_, _api2wire_String(json)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_set_options",
          argNames: ["json"],
        ),
        argValues: [json],
        hint: hint,
      ));

  Future<String> mainTestIfValidServer(
          {required String server, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_test_if_valid_server(
            port_, _api2wire_String(server)),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_test_if_valid_server",
          argNames: ["server"],
        ),
        argValues: [server],
        hint: hint,
      ));

  Future<void> mainSetSocks(
          {required String proxy,
          required String username,
          required String password,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_set_socks(
            port_,
            _api2wire_String(proxy),
            _api2wire_String(username),
            _api2wire_String(password)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_set_socks",
          argNames: ["proxy", "username", "password"],
        ),
        argValues: [proxy, username, password],
        hint: hint,
      ));

  Future<List<String>> mainGetSocks({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_socks(port_),
        parseSuccessData: _wire2api_StringList,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_socks",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetAppName({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_app_name(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_app_name",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetLicense({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_license(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_license",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetVersion({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_version(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_version",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<List<String>> mainGetFav({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_fav(port_),
        parseSuccessData: _wire2api_StringList,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_fav",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainStoreFav({required List<String> favs, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_store_fav(port_, _api2wire_StringList(favs)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_store_fav",
          argNames: ["favs"],
        ),
        argValues: [favs],
        hint: hint,
      ));

  Future<String> mainGetPeer({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_get_peer(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_peer",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<String> mainGetLanPeers({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_lan_peers(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_lan_peers",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetConnectStatus({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_connect_status(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_connect_status",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainCheckConnectStatus({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_check_connect_status(port_),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_check_connect_status",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<bool> mainIsUsingPublicServer({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_is_using_public_server(port_),
        parseSuccessData: _wire2api_bool,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_is_using_public_server",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainDiscover({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_discover(port_),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_discover",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<bool> mainHasRendezvousService({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_has_rendezvous_service(port_),
        parseSuccessData: _wire2api_bool,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_has_rendezvous_service",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetApiServer({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_api_server(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_api_server",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainPostRequest(
          {required String url,
          required String body,
          required String header,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_post_request(
            port_,
            _api2wire_String(url),
            _api2wire_String(body),
            _api2wire_String(header)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_post_request",
          argNames: ["url", "body", "header"],
        ),
        argValues: [url, body, header],
        hint: hint,
      ));

  Future<String> mainGetLocalOption({required String key, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_get_local_option(port_, _api2wire_String(key)),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_local_option",
          argNames: ["key"],
        ),
        argValues: [key],
        hint: hint,
      ));

  Future<void> mainSetLocalOption(
          {required String key, required String value, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_set_local_option(
            port_, _api2wire_String(key), _api2wire_String(value)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_set_local_option",
          argNames: ["key", "value"],
        ),
        argValues: [key, value],
        hint: hint,
      ));

  Future<String> mainGetMyId({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_my_id(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_my_id",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetUuid({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_uuid(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_uuid",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetPeerOption(
          {required String id, required String key, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_peer_option(
            port_, _api2wire_String(id), _api2wire_String(key)),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_peer_option",
          argNames: ["id", "key"],
        ),
        argValues: [id, key],
        hint: hint,
      ));

  Future<void> mainSetPeerOption(
          {required String id,
          required String key,
          required String value,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_set_peer_option(
            port_,
            _api2wire_String(id),
            _api2wire_String(key),
            _api2wire_String(value)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_set_peer_option",
          argNames: ["id", "key", "value"],
        ),
        argValues: [id, key, value],
        hint: hint,
      ));

  Future<void> mainForgetPassword({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_forget_password(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_forget_password",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<String> mainGetRecentPeers({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_recent_peers(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_recent_peers",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainLoadRecentPeers({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_load_recent_peers(port_),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_load_recent_peers",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainLoadFavPeers({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_load_fav_peers(port_),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_load_fav_peers",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainLoadLanPeers({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_load_lan_peers(port_),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_load_lan_peers",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> sessionAddPortForward(
          {required String id,
          required int localPort,
          required String remoteHost,
          required int remotePort,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_add_port_forward(
            port_,
            _api2wire_String(id),
            _api2wire_i32(localPort),
            _api2wire_String(remoteHost),
            _api2wire_i32(remotePort)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_add_port_forward",
          argNames: ["id", "localPort", "remoteHost", "remotePort"],
        ),
        argValues: [id, localPort, remoteHost, remotePort],
        hint: hint,
      ));

  Future<void> sessionRemovePortForward(
          {required String id, required int localPort, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_remove_port_forward(
            port_, _api2wire_String(id), _api2wire_i32(localPort)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_remove_port_forward",
          argNames: ["id", "localPort"],
        ),
        argValues: [id, localPort],
        hint: hint,
      ));

  Future<String> mainGetLastRemoteId({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_last_remote_id(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_last_remote_id",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetSoftwareUpdateUrl({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_software_update_url(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_software_update_url",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetHomeDir({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_home_dir(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_home_dir",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetLangs({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_langs(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_langs",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetTemporaryPassword({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_temporary_password(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_temporary_password",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetPermanentPassword({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_permanent_password(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_permanent_password",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<int> mainGetOnlineStatue({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_online_statue(port_),
        parseSuccessData: _wire2api_i64,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_online_statue",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String> mainGetClientsState({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_clients_state(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_clients_state",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<String?> mainCheckClientsLength({required int length, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_check_clients_length(
            port_, _api2wire_usize(length)),
        parseSuccessData: _wire2api_opt_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_check_clients_length",
          argNames: ["length"],
        ),
        argValues: [length],
        hint: hint,
      ));

  Future<void> mainInit({required String appDir, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_init(port_, _api2wire_String(appDir)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_init",
          argNames: ["appDir"],
        ),
        argValues: [appDir],
        hint: hint,
      ));

  Future<void> mainDeviceId({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_device_id(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_device_id",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<void> mainDeviceName({required String name, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_device_name(port_, _api2wire_String(name)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_device_name",
          argNames: ["name"],
        ),
        argValues: [name],
        hint: hint,
      ));

  Future<void> mainRemovePeer({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_remove_peer(port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_remove_peer",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<bool> mainHasHwcodec({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_has_hwcodec(port_),
        parseSuccessData: _wire2api_bool,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_has_hwcodec",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> sessionSendMouse(
          {required String id, required String msg, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_send_mouse(
            port_, _api2wire_String(id), _api2wire_String(msg)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_send_mouse",
          argNames: ["id", "msg"],
        ),
        argValues: [id, msg],
        hint: hint,
      ));

  Future<void> sessionRestartRemoteDevice({required String id, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_session_restart_remote_device(
            port_, _api2wire_String(id)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "session_restart_remote_device",
          argNames: ["id"],
        ),
        argValues: [id],
        hint: hint,
      ));

  Future<void> mainSetHomeDir({required String home, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_main_set_home_dir(port_, _api2wire_String(home)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_set_home_dir",
          argNames: ["home"],
        ),
        argValues: [home],
        hint: hint,
      ));

  Future<void> mainStopService({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_stop_service(port_),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_stop_service",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainStartService({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_start_service(port_),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_start_service",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainUpdateTemporaryPassword({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_update_temporary_password(port_),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_update_temporary_password",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainSetPermanentPassword(
          {required String password, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_set_permanent_password(
            port_, _api2wire_String(password)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_set_permanent_password",
          argNames: ["password"],
        ),
        argValues: [password],
        hint: hint,
      ));

  Future<bool> mainCheckSuperUserPermission({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_check_super_user_permission(port_),
        parseSuccessData: _wire2api_bool,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_check_super_user_permission",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> mainCheckMouseTime({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_check_mouse_time(port_),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_check_mouse_time",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<double> mainGetMouseTime({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_mouse_time(port_),
        parseSuccessData: _wire2api_f64,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_mouse_time",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> cmSendChat(
          {required int connId, required String msg, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_cm_send_chat(
            port_, _api2wire_i32(connId), _api2wire_String(msg)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "cm_send_chat",
          argNames: ["connId", "msg"],
        ),
        argValues: [connId, msg],
        hint: hint,
      ));

  Future<void> cmLoginRes(
          {required int connId, required bool res, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_cm_login_res(port_, _api2wire_i32(connId), res),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "cm_login_res",
          argNames: ["connId", "res"],
        ),
        argValues: [connId, res],
        hint: hint,
      ));

  Future<void> cmCloseConnection({required int connId, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_cm_close_connection(port_, _api2wire_i32(connId)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "cm_close_connection",
          argNames: ["connId"],
        ),
        argValues: [connId],
        hint: hint,
      ));

  Future<void> cmCheckClickTime({required int connId, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_cm_check_click_time(port_, _api2wire_i32(connId)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "cm_check_click_time",
          argNames: ["connId"],
        ),
        argValues: [connId],
        hint: hint,
      ));

  Future<double> cmGetClickTime({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_cm_get_click_time(port_),
        parseSuccessData: _wire2api_f64,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "cm_get_click_time",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> cmSwitchPermission(
          {required int connId,
          required String name,
          required bool enabled,
          dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_cm_switch_permission(
            port_, _api2wire_i32(connId), _api2wire_String(name), enabled),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "cm_switch_permission",
          argNames: ["connId", "name", "enabled"],
        ),
        argValues: [connId, name, enabled],
        hint: hint,
      ));

  Future<String> mainGetIcon({dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) => inner.wire_main_get_icon(port_),
        parseSuccessData: _wire2api_String,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "main_get_icon",
          argNames: [],
        ),
        argValues: [],
        hint: hint,
      ));

  Future<void> queryOnlines({required List<String> ids, dynamic hint}) =>
      executeNormal(FlutterRustBridgeTask(
        callFfi: (port_) =>
            inner.wire_query_onlines(port_, _api2wire_StringList(ids)),
        parseSuccessData: _wire2api_unit,
        constMeta: const FlutterRustBridgeTaskConstMeta(
          debugName: "query_onlines",
          argNames: ["ids"],
        ),
        argValues: [ids],
        hint: hint,
      ));

  // Section: api2wire
  ffi.Pointer<wire_uint_8_list> _api2wire_String(String raw) {
    return _api2wire_uint_8_list(utf8.encoder.convert(raw));
  }

  ffi.Pointer<wire_StringList> _api2wire_StringList(List<String> raw) {
    final ans = inner.new_StringList(raw.length);
    for (var i = 0; i < raw.length; i++) {
      ans.ref.ptr[i] = _api2wire_String(raw[i]);
    }
    return ans;
  }

  int _api2wire_bool(bool raw) {
    return raw ? 1 : 0;
  }

  int _api2wire_i32(int raw) {
    return raw;
  }

  int _api2wire_u8(int raw) {
    return raw;
  }

  ffi.Pointer<wire_uint_8_list> _api2wire_uint_8_list(Uint8List raw) {
    final ans = inner.new_uint_8_list(raw.length);
    ans.ref.ptr.asTypedList(raw.length).setAll(0, raw);
    return ans;
  }

  int _api2wire_usize(int raw) {
    return raw;
  }

  // Section: api_fill_to_wire

}

// Section: wire2api
String _wire2api_String(dynamic raw) {
  return raw as String;
}

List<String> _wire2api_StringList(dynamic raw) {
  return (raw as List<dynamic>).cast<String>();
}

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

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

bool _wire2api_bool(dynamic raw) {
  return raw as bool;
}

bool _wire2api_box_autoadd_bool(dynamic raw) {
  return raw as bool;
}

EventToUI _wire2api_event_to_ui(dynamic raw) {
  switch (raw[0]) {
    case 0:
      return Event(
        _wire2api_String(raw[1]),
      );
    case 1:
      return Rgba(
        _wire2api_ZeroCopyBuffer_Uint8List(raw[1]),
      );
    default:
      throw Exception("unreachable");
  }
}

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

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

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

Int32List _wire2api_int_32_list(dynamic raw) {
  return raw as Int32List;
}

String? _wire2api_opt_String(dynamic raw) {
  return raw == null ? null : _wire2api_String(raw);
}

bool? _wire2api_opt_box_autoadd_bool(dynamic raw) {
  return raw == null ? null : _wire2api_box_autoadd_bool(raw);
}

Int32List? _wire2api_opt_int_32_list(dynamic raw) {
  return raw == null ? null : _wire2api_int_32_list(raw);
}

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;
}

// 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`.

/// generated by flutter_rust_bridge
class RustdeskWire implements FlutterRustBridgeWireBase {
  /// Holds the symbol lookup function.
  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
      _lookup;

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

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

  void wire_rustdesk_core_main(
    int port_,
  ) {
    return _wire_rustdesk_core_main(
      port_,
    );
  }

  late final _wire_rustdesk_core_mainPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_rustdesk_core_main');
  late final _wire_rustdesk_core_main =
      _wire_rustdesk_core_mainPtr.asFunction<void Function(int)>();

  void wire_start_global_event_stream(
    int port_,
    ffi.Pointer<wire_uint_8_list> app_type,
  ) {
    return _wire_start_global_event_stream(
      port_,
      app_type,
    );
  }

  late final _wire_start_global_event_streamPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>)>>(
      'wire_start_global_event_stream');
  late final _wire_start_global_event_stream =
      _wire_start_global_event_streamPtr
          .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_stop_global_event_stream(
    int port_,
    ffi.Pointer<wire_uint_8_list> app_type,
  ) {
    return _wire_stop_global_event_stream(
      port_,
      app_type,
    );
  }

  late final _wire_stop_global_event_streamPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_stop_global_event_stream');
  late final _wire_stop_global_event_stream = _wire_stop_global_event_streamPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_host_stop_system_key_propagate(
    int port_,
    ffi.Pointer<bool> stopped,
  ) {
    return _wire_host_stop_system_key_propagate(
      port_,
      stopped,
    );
  }

  late final _wire_host_stop_system_key_propagatePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.Pointer<bool>)>>(
      'wire_host_stop_system_key_propagate');
  late final _wire_host_stop_system_key_propagate =
      _wire_host_stop_system_key_propagatePtr
          .asFunction<void Function(int, ffi.Pointer<bool>)>();

  WireSyncReturnStruct wire_session_add_sync(
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<bool> is_file_transfer,
    ffi.Pointer<bool> is_port_forward,
  ) {
    return _wire_session_add_sync(
      id,
      is_file_transfer,
      is_port_forward,
    );
  }

  late final _wire_session_add_syncPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturnStruct Function(ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<bool>, ffi.Pointer<bool>)>>('wire_session_add_sync');
  late final _wire_session_add_sync = _wire_session_add_syncPtr.asFunction<
      WireSyncReturnStruct Function(ffi.Pointer<wire_uint_8_list>,
          ffi.Pointer<bool>, ffi.Pointer<bool>)>();

  void wire_session_start(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_session_start(
      port_,
      id,
    );
  }

  late final _wire_session_startPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, ffi.Pointer<wire_uint_8_list>)>>('wire_session_start');
  late final _wire_session_start = _wire_session_startPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_get_remember(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_session_get_remember(
      port_,
      id,
    );
  }

  late final _wire_session_get_rememberPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_get_remember');
  late final _wire_session_get_remember = _wire_session_get_rememberPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_get_toggle_option(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> arg,
  ) {
    return _wire_session_get_toggle_option(
      port_,
      id,
      arg,
    );
  }

  late final _wire_session_get_toggle_optionPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
                  ffi.Pointer<wire_uint_8_list>)>>(
      'wire_session_get_toggle_option');
  late final _wire_session_get_toggle_option =
      _wire_session_get_toggle_optionPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>();

  WireSyncReturnStruct wire_session_get_toggle_option_sync(
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> arg,
  ) {
    return _wire_session_get_toggle_option_sync(
      id,
      arg,
    );
  }

  late final _wire_session_get_toggle_option_syncPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturnStruct Function(ffi.Pointer<wire_uint_8_list>,
                  ffi.Pointer<wire_uint_8_list>)>>(
      'wire_session_get_toggle_option_sync');
  late final _wire_session_get_toggle_option_sync =
      _wire_session_get_toggle_option_syncPtr.asFunction<
          WireSyncReturnStruct Function(
              ffi.Pointer<wire_uint_8_list>, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_get_option(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> arg,
  ) {
    return _wire_session_get_option(
      port_,
      id,
      arg,
    );
  }

  late final _wire_session_get_optionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_get_option');
  late final _wire_session_get_option = _wire_session_get_optionPtr.asFunction<
      void Function(
          int, ffi.Pointer<wire_uint_8_list>, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_login(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> password,
    ffi.Pointer<bool> remember,
  ) {
    return _wire_session_login(
      port_,
      id,
      password,
      remember,
    );
  }

  late final _wire_session_loginPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<bool>)>>('wire_session_login');
  late final _wire_session_login = _wire_session_loginPtr.asFunction<
      void Function(int, ffi.Pointer<wire_uint_8_list>,
          ffi.Pointer<wire_uint_8_list>, ffi.Pointer<bool>)>();

  void wire_session_close(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_session_close(
      port_,
      id,
    );
  }

  late final _wire_session_closePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, ffi.Pointer<wire_uint_8_list>)>>('wire_session_close');
  late final _wire_session_close = _wire_session_closePtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_refresh(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_session_refresh(
      port_,
      id,
    );
  }

  late final _wire_session_refreshPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_refresh');
  late final _wire_session_refresh = _wire_session_refreshPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_reconnect(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_session_reconnect(
      port_,
      id,
    );
  }

  late final _wire_session_reconnectPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_reconnect');
  late final _wire_session_reconnect = _wire_session_reconnectPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_toggle_option(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> value,
  ) {
    return _wire_session_toggle_option(
      port_,
      id,
      value,
    );
  }

  late final _wire_session_toggle_optionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_toggle_option');
  late final _wire_session_toggle_option =
      _wire_session_toggle_optionPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_get_image_quality(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_session_get_image_quality(
      port_,
      id,
    );
  }

  late final _wire_session_get_image_qualityPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>)>>(
      'wire_session_get_image_quality');
  late final _wire_session_get_image_quality =
      _wire_session_get_image_qualityPtr
          .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_set_image_quality(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> value,
  ) {
    return _wire_session_set_image_quality(
      port_,
      id,
      value,
    );
  }

  late final _wire_session_set_image_qualityPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
                  ffi.Pointer<wire_uint_8_list>)>>(
      'wire_session_set_image_quality');
  late final _wire_session_set_image_quality =
      _wire_session_set_image_qualityPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_get_custom_image_quality(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_session_get_custom_image_quality(
      port_,
      id,
    );
  }

  late final _wire_session_get_custom_image_qualityPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>)>>(
      'wire_session_get_custom_image_quality');
  late final _wire_session_get_custom_image_quality =
      _wire_session_get_custom_image_qualityPtr
          .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_set_custom_image_quality(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int value,
  ) {
    return _wire_session_set_custom_image_quality(
      port_,
      id,
      value,
    );
  }

  late final _wire_session_set_custom_image_qualityPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Int32)>>('wire_session_set_custom_image_quality');
  late final _wire_session_set_custom_image_quality =
      _wire_session_set_custom_image_qualityPtr
          .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>, int)>();

  void wire_session_lock_screen(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_session_lock_screen(
      port_,
      id,
    );
  }

  late final _wire_session_lock_screenPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_lock_screen');
  late final _wire_session_lock_screen = _wire_session_lock_screenPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_ctrl_alt_del(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_session_ctrl_alt_del(
      port_,
      id,
    );
  }

  late final _wire_session_ctrl_alt_delPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_ctrl_alt_del');
  late final _wire_session_ctrl_alt_del = _wire_session_ctrl_alt_delPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_switch_display(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int value,
  ) {
    return _wire_session_switch_display(
      port_,
      id,
      value,
    );
  }

  late final _wire_session_switch_displayPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Int32)>>('wire_session_switch_display');
  late final _wire_session_switch_display = _wire_session_switch_displayPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>, int)>();

  void wire_session_input_key(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> name,
    ffi.Pointer<bool> down,
    ffi.Pointer<bool> press,
    ffi.Pointer<bool> alt,
    ffi.Pointer<bool> ctrl,
    ffi.Pointer<bool> shift,
    ffi.Pointer<bool> command,
  ) {
    return _wire_session_input_key(
      port_,
      id,
      name,
      down,
      press,
      alt,
      ctrl,
      shift,
      command,
    );
  }

  late final _wire_session_input_keyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<bool>,
              ffi.Pointer<bool>,
              ffi.Pointer<bool>,
              ffi.Pointer<bool>,
              ffi.Pointer<bool>,
              ffi.Pointer<bool>)>>('wire_session_input_key');
  late final _wire_session_input_key = _wire_session_input_keyPtr.asFunction<
      void Function(
          int,
          ffi.Pointer<wire_uint_8_list>,
          ffi.Pointer<wire_uint_8_list>,
          ffi.Pointer<bool>,
          ffi.Pointer<bool>,
          ffi.Pointer<bool>,
          ffi.Pointer<bool>,
          ffi.Pointer<bool>,
          ffi.Pointer<bool>)>();

  void wire_session_input_string(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> value,
  ) {
    return _wire_session_input_string(
      port_,
      id,
      value,
    );
  }

  late final _wire_session_input_stringPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_input_string');
  late final _wire_session_input_string =
      _wire_session_input_stringPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_send_chat(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> text,
  ) {
    return _wire_session_send_chat(
      port_,
      id,
      text,
    );
  }

  late final _wire_session_send_chatPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_send_chat');
  late final _wire_session_send_chat = _wire_session_send_chatPtr.asFunction<
      void Function(
          int, ffi.Pointer<wire_uint_8_list>, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_peer_option(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> name,
    ffi.Pointer<wire_uint_8_list> value,
  ) {
    return _wire_session_peer_option(
      port_,
      id,
      name,
      value,
    );
  }

  late final _wire_session_peer_optionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_peer_option');
  late final _wire_session_peer_option =
      _wire_session_peer_optionPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_get_peer_option(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> name,
  ) {
    return _wire_session_get_peer_option(
      port_,
      id,
      name,
    );
  }

  late final _wire_session_get_peer_optionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_get_peer_option');
  late final _wire_session_get_peer_option =
      _wire_session_get_peer_optionPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_input_os_password(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> value,
  ) {
    return _wire_session_input_os_password(
      port_,
      id,
      value,
    );
  }

  late final _wire_session_input_os_passwordPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
                  ffi.Pointer<wire_uint_8_list>)>>(
      'wire_session_input_os_password');
  late final _wire_session_input_os_password =
      _wire_session_input_os_passwordPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_read_remote_dir(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> path,
    ffi.Pointer<bool> include_hidden,
  ) {
    return _wire_session_read_remote_dir(
      port_,
      id,
      path,
      include_hidden,
    );
  }

  late final _wire_session_read_remote_dirPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<bool>)>>('wire_session_read_remote_dir');
  late final _wire_session_read_remote_dir =
      _wire_session_read_remote_dirPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>, ffi.Pointer<bool>)>();

  void wire_session_send_files(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int act_id,
    ffi.Pointer<wire_uint_8_list> path,
    ffi.Pointer<wire_uint_8_list> to,
    int file_num,
    ffi.Pointer<bool> include_hidden,
    ffi.Pointer<bool> is_remote,
  ) {
    return _wire_session_send_files(
      port_,
      id,
      act_id,
      path,
      to,
      file_num,
      include_hidden,
      is_remote,
    );
  }

  late final _wire_session_send_filesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32,
              ffi.Pointer<bool>,
              ffi.Pointer<bool>)>>('wire_session_send_files');
  late final _wire_session_send_files = _wire_session_send_filesPtr.asFunction<
      void Function(
          int,
          ffi.Pointer<wire_uint_8_list>,
          int,
          ffi.Pointer<wire_uint_8_list>,
          ffi.Pointer<wire_uint_8_list>,
          int,
          ffi.Pointer<bool>,
          ffi.Pointer<bool>)>();

  void wire_session_set_confirm_override_file(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int act_id,
    int file_num,
    ffi.Pointer<bool> need_override,
    ffi.Pointer<bool> remember,
    ffi.Pointer<bool> is_upload,
  ) {
    return _wire_session_set_confirm_override_file(
      port_,
      id,
      act_id,
      file_num,
      need_override,
      remember,
      is_upload,
    );
  }

  late final _wire_session_set_confirm_override_filePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32,
              ffi.Int32,
              ffi.Pointer<bool>,
              ffi.Pointer<bool>,
              ffi.Pointer<bool>)>>('wire_session_set_confirm_override_file');
  late final _wire_session_set_confirm_override_file =
      _wire_session_set_confirm_override_filePtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>, int, int,
              ffi.Pointer<bool>, ffi.Pointer<bool>, ffi.Pointer<bool>)>();

  void wire_session_remove_file(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int act_id,
    ffi.Pointer<wire_uint_8_list> path,
    int file_num,
    ffi.Pointer<bool> is_remote,
  ) {
    return _wire_session_remove_file(
      port_,
      id,
      act_id,
      path,
      file_num,
      is_remote,
    );
  }

  late final _wire_session_remove_filePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32,
              ffi.Pointer<bool>)>>('wire_session_remove_file');
  late final _wire_session_remove_file =
      _wire_session_remove_filePtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>, int,
              ffi.Pointer<wire_uint_8_list>, int, ffi.Pointer<bool>)>();

  void wire_session_read_dir_recursive(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int act_id,
    ffi.Pointer<wire_uint_8_list> path,
    ffi.Pointer<bool> is_remote,
    ffi.Pointer<bool> show_hidden,
  ) {
    return _wire_session_read_dir_recursive(
      port_,
      id,
      act_id,
      path,
      is_remote,
      show_hidden,
    );
  }

  late final _wire_session_read_dir_recursivePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<bool>,
              ffi.Pointer<bool>)>>('wire_session_read_dir_recursive');
  late final _wire_session_read_dir_recursive =
      _wire_session_read_dir_recursivePtr.asFunction<
          void Function(
              int,
              ffi.Pointer<wire_uint_8_list>,
              int,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<bool>,
              ffi.Pointer<bool>)>();

  void wire_session_remove_all_empty_dirs(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int act_id,
    ffi.Pointer<wire_uint_8_list> path,
    ffi.Pointer<bool> is_remote,
  ) {
    return _wire_session_remove_all_empty_dirs(
      port_,
      id,
      act_id,
      path,
      is_remote,
    );
  }

  late final _wire_session_remove_all_empty_dirsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<bool>)>>('wire_session_remove_all_empty_dirs');
  late final _wire_session_remove_all_empty_dirs =
      _wire_session_remove_all_empty_dirsPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>, int,
              ffi.Pointer<wire_uint_8_list>, ffi.Pointer<bool>)>();

  void wire_session_cancel_job(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int act_id,
  ) {
    return _wire_session_cancel_job(
      port_,
      id,
      act_id,
    );
  }

  late final _wire_session_cancel_jobPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Int32)>>('wire_session_cancel_job');
  late final _wire_session_cancel_job = _wire_session_cancel_jobPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>, int)>();

  void wire_session_create_dir(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int act_id,
    ffi.Pointer<wire_uint_8_list> path,
    ffi.Pointer<bool> is_remote,
  ) {
    return _wire_session_create_dir(
      port_,
      id,
      act_id,
      path,
      is_remote,
    );
  }

  late final _wire_session_create_dirPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<bool>)>>('wire_session_create_dir');
  late final _wire_session_create_dir = _wire_session_create_dirPtr.asFunction<
      void Function(int, ffi.Pointer<wire_uint_8_list>, int,
          ffi.Pointer<wire_uint_8_list>, ffi.Pointer<bool>)>();

  void wire_session_read_local_dir_sync(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> path,
    ffi.Pointer<bool> show_hidden,
  ) {
    return _wire_session_read_local_dir_sync(
      port_,
      id,
      path,
      show_hidden,
    );
  }

  late final _wire_session_read_local_dir_syncPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<bool>)>>('wire_session_read_local_dir_sync');
  late final _wire_session_read_local_dir_sync =
      _wire_session_read_local_dir_syncPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>, ffi.Pointer<bool>)>();

  void wire_session_get_platform(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<bool> is_remote,
  ) {
    return _wire_session_get_platform(
      port_,
      id,
      is_remote,
    );
  }

  late final _wire_session_get_platformPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<bool>)>>('wire_session_get_platform');
  late final _wire_session_get_platform =
      _wire_session_get_platformPtr.asFunction<
          void Function(
              int, ffi.Pointer<wire_uint_8_list>, ffi.Pointer<bool>)>();

  void wire_session_load_last_transfer_jobs(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_session_load_last_transfer_jobs(
      port_,
      id,
    );
  }

  late final _wire_session_load_last_transfer_jobsPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>)>>(
      'wire_session_load_last_transfer_jobs');
  late final _wire_session_load_last_transfer_jobs =
      _wire_session_load_last_transfer_jobsPtr
          .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_add_job(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int act_id,
    ffi.Pointer<wire_uint_8_list> path,
    ffi.Pointer<wire_uint_8_list> to,
    int file_num,
    ffi.Pointer<bool> include_hidden,
    ffi.Pointer<bool> is_remote,
  ) {
    return _wire_session_add_job(
      port_,
      id,
      act_id,
      path,
      to,
      file_num,
      include_hidden,
      is_remote,
    );
  }

  late final _wire_session_add_jobPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32,
              ffi.Pointer<bool>,
              ffi.Pointer<bool>)>>('wire_session_add_job');
  late final _wire_session_add_job = _wire_session_add_jobPtr.asFunction<
      void Function(
          int,
          ffi.Pointer<wire_uint_8_list>,
          int,
          ffi.Pointer<wire_uint_8_list>,
          ffi.Pointer<wire_uint_8_list>,
          int,
          ffi.Pointer<bool>,
          ffi.Pointer<bool>)>();

  void wire_session_resume_job(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int act_id,
    ffi.Pointer<bool> is_remote,
  ) {
    return _wire_session_resume_job(
      port_,
      id,
      act_id,
      is_remote,
    );
  }

  late final _wire_session_resume_jobPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>, ffi.Int32,
              ffi.Pointer<bool>)>>('wire_session_resume_job');
  late final _wire_session_resume_job = _wire_session_resume_jobPtr.asFunction<
      void Function(
          int, ffi.Pointer<wire_uint_8_list>, int, ffi.Pointer<bool>)>();

  void wire_main_get_sound_inputs(
    int port_,
  ) {
    return _wire_main_get_sound_inputs(
      port_,
    );
  }

  late final _wire_main_get_sound_inputsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_sound_inputs');
  late final _wire_main_get_sound_inputs =
      _wire_main_get_sound_inputsPtr.asFunction<void Function(int)>();

  void wire_main_change_id(
    int port_,
    ffi.Pointer<wire_uint_8_list> new_id,
  ) {
    return _wire_main_change_id(
      port_,
      new_id,
    );
  }

  late final _wire_main_change_idPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_change_id');
  late final _wire_main_change_id = _wire_main_change_idPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_get_async_status(
    int port_,
  ) {
    return _wire_main_get_async_status(
      port_,
    );
  }

  late final _wire_main_get_async_statusPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_async_status');
  late final _wire_main_get_async_status =
      _wire_main_get_async_statusPtr.asFunction<void Function(int)>();

  void wire_main_get_option(
    int port_,
    ffi.Pointer<wire_uint_8_list> key,
  ) {
    return _wire_main_get_option(
      port_,
      key,
    );
  }

  late final _wire_main_get_optionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_get_option');
  late final _wire_main_get_option = _wire_main_get_optionPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_set_option(
    int port_,
    ffi.Pointer<wire_uint_8_list> key,
    ffi.Pointer<wire_uint_8_list> value,
  ) {
    return _wire_main_set_option(
      port_,
      key,
      value,
    );
  }

  late final _wire_main_set_optionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_set_option');
  late final _wire_main_set_option = _wire_main_set_optionPtr.asFunction<
      void Function(
          int, ffi.Pointer<wire_uint_8_list>, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_get_options(
    int port_,
  ) {
    return _wire_main_get_options(
      port_,
    );
  }

  late final _wire_main_get_optionsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_options');
  late final _wire_main_get_options =
      _wire_main_get_optionsPtr.asFunction<void Function(int)>();

  void wire_main_set_options(
    int port_,
    ffi.Pointer<wire_uint_8_list> json,
  ) {
    return _wire_main_set_options(
      port_,
      json,
    );
  }

  late final _wire_main_set_optionsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_set_options');
  late final _wire_main_set_options = _wire_main_set_optionsPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_test_if_valid_server(
    int port_,
    ffi.Pointer<wire_uint_8_list> server,
  ) {
    return _wire_main_test_if_valid_server(
      port_,
      server,
    );
  }

  late final _wire_main_test_if_valid_serverPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>)>>(
      'wire_main_test_if_valid_server');
  late final _wire_main_test_if_valid_server =
      _wire_main_test_if_valid_serverPtr
          .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_set_socks(
    int port_,
    ffi.Pointer<wire_uint_8_list> proxy,
    ffi.Pointer<wire_uint_8_list> username,
    ffi.Pointer<wire_uint_8_list> password,
  ) {
    return _wire_main_set_socks(
      port_,
      proxy,
      username,
      password,
    );
  }

  late final _wire_main_set_socksPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_set_socks');
  late final _wire_main_set_socks = _wire_main_set_socksPtr.asFunction<
      void Function(int, ffi.Pointer<wire_uint_8_list>,
          ffi.Pointer<wire_uint_8_list>, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_get_socks(
    int port_,
  ) {
    return _wire_main_get_socks(
      port_,
    );
  }

  late final _wire_main_get_socksPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_socks');
  late final _wire_main_get_socks =
      _wire_main_get_socksPtr.asFunction<void Function(int)>();

  void wire_main_get_app_name(
    int port_,
  ) {
    return _wire_main_get_app_name(
      port_,
    );
  }

  late final _wire_main_get_app_namePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_app_name');
  late final _wire_main_get_app_name =
      _wire_main_get_app_namePtr.asFunction<void Function(int)>();

  void wire_main_get_license(
    int port_,
  ) {
    return _wire_main_get_license(
      port_,
    );
  }

  late final _wire_main_get_licensePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_license');
  late final _wire_main_get_license =
      _wire_main_get_licensePtr.asFunction<void Function(int)>();

  void wire_main_get_version(
    int port_,
  ) {
    return _wire_main_get_version(
      port_,
    );
  }

  late final _wire_main_get_versionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_version');
  late final _wire_main_get_version =
      _wire_main_get_versionPtr.asFunction<void Function(int)>();

  void wire_main_get_fav(
    int port_,
  ) {
    return _wire_main_get_fav(
      port_,
    );
  }

  late final _wire_main_get_favPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_fav');
  late final _wire_main_get_fav =
      _wire_main_get_favPtr.asFunction<void Function(int)>();

  void wire_main_store_fav(
    int port_,
    ffi.Pointer<wire_StringList> favs,
  ) {
    return _wire_main_store_fav(
      port_,
      favs,
    );
  }

  late final _wire_main_store_favPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, ffi.Pointer<wire_StringList>)>>('wire_main_store_fav');
  late final _wire_main_store_fav = _wire_main_store_favPtr
      .asFunction<void Function(int, ffi.Pointer<wire_StringList>)>();

  void wire_main_get_peer(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_main_get_peer(
      port_,
      id,
    );
  }

  late final _wire_main_get_peerPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, ffi.Pointer<wire_uint_8_list>)>>('wire_main_get_peer');
  late final _wire_main_get_peer = _wire_main_get_peerPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_get_lan_peers(
    int port_,
  ) {
    return _wire_main_get_lan_peers(
      port_,
    );
  }

  late final _wire_main_get_lan_peersPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_lan_peers');
  late final _wire_main_get_lan_peers =
      _wire_main_get_lan_peersPtr.asFunction<void Function(int)>();

  void wire_main_get_connect_status(
    int port_,
  ) {
    return _wire_main_get_connect_status(
      port_,
    );
  }

  late final _wire_main_get_connect_statusPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_connect_status');
  late final _wire_main_get_connect_status =
      _wire_main_get_connect_statusPtr.asFunction<void Function(int)>();

  void wire_main_check_connect_status(
    int port_,
  ) {
    return _wire_main_check_connect_status(
      port_,
    );
  }

  late final _wire_main_check_connect_statusPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_check_connect_status');
  late final _wire_main_check_connect_status =
      _wire_main_check_connect_statusPtr.asFunction<void Function(int)>();

  void wire_main_is_using_public_server(
    int port_,
  ) {
    return _wire_main_is_using_public_server(
      port_,
    );
  }

  late final _wire_main_is_using_public_serverPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_is_using_public_server');
  late final _wire_main_is_using_public_server =
      _wire_main_is_using_public_serverPtr.asFunction<void Function(int)>();

  void wire_main_discover(
    int port_,
  ) {
    return _wire_main_discover(
      port_,
    );
  }

  late final _wire_main_discoverPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_discover');
  late final _wire_main_discover =
      _wire_main_discoverPtr.asFunction<void Function(int)>();

  void wire_main_has_rendezvous_service(
    int port_,
  ) {
    return _wire_main_has_rendezvous_service(
      port_,
    );
  }

  late final _wire_main_has_rendezvous_servicePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_has_rendezvous_service');
  late final _wire_main_has_rendezvous_service =
      _wire_main_has_rendezvous_servicePtr.asFunction<void Function(int)>();

  void wire_main_get_api_server(
    int port_,
  ) {
    return _wire_main_get_api_server(
      port_,
    );
  }

  late final _wire_main_get_api_serverPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_api_server');
  late final _wire_main_get_api_server =
      _wire_main_get_api_serverPtr.asFunction<void Function(int)>();

  void wire_main_post_request(
    int port_,
    ffi.Pointer<wire_uint_8_list> url,
    ffi.Pointer<wire_uint_8_list> body,
    ffi.Pointer<wire_uint_8_list> header,
  ) {
    return _wire_main_post_request(
      port_,
      url,
      body,
      header,
    );
  }

  late final _wire_main_post_requestPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_post_request');
  late final _wire_main_post_request = _wire_main_post_requestPtr.asFunction<
      void Function(int, ffi.Pointer<wire_uint_8_list>,
          ffi.Pointer<wire_uint_8_list>, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_get_local_option(
    int port_,
    ffi.Pointer<wire_uint_8_list> key,
  ) {
    return _wire_main_get_local_option(
      port_,
      key,
    );
  }

  late final _wire_main_get_local_optionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_get_local_option');
  late final _wire_main_get_local_option = _wire_main_get_local_optionPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_set_local_option(
    int port_,
    ffi.Pointer<wire_uint_8_list> key,
    ffi.Pointer<wire_uint_8_list> value,
  ) {
    return _wire_main_set_local_option(
      port_,
      key,
      value,
    );
  }

  late final _wire_main_set_local_optionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_set_local_option');
  late final _wire_main_set_local_option =
      _wire_main_set_local_optionPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_get_my_id(
    int port_,
  ) {
    return _wire_main_get_my_id(
      port_,
    );
  }

  late final _wire_main_get_my_idPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_my_id');
  late final _wire_main_get_my_id =
      _wire_main_get_my_idPtr.asFunction<void Function(int)>();

  void wire_main_get_uuid(
    int port_,
  ) {
    return _wire_main_get_uuid(
      port_,
    );
  }

  late final _wire_main_get_uuidPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_uuid');
  late final _wire_main_get_uuid =
      _wire_main_get_uuidPtr.asFunction<void Function(int)>();

  void wire_main_get_peer_option(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> key,
  ) {
    return _wire_main_get_peer_option(
      port_,
      id,
      key,
    );
  }

  late final _wire_main_get_peer_optionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_get_peer_option');
  late final _wire_main_get_peer_option =
      _wire_main_get_peer_optionPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_set_peer_option(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> key,
    ffi.Pointer<wire_uint_8_list> value,
  ) {
    return _wire_main_set_peer_option(
      port_,
      id,
      key,
      value,
    );
  }

  late final _wire_main_set_peer_optionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_set_peer_option');
  late final _wire_main_set_peer_option =
      _wire_main_set_peer_optionPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_forget_password(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_main_forget_password(
      port_,
      id,
    );
  }

  late final _wire_main_forget_passwordPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_forget_password');
  late final _wire_main_forget_password = _wire_main_forget_passwordPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_get_recent_peers(
    int port_,
  ) {
    return _wire_main_get_recent_peers(
      port_,
    );
  }

  late final _wire_main_get_recent_peersPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_recent_peers');
  late final _wire_main_get_recent_peers =
      _wire_main_get_recent_peersPtr.asFunction<void Function(int)>();

  void wire_main_load_recent_peers(
    int port_,
  ) {
    return _wire_main_load_recent_peers(
      port_,
    );
  }

  late final _wire_main_load_recent_peersPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_load_recent_peers');
  late final _wire_main_load_recent_peers =
      _wire_main_load_recent_peersPtr.asFunction<void Function(int)>();

  void wire_main_load_fav_peers(
    int port_,
  ) {
    return _wire_main_load_fav_peers(
      port_,
    );
  }

  late final _wire_main_load_fav_peersPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_load_fav_peers');
  late final _wire_main_load_fav_peers =
      _wire_main_load_fav_peersPtr.asFunction<void Function(int)>();

  void wire_main_load_lan_peers(
    int port_,
  ) {
    return _wire_main_load_lan_peers(
      port_,
    );
  }

  late final _wire_main_load_lan_peersPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_load_lan_peers');
  late final _wire_main_load_lan_peers =
      _wire_main_load_lan_peersPtr.asFunction<void Function(int)>();

  void wire_session_add_port_forward(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int local_port,
    ffi.Pointer<wire_uint_8_list> remote_host,
    int remote_port,
  ) {
    return _wire_session_add_port_forward(
      port_,
      id,
      local_port,
      remote_host,
      remote_port,
    );
  }

  late final _wire_session_add_port_forwardPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32,
              ffi.Pointer<wire_uint_8_list>,
              ffi.Int32)>>('wire_session_add_port_forward');
  late final _wire_session_add_port_forward =
      _wire_session_add_port_forwardPtr.asFunction<
          void Function(int, ffi.Pointer<wire_uint_8_list>, int,
              ffi.Pointer<wire_uint_8_list>, int)>();

  void wire_session_remove_port_forward(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    int local_port,
  ) {
    return _wire_session_remove_port_forward(
      port_,
      id,
      local_port,
    );
  }

  late final _wire_session_remove_port_forwardPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Int32)>>('wire_session_remove_port_forward');
  late final _wire_session_remove_port_forward =
      _wire_session_remove_port_forwardPtr
          .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>, int)>();

  void wire_main_get_last_remote_id(
    int port_,
  ) {
    return _wire_main_get_last_remote_id(
      port_,
    );
  }

  late final _wire_main_get_last_remote_idPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_last_remote_id');
  late final _wire_main_get_last_remote_id =
      _wire_main_get_last_remote_idPtr.asFunction<void Function(int)>();

  void wire_main_get_software_update_url(
    int port_,
  ) {
    return _wire_main_get_software_update_url(
      port_,
    );
  }

  late final _wire_main_get_software_update_urlPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_software_update_url');
  late final _wire_main_get_software_update_url =
      _wire_main_get_software_update_urlPtr.asFunction<void Function(int)>();

  void wire_main_get_home_dir(
    int port_,
  ) {
    return _wire_main_get_home_dir(
      port_,
    );
  }

  late final _wire_main_get_home_dirPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_home_dir');
  late final _wire_main_get_home_dir =
      _wire_main_get_home_dirPtr.asFunction<void Function(int)>();

  void wire_main_get_langs(
    int port_,
  ) {
    return _wire_main_get_langs(
      port_,
    );
  }

  late final _wire_main_get_langsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_langs');
  late final _wire_main_get_langs =
      _wire_main_get_langsPtr.asFunction<void Function(int)>();

  void wire_main_get_temporary_password(
    int port_,
  ) {
    return _wire_main_get_temporary_password(
      port_,
    );
  }

  late final _wire_main_get_temporary_passwordPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_temporary_password');
  late final _wire_main_get_temporary_password =
      _wire_main_get_temporary_passwordPtr.asFunction<void Function(int)>();

  void wire_main_get_permanent_password(
    int port_,
  ) {
    return _wire_main_get_permanent_password(
      port_,
    );
  }

  late final _wire_main_get_permanent_passwordPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_permanent_password');
  late final _wire_main_get_permanent_password =
      _wire_main_get_permanent_passwordPtr.asFunction<void Function(int)>();

  void wire_main_get_online_statue(
    int port_,
  ) {
    return _wire_main_get_online_statue(
      port_,
    );
  }

  late final _wire_main_get_online_statuePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_online_statue');
  late final _wire_main_get_online_statue =
      _wire_main_get_online_statuePtr.asFunction<void Function(int)>();

  void wire_main_get_clients_state(
    int port_,
  ) {
    return _wire_main_get_clients_state(
      port_,
    );
  }

  late final _wire_main_get_clients_statePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_clients_state');
  late final _wire_main_get_clients_state =
      _wire_main_get_clients_statePtr.asFunction<void Function(int)>();

  void wire_main_check_clients_length(
    int port_,
    int length,
  ) {
    return _wire_main_check_clients_length(
      port_,
      length,
    );
  }

  late final _wire_main_check_clients_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, uintptr_t)>>(
          'wire_main_check_clients_length');
  late final _wire_main_check_clients_length =
      _wire_main_check_clients_lengthPtr.asFunction<void Function(int, int)>();

  void wire_main_init(
    int port_,
    ffi.Pointer<wire_uint_8_list> app_dir,
  ) {
    return _wire_main_init(
      port_,
      app_dir,
    );
  }

  late final _wire_main_initPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, ffi.Pointer<wire_uint_8_list>)>>('wire_main_init');
  late final _wire_main_init = _wire_main_initPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_device_id(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_main_device_id(
      port_,
      id,
    );
  }

  late final _wire_main_device_idPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_device_id');
  late final _wire_main_device_id = _wire_main_device_idPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_device_name(
    int port_,
    ffi.Pointer<wire_uint_8_list> name,
  ) {
    return _wire_main_device_name(
      port_,
      name,
    );
  }

  late final _wire_main_device_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_device_name');
  late final _wire_main_device_name = _wire_main_device_namePtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_remove_peer(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_main_remove_peer(
      port_,
      id,
    );
  }

  late final _wire_main_remove_peerPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_remove_peer');
  late final _wire_main_remove_peer = _wire_main_remove_peerPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_has_hwcodec(
    int port_,
  ) {
    return _wire_main_has_hwcodec(
      port_,
    );
  }

  late final _wire_main_has_hwcodecPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_has_hwcodec');
  late final _wire_main_has_hwcodec =
      _wire_main_has_hwcodecPtr.asFunction<void Function(int)>();

  void wire_session_send_mouse(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
    ffi.Pointer<wire_uint_8_list> msg,
  ) {
    return _wire_session_send_mouse(
      port_,
      id,
      msg,
    );
  }

  late final _wire_session_send_mousePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_uint_8_list>)>>('wire_session_send_mouse');
  late final _wire_session_send_mouse = _wire_session_send_mousePtr.asFunction<
      void Function(
          int, ffi.Pointer<wire_uint_8_list>, ffi.Pointer<wire_uint_8_list>)>();

  void wire_session_restart_remote_device(
    int port_,
    ffi.Pointer<wire_uint_8_list> id,
  ) {
    return _wire_session_restart_remote_device(
      port_,
      id,
    );
  }

  late final _wire_session_restart_remote_devicePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>)>>(
      'wire_session_restart_remote_device');
  late final _wire_session_restart_remote_device =
      _wire_session_restart_remote_devicePtr
          .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_set_home_dir(
    int port_,
    ffi.Pointer<wire_uint_8_list> home,
  ) {
    return _wire_main_set_home_dir(
      port_,
      home,
    );
  }

  late final _wire_main_set_home_dirPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_main_set_home_dir');
  late final _wire_main_set_home_dir = _wire_main_set_home_dirPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_stop_service(
    int port_,
  ) {
    return _wire_main_stop_service(
      port_,
    );
  }

  late final _wire_main_stop_servicePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_stop_service');
  late final _wire_main_stop_service =
      _wire_main_stop_servicePtr.asFunction<void Function(int)>();

  void wire_main_start_service(
    int port_,
  ) {
    return _wire_main_start_service(
      port_,
    );
  }

  late final _wire_main_start_servicePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_start_service');
  late final _wire_main_start_service =
      _wire_main_start_servicePtr.asFunction<void Function(int)>();

  void wire_main_update_temporary_password(
    int port_,
  ) {
    return _wire_main_update_temporary_password(
      port_,
    );
  }

  late final _wire_main_update_temporary_passwordPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_update_temporary_password');
  late final _wire_main_update_temporary_password =
      _wire_main_update_temporary_passwordPtr.asFunction<void Function(int)>();

  void wire_main_set_permanent_password(
    int port_,
    ffi.Pointer<wire_uint_8_list> password,
  ) {
    return _wire_main_set_permanent_password(
      port_,
      password,
    );
  }

  late final _wire_main_set_permanent_passwordPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>)>>(
      'wire_main_set_permanent_password');
  late final _wire_main_set_permanent_password =
      _wire_main_set_permanent_passwordPtr
          .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_main_check_super_user_permission(
    int port_,
  ) {
    return _wire_main_check_super_user_permission(
      port_,
    );
  }

  late final _wire_main_check_super_user_permissionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_check_super_user_permission');
  late final _wire_main_check_super_user_permission =
      _wire_main_check_super_user_permissionPtr
          .asFunction<void Function(int)>();

  void wire_main_check_mouse_time(
    int port_,
  ) {
    return _wire_main_check_mouse_time(
      port_,
    );
  }

  late final _wire_main_check_mouse_timePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_check_mouse_time');
  late final _wire_main_check_mouse_time =
      _wire_main_check_mouse_timePtr.asFunction<void Function(int)>();

  void wire_main_get_mouse_time(
    int port_,
  ) {
    return _wire_main_get_mouse_time(
      port_,
    );
  }

  late final _wire_main_get_mouse_timePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_mouse_time');
  late final _wire_main_get_mouse_time =
      _wire_main_get_mouse_timePtr.asFunction<void Function(int)>();

  void wire_cm_send_chat(
    int port_,
    int conn_id,
    ffi.Pointer<wire_uint_8_list> msg,
  ) {
    return _wire_cm_send_chat(
      port_,
      conn_id,
      msg,
    );
  }

  late final _wire_cm_send_chatPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Int32,
              ffi.Pointer<wire_uint_8_list>)>>('wire_cm_send_chat');
  late final _wire_cm_send_chat = _wire_cm_send_chatPtr
      .asFunction<void Function(int, int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_cm_login_res(
    int port_,
    int conn_id,
    ffi.Pointer<bool> res,
  ) {
    return _wire_cm_login_res(
      port_,
      conn_id,
      res,
    );
  }

  late final _wire_cm_login_resPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, ffi.Int32, ffi.Pointer<bool>)>>('wire_cm_login_res');
  late final _wire_cm_login_res = _wire_cm_login_resPtr
      .asFunction<void Function(int, int, ffi.Pointer<bool>)>();

  void wire_cm_close_connection(
    int port_,
    int conn_id,
  ) {
    return _wire_cm_close_connection(
      port_,
      conn_id,
    );
  }

  late final _wire_cm_close_connectionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.Int32)>>(
          'wire_cm_close_connection');
  late final _wire_cm_close_connection =
      _wire_cm_close_connectionPtr.asFunction<void Function(int, int)>();

  void wire_cm_check_click_time(
    int port_,
    int conn_id,
  ) {
    return _wire_cm_check_click_time(
      port_,
      conn_id,
    );
  }

  late final _wire_cm_check_click_timePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.Int32)>>(
          'wire_cm_check_click_time');
  late final _wire_cm_check_click_time =
      _wire_cm_check_click_timePtr.asFunction<void Function(int, int)>();

  void wire_cm_get_click_time(
    int port_,
  ) {
    return _wire_cm_get_click_time(
      port_,
    );
  }

  late final _wire_cm_get_click_timePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_cm_get_click_time');
  late final _wire_cm_get_click_time =
      _wire_cm_get_click_timePtr.asFunction<void Function(int)>();

  void wire_cm_switch_permission(
    int port_,
    int conn_id,
    ffi.Pointer<wire_uint_8_list> name,
    ffi.Pointer<bool> enabled,
  ) {
    return _wire_cm_switch_permission(
      port_,
      conn_id,
      name,
      enabled,
    );
  }

  late final _wire_cm_switch_permissionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Int32, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<bool>)>>('wire_cm_switch_permission');
  late final _wire_cm_switch_permission =
      _wire_cm_switch_permissionPtr.asFunction<
          void Function(
              int, int, ffi.Pointer<wire_uint_8_list>, ffi.Pointer<bool>)>();

  void wire_main_get_icon(
    int port_,
  ) {
    return _wire_main_get_icon(
      port_,
    );
  }

  late final _wire_main_get_iconPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64)>>(
          'wire_main_get_icon');
  late final _wire_main_get_icon =
      _wire_main_get_iconPtr.asFunction<void Function(int)>();

  void wire_query_onlines(
    int port_,
    ffi.Pointer<wire_StringList> ids,
  ) {
    return _wire_query_onlines(
      port_,
      ids,
    );
  }

  late final _wire_query_onlinesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64, ffi.Pointer<wire_StringList>)>>('wire_query_onlines');
  late final _wire_query_onlines = _wire_query_onlinesPtr
      .asFunction<void Function(int, ffi.Pointer<wire_StringList>)>();

  ffi.Pointer<wire_StringList> new_StringList(
    int len,
  ) {
    return _new_StringList(
      len,
    );
  }

  late final _new_StringListPtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<wire_StringList> Function(ffi.Int32)>>(
      'new_StringList');
  late final _new_StringList = _new_StringListPtr
      .asFunction<ffi.Pointer<wire_StringList> Function(int)>();

  ffi.Pointer<wire_uint_8_list> new_uint_8_list(
    int len,
  ) {
    return _new_uint_8_list(
      len,
    );
  }

  late final _new_uint_8_listPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<wire_uint_8_list> Function(
              ffi.Int32)>>('new_uint_8_list');
  late final _new_uint_8_list = _new_uint_8_listPtr
      .asFunction<ffi.Pointer<wire_uint_8_list> Function(int)>();

  void free_WireSyncReturnStruct(
    WireSyncReturnStruct val,
  ) {
    return _free_WireSyncReturnStruct(
      val,
    );
  }

  late final _free_WireSyncReturnStructPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(WireSyncReturnStruct)>>(
          'free_WireSyncReturnStruct');
  late final _free_WireSyncReturnStruct = _free_WireSyncReturnStructPtr
      .asFunction<void Function(WireSyncReturnStruct)>();

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

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

  int rustdesk_core_main() {
    return _rustdesk_core_main();
  }

  late final _rustdesk_core_mainPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function()>>('rustdesk_core_main');
  late final _rustdesk_core_main =
      _rustdesk_core_mainPtr.asFunction<int Function()>();
}

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

  @ffi.Int32()
  external int len;
}

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

  @ffi.Int32()
  external int len;
}

typedef bool = ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Int>)>;
typedef uintptr_t = ffi.UnsignedLong;

const int GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT = 2;

const int GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS = 4;