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

// 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/commands.dart';
import 'dart:async';
import 'dart:convert';
import 'discovery/model.dart';
import 'event.dart';
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';
import 'transfer/model.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.11.1';

  @override
  int get rustContentHash => -782745325;

  static const kDefaultExternalLibraryLoaderConfig =
      ExternalLibraryLoaderConfig(
        stem: 'rust_lib_mesh_drop_flutter',
        ioDirectory: 'rust/target/release/',
        webPrefix: 'pkg/',
      );
}

abstract class RustLibApi extends BaseApi {
  Future<void> crateApiCommandsCancelTransfer({required String id});

  Future<void> crateApiCommandsClearTransfers();

  Stream<AppEvent> crateApiCommandsCreateEventStream();

  Future<void> crateApiCommandsDeleteTransfer({required String id});

  Future<bool> crateApiCommandsGetAutoAccept();

  Future<bool> crateApiCommandsGetEnableTls();

  Future<String> crateApiCommandsGetHostname();

  Future<List<Peer>> crateApiCommandsGetPeers();

  Future<bool> crateApiCommandsGetSaveHistory();

  Future<String> crateApiCommandsGetSavePath();

  Future<List<Transfer>> crateApiCommandsGetTransfers();

  Future<bool> crateApiCommandsIsTrusted({required String peerId});

  Future<void> crateApiCommandsResolvePendingRequest({
    required String id,
    required bool accept,
    required String path,
  });

  Future<void> crateApiCommandsSendFile({
    required Peer target,
    required String targetIp,
    required String filePath,
  });

  Future<void> crateApiCommandsSendFolder({
    required Peer target,
    required String targetIp,
    required String folderPath,
  });

  Future<void> crateApiCommandsSendText({
    required Peer target,
    required String targetIp,
    required String text,
  });

  Future<void> crateApiCommandsSetAutoAccept({required bool autoAccept});

  Future<void> crateApiCommandsSetEnableTls({required bool enableTls});

  Future<void> crateApiCommandsSetHostname({required String hostname});

  Future<void> crateApiCommandsSetSaveHistory({required bool saveHistory});

  Future<void> crateApiCommandsSetSavePath({required String savePath});

  Future<void> crateApiCommandsTrustPeer({required String peerId});

