// This file is automatically generated, so please do not edit it.
// @generated by `flutter_rust_bridge`@ 2.13.0.

// ignore_for_file: unused_import, unused_element, unnecessary_import, duplicate_ignore, invalid_use_of_internal_member, annotate_overrides, non_constant_identifier_names, curly_braces_in_flow_control_structures, prefer_const_literals_to_create_immutables, unused_field

import 'api.dart';
import 'dart:async';
import 'dart:convert';
import 'frb_generated.dart';
import 'frb_generated.io.dart'
    if (dart.library.js_interop) 'frb_generated.web.dart';
import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart';

/// Main entrypoint of the Rust API
class RustLib extends BaseEntrypoint<RustLibApi, RustLibApiImpl, RustLibWire> {
  @internal
  static final instance = RustLib._();

  RustLib._();

  /// Initialize flutter_rust_bridge
  static Future<void> init({
    RustLibApi? api,
    BaseHandler? handler,
    ExternalLibrary? externalLibrary,
    bool forceSameCodegenVersion = true,
  }) async {
    await instance.initImpl(
      api: api,
      handler: handler,
      externalLibrary: externalLibrary,
      forceSameCodegenVersion: forceSameCodegenVersion,
    );
  }

  /// Initialize flutter_rust_bridge in mock mode.
  /// No libraries for FFI are loaded.
  static void initMock({
    required RustLibApi api,
  }) {
    instance.initMockImpl(
      api: api,
    );
  }

  /// Dispose flutter_rust_bridge
  ///
  /// The call to this function is optional, since flutter_rust_bridge (and everything else)
  /// is automatically disposed when the app stops.
  static void dispose() => instance.disposeImpl();

  @override
  ApiImplConstructor<RustLibApiImpl, RustLibWire> get apiImplConstructor =>
      RustLibApiImpl.new;

  @override
  WireConstructor<RustLibWire> get wireConstructor =>
      RustLibWire.fromExternalLibrary;

  @override
  Future<void> executeRustInitializers() async {}

  @override
  ExternalLibraryLoaderConfig get defaultExternalLibraryLoaderConfig =>
      kDefaultExternalLibraryLoaderConfig;

  @override
  String get codegenVersion => '2.13.0';

  @override
  int get rustContentHash => 389194750;

  static const kDefaultExternalLibraryLoaderConfig =
      ExternalLibraryLoaderConfig(
    stem: 'netdesk_frb',
    ioDirectory: '../frb/target/release/',
    webPrefix: 'pkg/',
    wasmBindgenName: 'wasm_bindgen',
  );
}

abstract class RustLibApi extends BaseApi {
  Future<BigInt> crateApiConnect(
      {required String wsUrl,
      required String hostId,
      required String password,
      required String totp});

  void crateApiCtrlAltDel({required BigInt handle});

  void crateApiDisconnect({required BigInt handle});

  Stream<NdHostEvent> crateApiHostEvents({required BigInt handle});

  String crateApiHostGenId();

  String crateApiHostGenPassword();

  void crateApiHostPushFrame(
      {required BigInt handle,
      required List<int> data,
      required bool keyframe});

  Future<BigInt> crateApiHostStart(
      {required String wsUrl,
      required String hostId,
      required String name,
      required String password,
      required int width,
      required int height});

  void crateApiHostStop({required BigInt handle});

  void crateApiMonitorSwitch({required BigInt handle, required int i});

  void crateApiSendChat({required BigInt handle, required String text});

  void crateApiSendKey(
      {required BigInt handle, required String code, required bool down});

  void crateApiSendMouse(
      {required BigInt handle,
      required int x,
      required int y,
      required int buttons,
      required double wheel,
      required double hwheel});

  int crateApiSessionCurrentMonitor({required BigInt handle});

  Stream<NdEvent> crateApiSessionEvents({required BigInt handle});

  List<NdMonitor> crateApiSessionMonitors({required BigInt handle});

  void crateApiSetClipboard({required BigInt handle, required String text});

  void crateApiSetQuality(
      {required BigInt handle,
      required int fps,
      required int bitrate,
      required double scale});
}