  Future<void> crateApiCommandsUntrustPeer({required String peerId});
}

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

  @override
  Future<void> crateApiCommandsCancelTransfer({required String id}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(id, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 1,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsCancelTransferConstMeta,
        argValues: [id],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsCancelTransferConstMeta =>
      const TaskConstMeta(debugName: "cancel_transfer", argNames: ["id"]);

  @override
  Future<void> crateApiCommandsClearTransfers() {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 2,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsClearTransfersConstMeta,
        argValues: [],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsClearTransfersConstMeta =>
      const TaskConstMeta(debugName: "clear_transfers", argNames: []);

  @override
  Stream<AppEvent> crateApiCommandsCreateEventStream() {
    final sink = RustStreamSink<AppEvent>();
    unawaited(
      handler.executeNormal(
        NormalTask(
          callFfi: (port_) {
            final serializer = SseSerializer(generalizedFrbRustBinding);
            sse_encode_StreamSink_app_event_Sse(sink, serializer);
            pdeCallFfi(
              generalizedFrbRustBinding,
              serializer,
              funcId: 3,
              port: port_,
            );
          },
          codec: SseCodec(
            decodeSuccessData: sse_decode_unit,
            decodeErrorData: null,
          ),
          constMeta: kCrateApiCommandsCreateEventStreamConstMeta,
          argValues: [sink],
          apiImpl: this,
        ),
      ),
    );
    return sink.stream;
  }

  TaskConstMeta get kCrateApiCommandsCreateEventStreamConstMeta =>
      const TaskConstMeta(debugName: "create_event_stream", argNames: ["sink"]);

  @override
  Future<void> crateApiCommandsDeleteTransfer({required String id}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(id, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 4,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsDeleteTransferConstMeta,
        argValues: [id],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsDeleteTransferConstMeta =>
      const TaskConstMeta(debugName: "delete_transfer", argNames: ["id"]);

  @override
  Future<bool> crateApiCommandsGetAutoAccept() {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 5,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_bool,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsGetAutoAcceptConstMeta,
        argValues: [],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsGetAutoAcceptConstMeta =>
      const TaskConstMeta(debugName: "get_auto_accept", argNames: []);

  @override
  Future<bool> crateApiCommandsGetEnableTls() {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 6,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_bool,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsGetEnableTlsConstMeta,
        argValues: [],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsGetEnableTlsConstMeta =>
      const TaskConstMeta(debugName: "get_enable_tls", argNames: []);

  @override
  Future<String> crateApiCommandsGetHostname() {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 7,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_String,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsGetHostnameConstMeta,
        argValues: [],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsGetHostnameConstMeta =>
      const TaskConstMeta(debugName: "get_hostname", argNames: []);

  @override
  Future<List<Peer>> crateApiCommandsGetPeers() {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 8,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_list_peer,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiCommandsGetPeersConstMeta,
        argValues: [],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsGetPeersConstMeta =>
      const TaskConstMeta(debugName: "get_peers", argNames: []);

  @override
  Future<bool> crateApiCommandsGetSaveHistory() {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 9,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_bool,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsGetSaveHistoryConstMeta,
        argValues: [],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsGetSaveHistoryConstMeta =>
      const TaskConstMeta(debugName: "get_save_history", argNames: []);

  @override
  Future<String> crateApiCommandsGetSavePath() {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 10,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_String,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsGetSavePathConstMeta,
        argValues: [],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsGetSavePathConstMeta =>
      const TaskConstMeta(debugName: "get_save_path", argNames: []);

  @override
  Future<List<Transfer>> crateApiCommandsGetTransfers() {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 11,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_list_transfer,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsGetTransfersConstMeta,
        argValues: [],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsGetTransfersConstMeta =>
      const TaskConstMeta(debugName: "get_transfers", argNames: []);

  @override
  Future<bool> crateApiCommandsIsTrusted({required String peerId}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(peerId, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 12,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_bool,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsIsTrustedConstMeta,
        argValues: [peerId],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsIsTrustedConstMeta =>
      const TaskConstMeta(debugName: "is_trusted", argNames: ["peerId"]);

  @override
  Future<void> crateApiCommandsResolvePendingRequest({
    required String id,
    required bool accept,
    required String path,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(id, serializer);
          sse_encode_bool(accept, serializer);
          sse_encode_String(path, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 13,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsResolvePendingRequestConstMeta,
        argValues: [id, accept, path],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsResolvePendingRequestConstMeta =>
      const TaskConstMeta(
        debugName: "resolve_pending_request",
        argNames: ["id", "accept", "path"],
      );

  @override
  Future<void> crateApiCommandsSendFile({
    required Peer target,
    required String targetIp,
    required String filePath,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_box_autoadd_peer(target, serializer);
          sse_encode_String(targetIp, serializer);
          sse_encode_String(filePath, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 14,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiCommandsSendFileConstMeta,
        argValues: [target, targetIp, filePath],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsSendFileConstMeta => const TaskConstMeta(
    debugName: "send_file",
    argNames: ["target", "targetIp", "filePath"],
  );

  @override
  Future<void> crateApiCommandsSendFolder({
    required Peer target,
    required String targetIp,
    required String folderPath,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_box_autoadd_peer(target, serializer);
          sse_encode_String(targetIp, serializer);
          sse_encode_String(folderPath, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 15,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiCommandsSendFolderConstMeta,
        argValues: [target, targetIp, folderPath],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsSendFolderConstMeta => const TaskConstMeta(
    debugName: "send_folder",
    argNames: ["target", "targetIp", "folderPath"],
  );

  @override
  Future<void> crateApiCommandsSendText({
    required Peer target,
    required String targetIp,
    required String text,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_box_autoadd_peer(target, serializer);
          sse_encode_String(targetIp, serializer);
          sse_encode_String(text, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 16,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiCommandsSendTextConstMeta,
        argValues: [target, targetIp, text],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsSendTextConstMeta => const TaskConstMeta(
    debugName: "send_text",
    argNames: ["target", "targetIp", "text"],
  );

  @override
  Future<void> crateApiCommandsSetAutoAccept({required bool autoAccept}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_bool(autoAccept, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 17,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsSetAutoAcceptConstMeta,
        argValues: [autoAccept],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsSetAutoAcceptConstMeta =>
      const TaskConstMeta(
        debugName: "set_auto_accept",
        argNames: ["autoAccept"],
      );

  @override
  Future<void> crateApiCommandsSetEnableTls({required bool enableTls}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_bool(enableTls, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 18,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsSetEnableTlsConstMeta,
        argValues: [enableTls],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsSetEnableTlsConstMeta =>
      const TaskConstMeta(debugName: "set_enable_tls", argNames: ["enableTls"]);

  @override
  Future<void> crateApiCommandsSetHostname({required String hostname}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(hostname, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 19,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsSetHostnameConstMeta,
        argValues: [hostname],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsSetHostnameConstMeta =>
      const TaskConstMeta(debugName: "set_hostname", argNames: ["hostname"]);

  @override
  Future<void> crateApiCommandsSetSaveHistory({required bool saveHistory}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_bool(saveHistory, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 20,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsSetSaveHistoryConstMeta,
        argValues: [saveHistory],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsSetSaveHistoryConstMeta =>
      const TaskConstMeta(
        debugName: "set_save_history",
        argNames: ["saveHistory"],
      );

  @override
  Future<void> crateApiCommandsSetSavePath({required String savePath}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(savePath, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 21,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsSetSavePathConstMeta,
        argValues: [savePath],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsSetSavePathConstMeta =>
      const TaskConstMeta(debugName: "set_save_path", argNames: ["savePath"]);

  @override
  Future<void> crateApiCommandsTrustPeer({required String peerId}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(peerId, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 22,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiCommandsTrustPeerConstMeta,
        argValues: [peerId],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsTrustPeerConstMeta =>
      const TaskConstMeta(debugName: "trust_peer", argNames: ["peerId"]);

  @override
  Future<void> crateApiCommandsUntrustPeer({required String peerId}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(peerId, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 23,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiCommandsUntrustPeerConstMeta,
        argValues: [peerId],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCommandsUntrustPeerConstMeta =>
      const TaskConstMeta(debugName: "untrust_peer", argNames: ["peerId"]);

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

  @protected
  Map<String, RouteState> dco_decode_Map_String_route_state_None(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return Map.fromEntries(
      dco_decode_list_record_string_route_state(
        raw,
      ).map((e) => MapEntry(e.$1, e.$2)),
    );
  }

  @protected
  RustStreamSink<AppEvent> dco_decode_StreamSink_app_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
  AppEvent dco_decode_app_event(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    switch (raw[0]) {
      case 0:
        return AppEvent_TransferStatusChanged(
          transfer: dco_decode_box_autoadd_transfer(raw[1]),
        );
      case 1:
        return AppEvent_TransferProgressChanged(
          id: dco_decode_String(raw[1]),
          progress: dco_decode_f_64(raw[2]),
          total: dco_decode_f_64(raw[3]),
          speed: dco_decode_f_64(raw[4]),
        );
      case 2:
        return AppEvent_PeerConnectOrUpdated(
          peer: dco_decode_box_autoadd_peer(raw[1]),
        );
      case 3:
        return AppEvent_PeerDisconnected(id: dco_decode_String(raw[1]));
      case 4:
        return AppEvent_TransferAdded(
          transfer: dco_decode_box_autoadd_transfer(raw[1]),
        );
      case 5:
        return AppEvent_TransferRemoved(id: dco_decode_String(raw[1]));
      case 6:
        return AppEvent_TransferClear();
      default:
        throw Exception("unreachable");
    }
  }

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

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

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

  @protected
  CanceledBy dco_decode_canceled_by(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return CanceledBy.values[raw as int];
  }

  @protected
  ContentType dco_decode_content_type(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return ContentType.values[raw as int];
  }

  @protected
  double dco_decode_f_64(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
  PlatformInt64 dco_decode_i_64(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dcoDecodeI64(raw);
  }

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

  @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
  List<(String, RouteState)> dco_decode_list_record_string_route_state(
    dynamic raw,
  ) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return (raw as List<dynamic>)
        .map(dco_decode_record_string_route_state)
        .toList();
  }

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

  @protected
  Peer dco_decode_peer(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 8)
      throw Exception('unexpected arr length: expect 8 but see ${arr.length}');
    return Peer(
      id: dco_decode_String(arr[0]),
      name: dco_decode_String(arr[1]),
      routes: dco_decode_Map_String_route_state_None(arr[2]),
      port: dco_decode_u_16(arr[3]),
      os: dco_decode_String(arr[4]),
      publicKey: dco_decode_String(arr[5]),
      trustMismatch: dco_decode_bool(arr[6]),
      enableTls: dco_decode_bool(arr[7]),
    );
  }

  @protected
  (String, RouteState) dco_decode_record_string_route_state(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 2) {
      throw Exception('Expected 2 elements, got ${arr.length}');
    }
    return (dco_decode_String(arr[0]), dco_decode_route_state(arr[1]));
  }

  @protected
  RouteState dco_decode_route_state(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 2)
      throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
    return RouteState(
      ip: dco_decode_String(arr[0]),
      lastSeen: dco_decode_f_64(arr[1]),
    );
  }

  @protected
  Transfer dco_decode_transfer(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 16)
      throw Exception('unexpected arr length: expect 16 but see ${arr.length}');
    return Transfer(
      id: dco_decode_String(arr[0]),
      createTime: dco_decode_f_64(arr[1]),
      sender: dco_decode_peer(arr[2]),
      senderIp: dco_decode_String(arr[3]),
      fileName: dco_decode_String(arr[4]),
      fileSize: dco_decode_f_64(arr[5]),
      savePath: dco_decode_String(arr[6]),
      status: dco_decode_transfer_status(arr[7]),
      type: dco_decode_transfer_type(arr[8]),
      contentType: dco_decode_content_type(arr[9]),
      text: dco_decode_String(arr[10]),
      errorMsg: dco_decode_String(arr[11]),
      token: dco_decode_String(arr[12]),
      progress: dco_decode_f_64(arr[13]),
      lastReadTime: dco_decode_i_64(arr[14]),
      speed: dco_decode_f_64(arr[15]),
    );
  }

  @protected
  TransferStatus dco_decode_transfer_status(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    switch (raw[0]) {
      case 0:
        return TransferStatus_Pending();
      case 1:
        return TransferStatus_Accepted();
      case 2:
        return TransferStatus_Rejected();
      case 3:
        return TransferStatus_Completed();
      case 4:
        return TransferStatus_Error();
      case 5:
        return TransferStatus_Canceled(dco_decode_canceled_by(raw[1]));
      case 6:
        return TransferStatus_Active();
      default:
        throw Exception("unreachable");
    }
  }

  @protected
  TransferType dco_decode_transfer_type(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return TransferType.values[raw as int];
  }

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

  @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
  Map<String, RouteState> sse_decode_Map_String_route_state_None(
    SseDeserializer deserializer,
  ) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_list_record_string_route_state(deserializer);
    return Map.fromEntries(inner.map((e) => MapEntry(e.$1, e.$2)));
  }

  @protected
  RustStreamSink<AppEvent> sse_decode_StreamSink_app_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
  AppEvent sse_decode_app_event(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    var tag_ = sse_decode_i_32(deserializer);
    switch (tag_) {
      case 0:
        var var_transfer = sse_decode_box_autoadd_transfer(deserializer);
        return AppEvent_TransferStatusChanged(transfer: var_transfer);
      case 1:
        var var_id = sse_decode_String(deserializer);
        var var_progress = sse_decode_f_64(deserializer);
        var var_total = sse_decode_f_64(deserializer);
        var var_speed = sse_decode_f_64(deserializer);
        return AppEvent_TransferProgressChanged(
          id: var_id,
          progress: var_progress,
          total: var_total,
          speed: var_speed,
        );
      case 2:
        var var_peer = sse_decode_box_autoadd_peer(deserializer);
        return AppEvent_PeerConnectOrUpdated(peer: var_peer);
      case 3:
        var var_id = sse_decode_String(deserializer);
        return AppEvent_PeerDisconnected(id: var_id);
      case 4:
        var var_transfer = sse_decode_box_autoadd_transfer(deserializer);
        return AppEvent_TransferAdded(transfer: var_transfer);
      case 5:
        var var_id = sse_decode_String(deserializer);
        return AppEvent_TransferRemoved(id: var_id);
      case 6:
        return AppEvent_TransferClear();
      default:
        throw UnimplementedError('');
    }
  }

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

  @protected
  Peer sse_decode_box_autoadd_peer(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_peer(deserializer));
  }

  @protected
  Transfer sse_decode_box_autoadd_transfer(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_transfer(deserializer));
  }

  @protected
  CanceledBy sse_decode_canceled_by(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_i_32(deserializer);
    return CanceledBy.values[inner];
  }

  @protected
  ContentType sse_decode_content_type(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_i_32(deserializer);
    return ContentType.values[inner];
  }

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

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

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

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

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

  @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
  List<(String, RouteState)> sse_decode_list_record_string_route_state(
    SseDeserializer deserializer,
  ) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    var len_ = sse_decode_i_32(deserializer);
    var ans_ = <(String, RouteState)>[];
    for (var idx_ = 0; idx_ < len_; ++idx_) {
      ans_.add(sse_decode_record_string_route_state(deserializer));
    }
    return ans_;
  }

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

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

  @protected
  Peer sse_decode_peer(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_id = sse_decode_String(deserializer);
    var var_name = sse_decode_String(deserializer);
    var var_routes = sse_decode_Map_String_route_state_None(deserializer);
    var var_port = sse_decode_u_16(deserializer);
    var var_os = sse_decode_String(deserializer);
    var var_publicKey = sse_decode_String(deserializer);
    var var_trustMismatch = sse_decode_bool(deserializer);
    var var_enableTls = sse_decode_bool(deserializer);
    return Peer(
      id: var_id,
      name: var_name,
      routes: var_routes,
      port: var_port,
      os: var_os,
      publicKey: var_publicKey,
      trustMismatch: var_trustMismatch,
      enableTls: var_enableTls,
    );
  }

  @protected
  (String, RouteState) sse_decode_record_string_route_state(
    SseDeserializer deserializer,
  ) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 = sse_decode_String(deserializer);
    var var_field1 = sse_decode_route_state(deserializer);
    return (var_field0, var_field1);
  }

  @protected
  RouteState sse_decode_route_state(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_ip = sse_decode_String(deserializer);
    var var_lastSeen = sse_decode_f_64(deserializer);
    return RouteState(ip: var_ip, lastSeen: var_lastSeen);
  }

  @protected
  Transfer sse_decode_transfer(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_id = sse_decode_String(deserializer);
    var var_createTime = sse_decode_f_64(deserializer);
    var var_sender = sse_decode_peer(deserializer);
    var var_senderIp = sse_decode_String(deserializer);
    var var_fileName = sse_decode_String(deserializer);
    var var_fileSize = sse_decode_f_64(deserializer);
    var var_savePath = sse_decode_String(deserializer);
    var var_status = sse_decode_transfer_status(deserializer);
    var var_type = sse_decode_transfer_type(deserializer);
    var var_contentType = sse_decode_content_type(deserializer);
    var var_text = sse_decode_String(deserializer);
    var var_errorMsg = sse_decode_String(deserializer);
    var var_token = sse_decode_String(deserializer);
    var var_progress = sse_decode_f_64(deserializer);
    var var_lastReadTime = sse_decode_i_64(deserializer);
    var var_speed = sse_decode_f_64(deserializer);
    return Transfer(
      id: var_id,
      createTime: var_createTime,
      sender: var_sender,
      senderIp: var_senderIp,
      fileName: var_fileName,
      fileSize: var_fileSize,
      savePath: var_savePath,
      status: var_status,
      type: var_type,
      contentType: var_contentType,
      text: var_text,
      errorMsg: var_errorMsg,
      token: var_token,
      progress: var_progress,
      lastReadTime: var_lastReadTime,
      speed: var_speed,
    );
  }

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

    var tag_ = sse_decode_i_32(deserializer);
    switch (tag_) {
      case 0:
        return TransferStatus_Pending();
      case 1:
        return TransferStatus_Accepted();
      case 2:
        return TransferStatus_Rejected();
      case 3:
        return TransferStatus_Completed();
      case 4:
        return TransferStatus_Error();
      case 5:
        var var_field0 = sse_decode_canceled_by(deserializer);
        return TransferStatus_Canceled(var_field0);
      case 6:
        return TransferStatus_Active();
      default:
        throw UnimplementedError('');
    }
  }

  @protected
  TransferType sse_decode_transfer_type(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_i_32(deserializer);
    return TransferType.values[inner];
  }

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

  @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_Map_String_route_state_None(
    Map<String, RouteState> self,
    SseSerializer serializer,
  ) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_list_record_string_route_state(
      self.entries.map((e) => (e.key, e.value)).toList(),
      serializer,
    );
  }

  @protected
  void sse_encode_StreamSink_app_event_Sse(
    RustStreamSink<AppEvent> self,
    SseSerializer serializer,
  ) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(
      self.setupAndSerialize(
        codec: SseCodec(
          decodeSuccessData: sse_decode_app_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_app_event(AppEvent self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    switch (self) {
      case AppEvent_TransferStatusChanged(transfer: final transfer):
        sse_encode_i_32(0, serializer);
        sse_encode_box_autoadd_transfer(transfer, serializer);
      case AppEvent_TransferProgressChanged(
        id: final id,
        progress: final progress,
        total: final total,
        speed: final speed,
      ):
        sse_encode_i_32(1, serializer);
        sse_encode_String(id, serializer);
        sse_encode_f_64(progress, serializer);
        sse_encode_f_64(total, serializer);
        sse_encode_f_64(speed, serializer);
      case AppEvent_PeerConnectOrUpdated(peer: final peer):
        sse_encode_i_32(2, serializer);
        sse_encode_box_autoadd_peer(peer, serializer);
      case AppEvent_PeerDisconnected(id: final id):
        sse_encode_i_32(3, serializer);
        sse_encode_String(id, serializer);
      case AppEvent_TransferAdded(transfer: final transfer):
        sse_encode_i_32(4, serializer);
        sse_encode_box_autoadd_transfer(transfer, serializer);
      case AppEvent_TransferRemoved(id: final id):
        sse_encode_i_32(5, serializer);
        sse_encode_String(id, serializer);
      case AppEvent_TransferClear():
        sse_encode_i_32(6, 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_box_autoadd_peer(Peer self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_peer(self, serializer);
  }

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

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

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

  @protected
  void sse_encode_f_64(double self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putFloat64(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_i_64(PlatformInt64 self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putPlatformInt64(self);
  }

  @protected
  void sse_encode_list_peer(List<Peer> 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_peer(item, serializer);
    }
  }

  @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_list_record_string_route_state(
    List<(String, RouteState)> 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_record_string_route_state(item, serializer);
    }
  }

  @protected
  void sse_encode_list_transfer(List<Transfer> 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_transfer(item, serializer);
    }
  }

  @protected
  void sse_encode_peer(Peer self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(self.id, serializer);
    sse_encode_String(self.name, serializer);
    sse_encode_Map_String_route_state_None(self.routes, serializer);
    sse_encode_u_16(self.port, serializer);
    sse_encode_String(self.os, serializer);
    sse_encode_String(self.publicKey, serializer);
    sse_encode_bool(self.trustMismatch, serializer);
    sse_encode_bool(self.enableTls, serializer);
  }

  @protected
  void sse_encode_record_string_route_state(
    (String, RouteState) self,
    SseSerializer serializer,
  ) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(self.$1, serializer);
    sse_encode_route_state(self.$2, serializer);
  }

  @protected
  void sse_encode_route_state(RouteState self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(self.ip, serializer);
    sse_encode_f_64(self.lastSeen, serializer);
  }

  @protected
  void sse_encode_transfer(Transfer self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(self.id, serializer);
    sse_encode_f_64(self.createTime, serializer);
    sse_encode_peer(self.sender, serializer);
    sse_encode_String(self.senderIp, serializer);
    sse_encode_String(self.fileName, serializer);
    sse_encode_f_64(self.fileSize, serializer);
    sse_encode_String(self.savePath, serializer);
    sse_encode_transfer_status(self.status, serializer);
    sse_encode_transfer_type(self.type, serializer);
    sse_encode_content_type(self.contentType, serializer);
    sse_encode_String(self.text, serializer);
    sse_encode_String(self.errorMsg, serializer);
    sse_encode_String(self.token, serializer);
    sse_encode_f_64(self.progress, serializer);
    sse_encode_i_64(self.lastReadTime, serializer);
    sse_encode_f_64(self.speed, serializer);
  }

  @protected
  void sse_encode_transfer_status(
    TransferStatus self,
    SseSerializer serializer,
  ) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    switch (self) {
      case TransferStatus_Pending():
        sse_encode_i_32(0, serializer);
      case TransferStatus_Accepted():
        sse_encode_i_32(1, serializer);
      case TransferStatus_Rejected():
        sse_encode_i_32(2, serializer);
      case TransferStatus_Completed():
        sse_encode_i_32(3, serializer);
      case TransferStatus_Error():
        sse_encode_i_32(4, serializer);
      case TransferStatus_Canceled(field0: final field0):
        sse_encode_i_32(5, serializer);
        sse_encode_canceled_by(field0, serializer);
      case TransferStatus_Active():
        sse_encode_i_32(6, serializer);
    }
  }

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

  @protected
  void sse_encode_u_16(int self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putUint16(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
  }
}