class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
  RustLibApiImpl({
    required super.handler,
    required super.wire,
    required super.generalizedFrbRustBinding,
    required super.portManager,
  });

  @override
  Future<BigInt> crateApiConnect(
      {required String wsUrl,
      required String hostId,
      required String password,
      required String totp}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_String(wsUrl, serializer);
        sse_encode_String(hostId, serializer);
        sse_encode_String(password, serializer);
        sse_encode_String(totp, serializer);
        pdeCallFfi(generalizedFrbRustBinding, serializer,
            funcId: 1, port: port_);
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_u_64,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiConnectConstMeta,
      argValues: [wsUrl, hostId, password, totp],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiConnectConstMeta => const TaskConstMeta(
        debugName: "connect",
        argNames: ["wsUrl", "hostId", "password", "totp"],
      );

  @override
  void crateApiCtrlAltDel({required BigInt handle}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 2)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiCtrlAltDelConstMeta,
      argValues: [handle],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiCtrlAltDelConstMeta => const TaskConstMeta(
        debugName: "ctrl_alt_del",
        argNames: ["handle"],
      );

  @override
  void crateApiDisconnect({required BigInt handle}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 3)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiDisconnectConstMeta,
      argValues: [handle],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiDisconnectConstMeta => const TaskConstMeta(
        debugName: "disconnect",
        argNames: ["handle"],
      );

  @override
  Stream<NdHostEvent> crateApiHostEvents({required BigInt handle}) {
    final sink = RustStreamSink<NdHostEvent>();
    unawaited(handler.executeNormal(NormalTask(
      callFfi: (port_) {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        sse_encode_StreamSink_nd_host_event_Sse(sink, serializer);
        pdeCallFfi(generalizedFrbRustBinding, serializer,
            funcId: 4, port: port_);
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiHostEventsConstMeta,
      argValues: [handle, sink],
      apiImpl: this,
    )));
    return sink.stream;
  }

  TaskConstMeta get kCrateApiHostEventsConstMeta => const TaskConstMeta(
        debugName: "host_events",
        argNames: ["handle", "sink"],
      );

  @override
  String crateApiHostGenId() {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 5)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiHostGenIdConstMeta,
      argValues: [],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiHostGenIdConstMeta => const TaskConstMeta(
        debugName: "host_gen_id",
        argNames: [],
      );

  @override
  String crateApiHostGenPassword() {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 6)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiHostGenPasswordConstMeta,
      argValues: [],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiHostGenPasswordConstMeta => const TaskConstMeta(
        debugName: "host_gen_password",
        argNames: [],
      );

  @override
  void crateApiHostPushFrame(
      {required BigInt handle,
      required List<int> data,
      required bool keyframe}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        sse_encode_list_prim_u_8_loose(data, serializer);
        sse_encode_bool(keyframe, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 7)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiHostPushFrameConstMeta,
      argValues: [handle, data, keyframe],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiHostPushFrameConstMeta => const TaskConstMeta(
        debugName: "host_push_frame",
        argNames: ["handle", "data", "keyframe"],
      );

  @override
  Future<BigInt> crateApiHostStart(
      {required String wsUrl,
      required String hostId,
      required String name,
      required String password,
      required int width,
      required int height}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_String(wsUrl, serializer);
        sse_encode_String(hostId, serializer);
        sse_encode_String(name, serializer);
        sse_encode_String(password, serializer);
        sse_encode_u_32(width, serializer);
        sse_encode_u_32(height, serializer);
        pdeCallFfi(generalizedFrbRustBinding, serializer,
            funcId: 8, port: port_);
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_u_64,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiHostStartConstMeta,
      argValues: [wsUrl, hostId, name, password, width, height],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiHostStartConstMeta => const TaskConstMeta(
        debugName: "host_start",
        argNames: ["wsUrl", "hostId", "name", "password", "width", "height"],
      );

  @override
  void crateApiHostStop({required BigInt handle}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 9)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiHostStopConstMeta,
      argValues: [handle],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiHostStopConstMeta => const TaskConstMeta(
        debugName: "host_stop",
        argNames: ["handle"],
      );

  @override
  void crateApiMonitorSwitch({required BigInt handle, required int i}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        sse_encode_i_32(i, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 10)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiMonitorSwitchConstMeta,
      argValues: [handle, i],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiMonitorSwitchConstMeta => const TaskConstMeta(
        debugName: "monitor_switch",
        argNames: ["handle", "i"],
      );

  @override
  void crateApiSendChat({required BigInt handle, required String text}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        sse_encode_String(text, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 11)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSendChatConstMeta,
      argValues: [handle, text],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendChatConstMeta => const TaskConstMeta(
        debugName: "send_chat",
        argNames: ["handle", "text"],
      );

  @override
  void crateApiSendKey(
      {required BigInt handle, required String code, required bool down}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        sse_encode_String(code, serializer);
        sse_encode_bool(down, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 12)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSendKeyConstMeta,
      argValues: [handle, code, down],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendKeyConstMeta => const TaskConstMeta(
        debugName: "send_key",
        argNames: ["handle", "code", "down"],
      );

  @override
  void crateApiSendMouse(
      {required BigInt handle,
      required int x,
      required int y,
      required int buttons,
      required double wheel,
      required double hwheel}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        sse_encode_i_32(x, serializer);
        sse_encode_i_32(y, serializer);
        sse_encode_u_32(buttons, serializer);
        sse_encode_f_32(wheel, serializer);
        sse_encode_f_32(hwheel, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 13)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSendMouseConstMeta,
      argValues: [handle, x, y, buttons, wheel, hwheel],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendMouseConstMeta => const TaskConstMeta(
        debugName: "send_mouse",
        argNames: ["handle", "x", "y", "buttons", "wheel", "hwheel"],
      );

  @override
  int crateApiSessionCurrentMonitor({required BigInt handle}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 14)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_i_32,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSessionCurrentMonitorConstMeta,
      argValues: [handle],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSessionCurrentMonitorConstMeta =>
      const TaskConstMeta(
        debugName: "session_current_monitor",
        argNames: ["handle"],
      );

  @override
  Stream<NdEvent> crateApiSessionEvents({required BigInt handle}) {
    final sink = RustStreamSink<NdEvent>();
    unawaited(handler.executeNormal(NormalTask(
      callFfi: (port_) {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        sse_encode_StreamSink_nd_event_Sse(sink, serializer);
        pdeCallFfi(generalizedFrbRustBinding, serializer,
            funcId: 15, port: port_);
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSessionEventsConstMeta,
      argValues: [handle, sink],
      apiImpl: this,
    )));
    return sink.stream;
  }

  TaskConstMeta get kCrateApiSessionEventsConstMeta => const TaskConstMeta(
        debugName: "session_events",
        argNames: ["handle", "sink"],
      );

  @override
  List<NdMonitor> crateApiSessionMonitors({required BigInt handle}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 16)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_list_nd_monitor,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSessionMonitorsConstMeta,
      argValues: [handle],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSessionMonitorsConstMeta => const TaskConstMeta(
        debugName: "session_monitors",
        argNames: ["handle"],
      );

  @override
  void crateApiSetClipboard({required BigInt handle, required String text}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        sse_encode_String(text, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 17)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSetClipboardConstMeta,
      argValues: [handle, text],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSetClipboardConstMeta => const TaskConstMeta(
        debugName: "set_clipboard",
        argNames: ["handle", "text"],
      );

  @override
  void crateApiSetQuality(
      {required BigInt handle,
      required int fps,
      required int bitrate,
      required double scale}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_u_64(handle, serializer);
        sse_encode_u_32(fps, serializer);
        sse_encode_u_32(bitrate, serializer);
        sse_encode_f_32(scale, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 18)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiSetQualityConstMeta,
      argValues: [handle, fps, bitrate, scale],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSetQualityConstMeta => const TaskConstMeta(
        debugName: "set_quality",
        argNames: ["handle", "fps", "bitrate", "scale"],
      );

  @protected
  AnyhowException dco_decode_AnyhowException(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return AnyhowException(raw as String);
  }

  @protected
  RustStreamSink<NdEvent> dco_decode_StreamSink_nd_event_Sse(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    throw UnimplementedError();
  }

  @protected
  RustStreamSink<NdHostEvent> dco_decode_StreamSink_nd_host_event_Sse(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    throw UnimplementedError();
  }

  @protected
  String dco_decode_String(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as String;
  }

  @protected
  bool dco_decode_bool(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as bool;
  }

  @protected
  double dco_decode_f_32(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as double;
  }

  @protected
  int dco_decode_i_32(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as int;
  }

  @protected
  List<NdMonitor> dco_decode_list_nd_monitor(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return (raw as List<dynamic>).map(dco_decode_nd_monitor).toList();
  }

  @protected
  List<int> dco_decode_list_prim_u_8_loose(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as List<int>;
  }

  @protected
  Uint8List dco_decode_list_prim_u_8_strict(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as Uint8List;
  }

  @protected
  NdEvent dco_decode_nd_event(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    switch (raw[0]) {
      case 0:
        return const NdEvent_Connecting();
      case 1:
        return NdEvent_Connected(
          w: dco_decode_u_32(raw[1]),
          h: dco_decode_u_32(raw[2]),
          e2E: dco_decode_bool(raw[3]),
          hostName: dco_decode_String(raw[4]),
        );
      case 2:
        return NdEvent_Frame(
          width: dco_decode_u_32(raw[1]),
          height: dco_decode_u_32(raw[2]),
          rgba: dco_decode_list_prim_u_8_strict(raw[3]),
        );
      case 3:
        return NdEvent_Ended(
          reason: dco_decode_String(raw[1]),
        );
      case 4:
        return NdEvent_Denied(
          reason: dco_decode_String(raw[1]),
        );
      case 5:
        return NdEvent_ChatMessage(
          from: dco_decode_String(raw[1]),
          text: dco_decode_String(raw[2]),
        );
      case 6:
        return NdEvent_Clipboard(
          text: dco_decode_String(raw[1]),
        );
      default:
        throw Exception("unreachable");
    }
  }

  @protected
  NdHostEvent dco_decode_nd_host_event(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    switch (raw[0]) {
      case 0:
        return const NdHostEvent_Registered();
      case 1:
        return NdHostEvent_ViewerConnected(
          e2E: dco_decode_bool(raw[1]),
        );
      case 2:
        return const NdHostEvent_ViewerLeft();
      case 3:
        return NdHostEvent_Mouse(
          x: dco_decode_i_32(raw[1]),
          y: dco_decode_i_32(raw[2]),
          buttons: dco_decode_u_32(raw[3]),
          wheel: dco_decode_f_32(raw[4]),
        );
      case 4:
        return NdHostEvent_Key(
          code: dco_decode_String(raw[1]),
          down: dco_decode_bool(raw[2]),
        );
      case 5:
        return const NdHostEvent_KeyframeRequested();
      case 6:
        return NdHostEvent_Quality(
          fps: dco_decode_u_32(raw[1]),
          bitrate: dco_decode_u_32(raw[2]),
          scale: dco_decode_f_32(raw[3]),
        );
      case 7:
        return const NdHostEvent_Reconnecting();
      case 8:
        return NdHostEvent_Ended(
          reason: dco_decode_String(raw[1]),
        );
      default:
        throw Exception("unreachable");
    }
  }

  @protected
  NdMonitor dco_decode_nd_monitor(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 3)
      throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
    return NdMonitor(
      i: dco_decode_i_32(arr[0]),
      w: dco_decode_u_32(arr[1]),
      h: dco_decode_u_32(arr[2]),
    );
  }

  @protected
  int dco_decode_u_32(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as int;
  }

  @protected
  BigInt dco_decode_u_64(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dcoDecodeU64(raw);
  }

  @protected
  int dco_decode_u_8(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as int;
  }

  @protected
  void dco_decode_unit(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return;
  }

  @protected
  AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_String(deserializer);
    return AnyhowException(inner);
  }

  @protected
  RustStreamSink<NdEvent> sse_decode_StreamSink_nd_event_Sse(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    throw UnimplementedError('Unreachable ()');
  }

  @protected
  RustStreamSink<NdHostEvent> sse_decode_StreamSink_nd_host_event_Sse(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    throw UnimplementedError('Unreachable ()');
  }

  @protected
  String sse_decode_String(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_list_prim_u_8_strict(deserializer);
    return utf8.decoder.convert(inner);
  }

  @protected
  bool sse_decode_bool(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getUint8() != 0;
  }

  @protected
  double sse_decode_f_32(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getFloat32();
  }

  @protected
  int sse_decode_i_32(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getInt32();
  }

  @protected
  List<NdMonitor> sse_decode_list_nd_monitor(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    var len_ = sse_decode_i_32(deserializer);
    var ans_ = <NdMonitor>[];
    for (var idx_ = 0; idx_ < len_; ++idx_) {
      ans_.add(sse_decode_nd_monitor(deserializer));
    }
    return ans_;
  }

  @protected
  List<int> sse_decode_list_prim_u_8_loose(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var len_ = sse_decode_i_32(deserializer);
    return deserializer.buffer.getUint8List(len_);
  }

  @protected
  Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var len_ = sse_decode_i_32(deserializer);
    return deserializer.buffer.getUint8List(len_);
  }

  @protected
  NdEvent sse_decode_nd_event(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    var tag_ = sse_decode_i_32(deserializer);
    switch (tag_) {
      case 0:
        return const NdEvent_Connecting();
      case 1:
        var var_w = sse_decode_u_32(deserializer);
        var var_h = sse_decode_u_32(deserializer);
        var var_e2E = sse_decode_bool(deserializer);
        var var_hostName = sse_decode_String(deserializer);
        return NdEvent_Connected(
            w: var_w, h: var_h, e2E: var_e2E, hostName: var_hostName);
      case 2:
        var var_width = sse_decode_u_32(deserializer);
        var var_height = sse_decode_u_32(deserializer);
        var var_rgba = sse_decode_list_prim_u_8_strict(deserializer);
        return NdEvent_Frame(
            width: var_width, height: var_height, rgba: var_rgba);
      case 3:
        var var_reason = sse_decode_String(deserializer);
        return NdEvent_Ended(reason: var_reason);
      case 4:
        var var_reason = sse_decode_String(deserializer);
        return NdEvent_Denied(reason: var_reason);
      case 5:
        var var_from = sse_decode_String(deserializer);
        var var_text = sse_decode_String(deserializer);
        return NdEvent_ChatMessage(from: var_from, text: var_text);
      case 6:
        var var_text = sse_decode_String(deserializer);
        return NdEvent_Clipboard(text: var_text);
      default:
        throw UnimplementedError('');
    }
  }

  @protected
  NdHostEvent sse_decode_nd_host_event(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    var tag_ = sse_decode_i_32(deserializer);
    switch (tag_) {
      case 0:
        return const NdHostEvent_Registered();
      case 1:
        var var_e2E = sse_decode_bool(deserializer);
        return NdHostEvent_ViewerConnected(e2E: var_e2E);
      case 2:
        return const NdHostEvent_ViewerLeft();
      case 3:
        var var_x = sse_decode_i_32(deserializer);
        var var_y = sse_decode_i_32(deserializer);
        var var_buttons = sse_decode_u_32(deserializer);
        var var_wheel = sse_decode_f_32(deserializer);
        return NdHostEvent_Mouse(
            x: var_x, y: var_y, buttons: var_buttons, wheel: var_wheel);
      case 4:
        var var_code = sse_decode_String(deserializer);
        var var_down = sse_decode_bool(deserializer);
        return NdHostEvent_Key(code: var_code, down: var_down);
      case 5:
        return const NdHostEvent_KeyframeRequested();
      case 6:
        var var_fps = sse_decode_u_32(deserializer);
        var var_bitrate = sse_decode_u_32(deserializer);
        var var_scale = sse_decode_f_32(deserializer);
        return NdHostEvent_Quality(
            fps: var_fps, bitrate: var_bitrate, scale: var_scale);
      case 7:
        return const NdHostEvent_Reconnecting();
      case 8:
        var var_reason = sse_decode_String(deserializer);
        return NdHostEvent_Ended(reason: var_reason);
      default:
        throw UnimplementedError('');
    }
  }

  @protected
  NdMonitor sse_decode_nd_monitor(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_i = sse_decode_i_32(deserializer);
    var var_w = sse_decode_u_32(deserializer);
    var var_h = sse_decode_u_32(deserializer);
    return NdMonitor(i: var_i, w: var_w, h: var_h);
  }

  @protected
  int sse_decode_u_32(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getUint32();
  }

  @protected
  BigInt sse_decode_u_64(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getBigUint64();
  }

  @protected
  int sse_decode_u_8(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getUint8();
  }

  @protected
  void sse_decode_unit(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
  }

  @protected
  void sse_encode_AnyhowException(
      AnyhowException self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(self.message, serializer);
  }

  @protected
  void sse_encode_StreamSink_nd_event_Sse(
      RustStreamSink<NdEvent> self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(
        self.setupAndSerialize(
            codec: SseCodec(
          decodeSuccessData: sse_decode_nd_event,
          decodeErrorData: sse_decode_AnyhowException,
        )),
        serializer);
  }

  @protected
  void sse_encode_StreamSink_nd_host_event_Sse(
      RustStreamSink<NdHostEvent> self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(
        self.setupAndSerialize(
            codec: SseCodec(
          decodeSuccessData: sse_decode_nd_host_event,
          decodeErrorData: sse_decode_AnyhowException,
        )),
        serializer);
  }

  @protected
  void sse_encode_String(String self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_list_prim_u_8_strict(utf8.encoder.convert(self), serializer);
  }

  @protected
  void sse_encode_bool(bool self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putUint8(self ? 1 : 0);
  }

  @protected
  void sse_encode_f_32(double self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putFloat32(self);
  }

  @protected
  void sse_encode_i_32(int self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putInt32(self);
  }

  @protected
  void sse_encode_list_nd_monitor(
      List<NdMonitor> self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.length, serializer);
    for (final item in self) {
      sse_encode_nd_monitor(item, serializer);
    }
  }

  @protected
  void sse_encode_list_prim_u_8_loose(
      List<int> self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.length, serializer);
    serializer.buffer
        .putUint8List(self is Uint8List ? self : Uint8List.fromList(self));
  }

  @protected
  void sse_encode_list_prim_u_8_strict(
      Uint8List self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.length, serializer);
    serializer.buffer.putUint8List(self);
  }

  @protected
  void sse_encode_nd_event(NdEvent self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    switch (self) {
      case NdEvent_Connecting():
        sse_encode_i_32(0, serializer);
      case NdEvent_Connected(
          w: final w,
          h: final h,
          e2E: final e2E,
          hostName: final hostName
        ):
        sse_encode_i_32(1, serializer);
        sse_encode_u_32(w, serializer);
        sse_encode_u_32(h, serializer);
        sse_encode_bool(e2E, serializer);
        sse_encode_String(hostName, serializer);
      case NdEvent_Frame(
          width: final width,
          height: final height,
          rgba: final rgba
        ):
        sse_encode_i_32(2, serializer);
        sse_encode_u_32(width, serializer);
        sse_encode_u_32(height, serializer);
        sse_encode_list_prim_u_8_strict(rgba, serializer);
      case NdEvent_Ended(reason: final reason):
        sse_encode_i_32(3, serializer);
        sse_encode_String(reason, serializer);
      case NdEvent_Denied(reason: final reason):
        sse_encode_i_32(4, serializer);
        sse_encode_String(reason, serializer);
      case NdEvent_ChatMessage(from: final from, text: final text):
        sse_encode_i_32(5, serializer);
        sse_encode_String(from, serializer);
        sse_encode_String(text, serializer);
      case NdEvent_Clipboard(text: final text):
        sse_encode_i_32(6, serializer);
        sse_encode_String(text, serializer);
    }
  }

  @protected
  void sse_encode_nd_host_event(NdHostEvent self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    switch (self) {
      case NdHostEvent_Registered():
        sse_encode_i_32(0, serializer);
      case NdHostEvent_ViewerConnected(e2E: final e2E):
        sse_encode_i_32(1, serializer);
        sse_encode_bool(e2E, serializer);
      case NdHostEvent_ViewerLeft():
        sse_encode_i_32(2, serializer);
      case NdHostEvent_Mouse(
          x: final x,
          y: final y,
          buttons: final buttons,
          wheel: final wheel
        ):
        sse_encode_i_32(3, serializer);
        sse_encode_i_32(x, serializer);
        sse_encode_i_32(y, serializer);
        sse_encode_u_32(buttons, serializer);
        sse_encode_f_32(wheel, serializer);
      case NdHostEvent_Key(code: final code, down: final down):
        sse_encode_i_32(4, serializer);
        sse_encode_String(code, serializer);
        sse_encode_bool(down, serializer);
      case NdHostEvent_KeyframeRequested():
        sse_encode_i_32(5, serializer);
      case NdHostEvent_Quality(
          fps: final fps,
          bitrate: final bitrate,
          scale: final scale
        ):
        sse_encode_i_32(6, serializer);
        sse_encode_u_32(fps, serializer);
        sse_encode_u_32(bitrate, serializer);
        sse_encode_f_32(scale, serializer);
      case NdHostEvent_Reconnecting():
        sse_encode_i_32(7, serializer);
      case NdHostEvent_Ended(reason: final reason):
        sse_encode_i_32(8, serializer);
        sse_encode_String(reason, serializer);
    }
  }

  @protected
  void sse_encode_nd_monitor(NdMonitor self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.i, serializer);
    sse_encode_u_32(self.w, serializer);
    sse_encode_u_32(self.h, serializer);
  }

  @protected
  void sse_encode_u_32(int self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putUint32(self);
  }

  @protected
  void sse_encode_u_64(BigInt self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putBigUint64(self);
  }

  @protected
  void sse_encode_u_8(int self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putUint8(self);
  }

  @protected
  void sse_encode_unit(void self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
  }
}