1  // This file is automatically generated, so please do not edit it.
   2  // @generated by `flutter_rust_bridge`@ 2.11.1.
   3  
   4  // 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
   5  
   6  import 'api.dart';
   7  import 'dart:async';
   8  import 'dart:convert';
   9  import 'frb_generated.dart';
  10  import 'frb_generated.io.dart'
  11      if (dart.library.js_interop) 'frb_generated.web.dart';
  12  import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart';
  13  import 'transport.dart';
  14  import 'transport/dht.dart';
  15  import 'transport/relay.dart';
  16  
  17  /// Main entrypoint of the Rust API
  18  class RustLib extends BaseEntrypoint<RustLibApi, RustLibApiImpl, RustLibWire> {
  19    @internal
  20    static final instance = RustLib._();
  21  
  22    RustLib._();
  23  
  24    /// Initialize flutter_rust_bridge
  25    static Future<void> init({
  26      RustLibApi? api,
  27      BaseHandler? handler,
  28      ExternalLibrary? externalLibrary,
  29      bool forceSameCodegenVersion = true,
  30    }) async {
  31      await instance.initImpl(
  32        api: api,
  33        handler: handler,
  34        externalLibrary: externalLibrary,
  35        forceSameCodegenVersion: forceSameCodegenVersion,
  36      );
  37    }
  38  
  39    /// Initialize flutter_rust_bridge in mock mode.
  40    /// No libraries for FFI are loaded.
  41    static void initMock({required RustLibApi api}) {
  42      instance.initMockImpl(api: api);
  43    }
  44  
  45    /// Dispose flutter_rust_bridge
  46    ///
  47    /// The call to this function is optional, since flutter_rust_bridge (and everything else)
  48    /// is automatically disposed when the app stops.
  49    static void dispose() => instance.disposeImpl();
  50  
  51    @override
  52    ApiImplConstructor<RustLibApiImpl, RustLibWire> get apiImplConstructor =>
  53        RustLibApiImpl.new;
  54  
  55    @override
  56    WireConstructor<RustLibWire> get wireConstructor =>
  57        RustLibWire.fromExternalLibrary;
  58  
  59    @override
  60    Future<void> executeRustInitializers() async {}
  61  
  62    @override
  63    ExternalLibraryLoaderConfig get defaultExternalLibraryLoaderConfig =>
  64        kDefaultExternalLibraryLoaderConfig;
  65  
  66    @override
  67    String get codegenVersion => '2.11.1';
  68  
  69    @override
  70    int get rustContentHash => 624514824;
  71  
  72    static const kDefaultExternalLibraryLoaderConfig =
  73        ExternalLibraryLoaderConfig(
  74          stem: 'rust_lib_dead_drop',
  75          ioDirectory: '../core/target/release/',
  76          webPrefix: 'pkg/',
  77        );
  78  }
  79  
  80  abstract class RustLibApi extends BaseApi {
  81    void crateApiAcceptGroupInvite({required List<int> groupId});
  82  
  83    void crateApiAcknowledgeDhtMessages({required List<Uint8List> messageIds});
  84  
  85    Future<void> crateApiAddGroupMember({
  86      required List<int> groupId,
  87      required List<int> contactId,
  88    });
  89  
  90    void crateApiAddReaction({
  91      required List<int> messageId,
  92      required String emoji,
  93    });
  94  
  95    void crateApiBlockContact({required List<int> contactId});
  96  
  97    Future<void> crateApiBootstrapDht({required List<String> nodes});
  98  
  99    Uint8List? crateApiCheckRotatingId({required List<int> scannedId});
 100  
 101    int crateApiCleanupForwardedMessages();
 102  
 103    int crateApiClearConversation({required List<int> contactId});
 104  
 105    int crateApiClearForwardedMessages();
 106  
 107    void crateApiConfirmContact({
 108      required PendingContact pending,
 109      String? nickname,
 110    });
 111  
 112    void crateApiConnectRelay({required String url});
 113  
 114    Future<Uint8List> crateApiCreateGroup({
 115      required String name,
 116      required List<Uint8List> memberIds,
 117    });
 118  
 119    HandshakeHandle crateApiCreateHandshakeInitiator({
 120      required List<int> contactId,
 121    });
 122  
 123    HandshakeHandle crateApiCreateHandshakeInitiatorAnonymous();
 124  
 125    HandshakeHandle crateApiCreateHandshakeResponder();
 126  
 127    IdentityInfo crateApiCreateIdentity();
 128  
 129    Future<void> crateApiDeclineGroupInvite({required List<int> groupId});
 130  
 131    void crateApiDeleteAllData();
 132  
 133    void crateApiDeleteContact({required List<int> contactId});
 134  
 135    void crateApiDeleteMessage({required List<int> messageId});
 136  
 137    Future<DhtStateDto> crateApiDhtStateDtoFromInternal({
 138      required DhtState state,
 139    });
 140  
 141    Future<void> crateApiDisconnectDht();
 142  
 143    void crateApiDisconnectRelay();
 144  
 145    int crateApiEnforceForwardingLimit();
 146  
 147    void crateApiExchangeCancel({required ExchangeHandle handle});
 148  
 149    ExchangeComplete crateApiExchangeFinalize({required ExchangeHandle handle});
 150  
 151    (ExchangeComplete, GossipExchangeHandle) crateApiExchangeFinalizeForGossip({
 152      required ExchangeHandle handle,
 153    });
 154  
 155    ExchangeResultDto crateApiExchangeReceive({
 156      required ExchangeHandle handle,
 157      required List<int> data,
 158    });
 159  
 160    Uint8List? crateApiExchangeSend({required ExchangeHandle handle});
 161  
 162    int crateApiExpirePendingRelay({required PlatformInt64 maxAgeSecs});
 163  
 164    int crateApiExpireStaleMessages({required PlatformInt64 maxAgeSecs});
 165  
 166    Future<String?> crateApiFetchContactIrohEndpointId({
 167      required List<int> contactId,
 168    });
 169  
 170    Future<String?> crateApiFetchContactOnionAddress({
 171      required List<int> contactId,
 172    });
 173  
 174    Future<DhtFetchResult> crateApiFetchMessagesFromDht();
 175  
 176    Uint8List crateApiGenerateGossipDigest();
 177  
 178    String crateApiGenerateQrPayload();
 179  
 180    List<AchievementInfo> crateApiGetAchievements();
 181  
 182    List<TransportInfoDto> crateApiGetAvailableTransports();
 183  
 184    Future<List<CachedIrohEndpoint>> crateApiGetCachedIrohEndpointIds();
 185  
 186    Future<List<CachedOnionAddress>> crateApiGetCachedOnionAddresses();
 187  
 188    ContactInfo crateApiGetContact({required List<int> contactId});
 189  
 190    Future<Uint8List?> crateApiGetContactIdByIdentityKey({
 191      required List<int> identityKey,
 192    });
 193  
 194    Uint8List crateApiGetContactIdentityKey({required List<int> contactId});
 195  
 196    bool crateApiGetContactMuted({required List<int> contactId});
 197  
 198    List<MessageInfo> crateApiGetConversation({required List<int> contactId});
 199  
 200    DhtStateDto crateApiGetDhtState();
 201  
 202    BigInt crateApiGetDisappearingDuration({required List<int> contactId});
 203  
 204    (String, BigInt)? crateApiGetDocumentInfo({required List<int> documentId});
 205  
 206    ForwardingInfo crateApiGetForwardingStats();
 207  
 208    List<MessageInfo> crateApiGetGroupConversation({required List<int> groupId});
 209  
 210    List<GroupMemberInfoDto> crateApiGetGroupMembers({
 211      required List<int> groupId,
 212    });
 213  
 214    IdentityInfo crateApiGetIdentity();
 215  
 216    IrohStateDto crateApiGetIrohState();
 217  
 218    List<MessageInfo> crateApiGetMessages({required List<int> contactId});
 219  
 220    List<Uint8List> crateApiGetMyRotatingIds();
 221  
 222    List<MessageInfo> crateApiGetOutboundQueue({required List<int> contactId});
 223  
 224    Future<List<EncryptedPayload>> crateApiGetQueuedEncrypted({
 225      required List<int> contactId,
 226    });
 227  
 228    (int, int)? crateApiGetReceiveProgress({required List<int> documentId});
 229  
 230    RelayStateDto crateApiGetRelayState();
 231  
 232    ReputationInfo crateApiGetReputation();
 233  
 234    (int, int)? crateApiGetSendProgress({required List<int> documentId});
 235  
 236    String crateApiGetStatistics();
 237  
 238    String crateApiGetTransportName({required TransportTypeDto transportType});
 239  
 240    NetworkTransportPreference crateApiGetTransportPreferenceValue();
 241  
 242    TransportStatsInfo crateApiGetTransportStats();
 243  
 244    int crateApiGetUnreadCount();
 245  
 246    void crateApiGossipExchangeCancel({required GossipExchangeHandle handle});
 247  
 248    GossipExchangeComplete crateApiGossipExchangeFinalize({
 249      required GossipExchangeHandle handle,
 250    });
 251  
 252    GossipFinalizeKeepTransportResult
 253    crateApiGossipExchangeFinalizeKeepTransport({
 254      required GossipExchangeHandle handle,
 255    });
 256  
 257    bool crateApiGossipExchangeReceive({
 258      required GossipExchangeHandle handle,
 259      required List<int> data,
 260    });
 261  
 262    Uint8List? crateApiGossipExchangeSend({required GossipExchangeHandle handle});
 263  
 264    GossipExchangeHandle crateApiGossipStartNewRound({
 265      required BigInt transportHandle,
 266    });
 267  
 268    void crateApiGossipTransportRelease({required BigInt transportHandle});
 269  
 270    Uint8List crateApiHandleGossipRequest({required List<int> requestBytes});
 271  
 272    void crateApiHandshakeCancel({required HandshakeHandle handle});
 273  
 274    ExchangeHandle crateApiHandshakeFinalize({required HandshakeHandle handle});
 275  
 276    GossipExchangeHandle crateApiHandshakeFinalizeForGossip({
 277      required HandshakeHandle handle,
 278    });
 279  
 280    Uint8List crateApiHandshakeGenerate({required HandshakeHandle handle});
 281  
 282    HandshakeResult crateApiHandshakeProcess({
 283      required HandshakeHandle handle,
 284      required List<int> data,
 285    });
 286  
 287    bool crateApiHasIdentity();
 288  
 289    void crateApiInitialize({
 290      required String storagePath,
 291      required String passphrase,
 292    });
 293  
 294    bool crateApiIsDocumentComplete({required List<int> documentId});
 295  
 296    bool crateApiIsGroupAccepted({required List<int> groupId});
 297  
 298    bool crateApiIsInitialized();
 299  
 300    bool crateApiIsTransportAvailable({required TransportTypeDto transportType});
 301  
 302    Future<void> crateApiLeaveGroup({required List<int> groupId});
 303  
 304    List<ContactInfo> crateApiListContacts();
 305  
 306    List<GroupInfo> crateApiListGroups();
 307  
 308    Future<void> crateApiMarkDeliveredViaTor({
 309      required List<Uint8List> messageIds,
 310    });
 311  
 312    void crateApiMarkRead({required List<int> messageId});
 313  
 314    Future<NetworkTransportPreference>
 315    crateApiNetworkTransportPreferenceDefault();
 316  
 317    Future<IrohIncomingMessage?> crateApiPollIrohIncoming();
 318  
 319    Uint8List? crateApiProcessGossipDigest({required List<int> digestBytes});
 320  
 321    GossipResult crateApiProcessGossipResponse({
 322      required List<int> responseBytes,
 323    });
 324  
 325    Future<MessageInfo?> crateApiProcessIrohMessage({
 326      required List<int> senderIdentityKey,
 327      required List<int> payload,
 328    });
 329  
 330    Future<MessageInfo?> crateApiProcessIrohMessageUnknownSender({
 331      required List<int> payload,
 332    });
 333  
 334    PendingContact crateApiProcessQrCode({required String payload});
 335  
 336    Future<MessageInfo?> crateApiProcessTorMessage({
 337      required List<int> senderIdentityKey,
 338      required List<int> payload,
 339    });
 340  
 341    int crateApiPromoteToGossipRelay({required PlatformInt64 minAgeSecs});
 342  
 343    Future<void> crateApiPublishIrohEndpointId();
 344  
 345    Future<DhtPublishResult> crateApiPublishMessagesToDht({
 346      required List<int> contactId,
 347    });
 348  
 349    Future<void> crateApiPublishOnionAddress({required String onionAddress});
 350  
 351    bool crateApiQueueForGossipRelay({required List<int> messageId});
 352  
 353    DocumentInfo crateApiReassembleDocument({required List<int> documentId});
 354  
 355    List<String> crateApiRecordDeliveryConfirmation({
 356      required List<int> messageHash,
 357    });
 358  
 359    List<String> crateApiRecordMessageForwarded({
 360      required List<int> recipientKeyHash,
 361    });
 362  
 363    void crateApiRefreshContactKeys({
 364      required List<int> contactId,
 365      required String qrPayload,
 366    });
 367  
 368    Future<RelayStateDto> crateApiRelayStateDtoFromInternal({
 369      required RelayState state,
 370    });
 371  
 372    Future<void> crateApiRemoveGroupMember({
 373      required List<int> groupId,
 374      required List<int> contactId,
 375    });
 376  
 377    void crateApiRemoveReaction({
 378      required List<int> messageId,
 379      required String emoji,
 380    });
 381  
 382    Future<void> crateApiRenameGroup({
 383      required List<int> groupId,
 384      required String newName,
 385    });
 386  
 387    Future<int> crateApiRequeueFailedMessages({required List<int> contactId});
 388  
 389    void crateApiRetryMessage({required List<int> messageId});
 390  
 391    int crateApiRetryStuckMessages({required PlatformInt64 timeoutSecs});
 392  
 393    int crateApiRunMaintenance();
 394  
 395    List<SearchResultInfo> crateApiSearchAllMessages({
 396      required String query,
 397      required int limit,
 398    });
 399  
 400    List<SearchResultInfo> crateApiSearchConversation({
 401      required List<int> contactId,
 402      required String query,
 403      required int limit,
 404    });
 405  
 406    Future<Uint8List> crateApiSendDocument({
 407      required List<int> recipientId,
 408      required List<int> content,
 409      required String filename,
 410      int? ttlDays,
 411    });
 412  
 413    Future<Uint8List> crateApiSendGroupDocument({
 414      required List<int> groupId,
 415      required List<int> content,
 416      required String filename,
 417    });
 418  
 419    Future<Uint8List> crateApiSendGroupMessage({
 420      required List<int> groupId,
 421      required List<int> content,
 422      required int contentType,
 423      String? filename,
 424    });
 425  
 426    Future<Uint8List> crateApiSendMessage({
 427      required List<int> recipientId,
 428      required List<int> content,
 429      required int contentType,
 430      String? filename,
 431      int? ttlDays,
 432    });
 433  
 434    Future<void> crateApiSendViaIroh({
 435      required String endpointId,
 436      required List<int> payload,
 437    });
 438  
 439    void crateApiSetContactIrohEndpoint({
 440      required List<int> contactId,
 441      required String endpointId,
 442    });
 443  
 444    void crateApiSetContactMuted({
 445      required List<int> contactId,
 446      required bool muted,
 447    });
 448  
 449    void crateApiSetDisappearingDuration({
 450      required List<int> contactId,
 451      required BigInt durationSecs,
 452    });
 453  
 454    void crateApiSetGroupDisappearing({
 455      required List<int> groupId,
 456      required BigInt duration,
 457    });
 458  
 459    void crateApiSetGroupMuted({
 460      required List<int> groupId,
 461      required bool isMuted,
 462    });
 463  
 464    Future<void> crateApiSetOutboundTransport({
 465      required List<Uint8List> messageIds,
 466      required String transport,
 467    });
 468  
 469    void crateApiSetTransportPreference({
 470      required NetworkTransportPreference preference,
 471    });
 472  
 473    Future<void> crateApiStartIroh();
 474  
 475    Future<void> crateApiStopIroh();
 476  
 477    bool crateApiToggleReaction({
 478      required List<int> messageId,
 479      required String emoji,
 480    });
 481  
 482    Future<TransportAddressDto?> crateApiTransportAddressDtoFromInternal({
 483      required TransportAddress addr,
 484    });
 485  
 486    Future<TransportStatsInfo> crateApiTransportStatsInfoDefault();
 487  
 488    Future<TransportTypeDto?> crateApiTransportTypeDtoFromInternal({
 489      required TransportType tt,
 490    });
 491  
 492    Future<TransportType> crateApiTransportTypeDtoToInternal({
 493      required TransportTypeDto that,
 494    });
 495  
 496    void crateApiUnblockContact({required List<int> contactId});
 497  
 498    void crateApiUpdateContactNickname({
 499      required List<int> contactId,
 500      String? nickname,
 501    });
 502  }
 503  
 504  class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
 505    RustLibApiImpl({
 506      required super.handler,
 507      required super.wire,
 508      required super.generalizedFrbRustBinding,
 509      required super.portManager,
 510    });
 511  
 512    @override
 513    void crateApiAcceptGroupInvite({required List<int> groupId}) {
 514      return handler.executeSync(
 515        SyncTask(
 516          callFfi: () {
 517            final serializer = SseSerializer(generalizedFrbRustBinding);
 518            sse_encode_list_prim_u_8_loose(groupId, serializer);
 519            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1)!;
 520          },
 521          codec: SseCodec(
 522            decodeSuccessData: sse_decode_unit,
 523            decodeErrorData: sse_decode_String,
 524          ),
 525          constMeta: kCrateApiAcceptGroupInviteConstMeta,
 526          argValues: [groupId],
 527          apiImpl: this,
 528        ),
 529      );
 530    }
 531  
 532    TaskConstMeta get kCrateApiAcceptGroupInviteConstMeta => const TaskConstMeta(
 533      debugName: "accept_group_invite",
 534      argNames: ["groupId"],
 535    );
 536  
 537    @override
 538    void crateApiAcknowledgeDhtMessages({required List<Uint8List> messageIds}) {
 539      return handler.executeSync(
 540        SyncTask(
 541          callFfi: () {
 542            final serializer = SseSerializer(generalizedFrbRustBinding);
 543            sse_encode_list_list_prim_u_8_strict(messageIds, serializer);
 544            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 2)!;
 545          },
 546          codec: SseCodec(
 547            decodeSuccessData: sse_decode_unit,
 548            decodeErrorData: sse_decode_String,
 549          ),
 550          constMeta: kCrateApiAcknowledgeDhtMessagesConstMeta,
 551          argValues: [messageIds],
 552          apiImpl: this,
 553        ),
 554      );
 555    }
 556  
 557    TaskConstMeta get kCrateApiAcknowledgeDhtMessagesConstMeta =>
 558        const TaskConstMeta(
 559          debugName: "acknowledge_dht_messages",
 560          argNames: ["messageIds"],
 561        );
 562  
 563    @override
 564    Future<void> crateApiAddGroupMember({
 565      required List<int> groupId,
 566      required List<int> contactId,
 567    }) {
 568      return handler.executeNormal(
 569        NormalTask(
 570          callFfi: (port_) {
 571            final serializer = SseSerializer(generalizedFrbRustBinding);
 572            sse_encode_list_prim_u_8_loose(groupId, serializer);
 573            sse_encode_list_prim_u_8_loose(contactId, serializer);
 574            pdeCallFfi(
 575              generalizedFrbRustBinding,
 576              serializer,
 577              funcId: 3,
 578              port: port_,
 579            );
 580          },
 581          codec: SseCodec(
 582            decodeSuccessData: sse_decode_unit,
 583            decodeErrorData: sse_decode_String,
 584          ),
 585          constMeta: kCrateApiAddGroupMemberConstMeta,
 586          argValues: [groupId, contactId],
 587          apiImpl: this,
 588        ),
 589      );
 590    }
 591  
 592    TaskConstMeta get kCrateApiAddGroupMemberConstMeta => const TaskConstMeta(
 593      debugName: "add_group_member",
 594      argNames: ["groupId", "contactId"],
 595    );
 596  
 597    @override
 598    void crateApiAddReaction({
 599      required List<int> messageId,
 600      required String emoji,
 601    }) {
 602      return handler.executeSync(
 603        SyncTask(
 604          callFfi: () {
 605            final serializer = SseSerializer(generalizedFrbRustBinding);
 606            sse_encode_list_prim_u_8_loose(messageId, serializer);
 607            sse_encode_String(emoji, serializer);
 608            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 4)!;
 609          },
 610          codec: SseCodec(
 611            decodeSuccessData: sse_decode_unit,
 612            decodeErrorData: sse_decode_String,
 613          ),
 614          constMeta: kCrateApiAddReactionConstMeta,
 615          argValues: [messageId, emoji],
 616          apiImpl: this,
 617        ),
 618      );
 619    }
 620  
 621    TaskConstMeta get kCrateApiAddReactionConstMeta => const TaskConstMeta(
 622      debugName: "add_reaction",
 623      argNames: ["messageId", "emoji"],
 624    );
 625  
 626    @override
 627    void crateApiBlockContact({required List<int> contactId}) {
 628      return handler.executeSync(
 629        SyncTask(
 630          callFfi: () {
 631            final serializer = SseSerializer(generalizedFrbRustBinding);
 632            sse_encode_list_prim_u_8_loose(contactId, serializer);
 633            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 5)!;
 634          },
 635          codec: SseCodec(
 636            decodeSuccessData: sse_decode_unit,
 637            decodeErrorData: sse_decode_String,
 638          ),
 639          constMeta: kCrateApiBlockContactConstMeta,
 640          argValues: [contactId],
 641          apiImpl: this,
 642        ),
 643      );
 644    }
 645  
 646    TaskConstMeta get kCrateApiBlockContactConstMeta =>
 647        const TaskConstMeta(debugName: "block_contact", argNames: ["contactId"]);
 648  
 649    @override
 650    Future<void> crateApiBootstrapDht({required List<String> nodes}) {
 651      return handler.executeNormal(
 652        NormalTask(
 653          callFfi: (port_) {
 654            final serializer = SseSerializer(generalizedFrbRustBinding);
 655            sse_encode_list_String(nodes, serializer);
 656            pdeCallFfi(
 657              generalizedFrbRustBinding,
 658              serializer,
 659              funcId: 6,
 660              port: port_,
 661            );
 662          },
 663          codec: SseCodec(
 664            decodeSuccessData: sse_decode_unit,
 665            decodeErrorData: sse_decode_String,
 666          ),
 667          constMeta: kCrateApiBootstrapDhtConstMeta,
 668          argValues: [nodes],
 669          apiImpl: this,
 670        ),
 671      );
 672    }
 673  
 674    TaskConstMeta get kCrateApiBootstrapDhtConstMeta =>
 675        const TaskConstMeta(debugName: "bootstrap_dht", argNames: ["nodes"]);
 676  
 677    @override
 678    Uint8List? crateApiCheckRotatingId({required List<int> scannedId}) {
 679      return handler.executeSync(
 680        SyncTask(
 681          callFfi: () {
 682            final serializer = SseSerializer(generalizedFrbRustBinding);
 683            sse_encode_list_prim_u_8_loose(scannedId, serializer);
 684            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 7)!;
 685          },
 686          codec: SseCodec(
 687            decodeSuccessData: sse_decode_opt_list_prim_u_8_strict,
 688            decodeErrorData: sse_decode_String,
 689          ),
 690          constMeta: kCrateApiCheckRotatingIdConstMeta,
 691          argValues: [scannedId],
 692          apiImpl: this,
 693        ),
 694      );
 695    }
 696  
 697    TaskConstMeta get kCrateApiCheckRotatingIdConstMeta => const TaskConstMeta(
 698      debugName: "check_rotating_id",
 699      argNames: ["scannedId"],
 700    );
 701  
 702    @override
 703    int crateApiCleanupForwardedMessages() {
 704      return handler.executeSync(
 705        SyncTask(
 706          callFfi: () {
 707            final serializer = SseSerializer(generalizedFrbRustBinding);
 708            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 8)!;
 709          },
 710          codec: SseCodec(
 711            decodeSuccessData: sse_decode_u_32,
 712            decodeErrorData: sse_decode_String,
 713          ),
 714          constMeta: kCrateApiCleanupForwardedMessagesConstMeta,
 715          argValues: [],
 716          apiImpl: this,
 717        ),
 718      );
 719    }
 720  
 721    TaskConstMeta get kCrateApiCleanupForwardedMessagesConstMeta =>
 722        const TaskConstMeta(
 723          debugName: "cleanup_forwarded_messages",
 724          argNames: [],
 725        );
 726  
 727    @override
 728    int crateApiClearConversation({required List<int> contactId}) {
 729      return handler.executeSync(
 730        SyncTask(
 731          callFfi: () {
 732            final serializer = SseSerializer(generalizedFrbRustBinding);
 733            sse_encode_list_prim_u_8_loose(contactId, serializer);
 734            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 9)!;
 735          },
 736          codec: SseCodec(
 737            decodeSuccessData: sse_decode_u_32,
 738            decodeErrorData: sse_decode_String,
 739          ),
 740          constMeta: kCrateApiClearConversationConstMeta,
 741          argValues: [contactId],
 742          apiImpl: this,
 743        ),
 744      );
 745    }
 746  
 747    TaskConstMeta get kCrateApiClearConversationConstMeta => const TaskConstMeta(
 748      debugName: "clear_conversation",
 749      argNames: ["contactId"],
 750    );
 751  
 752    @override
 753    int crateApiClearForwardedMessages() {
 754      return handler.executeSync(
 755        SyncTask(
 756          callFfi: () {
 757            final serializer = SseSerializer(generalizedFrbRustBinding);
 758            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 10)!;
 759          },
 760          codec: SseCodec(
 761            decodeSuccessData: sse_decode_u_32,
 762            decodeErrorData: sse_decode_String,
 763          ),
 764          constMeta: kCrateApiClearForwardedMessagesConstMeta,
 765          argValues: [],
 766          apiImpl: this,
 767        ),
 768      );
 769    }
 770  
 771    TaskConstMeta get kCrateApiClearForwardedMessagesConstMeta =>
 772        const TaskConstMeta(debugName: "clear_forwarded_messages", argNames: []);
 773  
 774    @override
 775    void crateApiConfirmContact({
 776      required PendingContact pending,
 777      String? nickname,
 778    }) {
 779      return handler.executeSync(
 780        SyncTask(
 781          callFfi: () {
 782            final serializer = SseSerializer(generalizedFrbRustBinding);
 783            sse_encode_box_autoadd_pending_contact(pending, serializer);
 784            sse_encode_opt_String(nickname, serializer);
 785            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 11)!;
 786          },
 787          codec: SseCodec(
 788            decodeSuccessData: sse_decode_unit,
 789            decodeErrorData: sse_decode_String,
 790          ),
 791          constMeta: kCrateApiConfirmContactConstMeta,
 792          argValues: [pending, nickname],
 793          apiImpl: this,
 794        ),
 795      );
 796    }
 797  
 798    TaskConstMeta get kCrateApiConfirmContactConstMeta => const TaskConstMeta(
 799      debugName: "confirm_contact",
 800      argNames: ["pending", "nickname"],
 801    );
 802  
 803    @override
 804    void crateApiConnectRelay({required String url}) {
 805      return handler.executeSync(
 806        SyncTask(
 807          callFfi: () {
 808            final serializer = SseSerializer(generalizedFrbRustBinding);
 809            sse_encode_String(url, serializer);
 810            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 12)!;
 811          },
 812          codec: SseCodec(
 813            decodeSuccessData: sse_decode_unit,
 814            decodeErrorData: sse_decode_String,
 815          ),
 816          constMeta: kCrateApiConnectRelayConstMeta,
 817          argValues: [url],
 818          apiImpl: this,
 819        ),
 820      );
 821    }
 822  
 823    TaskConstMeta get kCrateApiConnectRelayConstMeta =>
 824        const TaskConstMeta(debugName: "connect_relay", argNames: ["url"]);
 825  
 826    @override
 827    Future<Uint8List> crateApiCreateGroup({
 828      required String name,
 829      required List<Uint8List> memberIds,
 830    }) {
 831      return handler.executeNormal(
 832        NormalTask(
 833          callFfi: (port_) {
 834            final serializer = SseSerializer(generalizedFrbRustBinding);
 835            sse_encode_String(name, serializer);
 836            sse_encode_list_list_prim_u_8_strict(memberIds, serializer);
 837            pdeCallFfi(
 838              generalizedFrbRustBinding,
 839              serializer,
 840              funcId: 13,
 841              port: port_,
 842            );
 843          },
 844          codec: SseCodec(
 845            decodeSuccessData: sse_decode_list_prim_u_8_strict,
 846            decodeErrorData: sse_decode_String,
 847          ),
 848          constMeta: kCrateApiCreateGroupConstMeta,
 849          argValues: [name, memberIds],
 850          apiImpl: this,
 851        ),
 852      );
 853    }
 854  
 855    TaskConstMeta get kCrateApiCreateGroupConstMeta => const TaskConstMeta(
 856      debugName: "create_group",
 857      argNames: ["name", "memberIds"],
 858    );
 859  
 860    @override
 861    HandshakeHandle crateApiCreateHandshakeInitiator({
 862      required List<int> contactId,
 863    }) {
 864      return handler.executeSync(
 865        SyncTask(
 866          callFfi: () {
 867            final serializer = SseSerializer(generalizedFrbRustBinding);
 868            sse_encode_list_prim_u_8_loose(contactId, serializer);
 869            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 14)!;
 870          },
 871          codec: SseCodec(
 872            decodeSuccessData: sse_decode_handshake_handle,
 873            decodeErrorData: sse_decode_String,
 874          ),
 875          constMeta: kCrateApiCreateHandshakeInitiatorConstMeta,
 876          argValues: [contactId],
 877          apiImpl: this,
 878        ),
 879      );
 880    }
 881  
 882    TaskConstMeta get kCrateApiCreateHandshakeInitiatorConstMeta =>
 883        const TaskConstMeta(
 884          debugName: "create_handshake_initiator",
 885          argNames: ["contactId"],
 886        );
 887  
 888    @override
 889    HandshakeHandle crateApiCreateHandshakeInitiatorAnonymous() {
 890      return handler.executeSync(
 891        SyncTask(
 892          callFfi: () {
 893            final serializer = SseSerializer(generalizedFrbRustBinding);
 894            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 15)!;
 895          },
 896          codec: SseCodec(
 897            decodeSuccessData: sse_decode_handshake_handle,
 898            decodeErrorData: sse_decode_String,
 899          ),
 900          constMeta: kCrateApiCreateHandshakeInitiatorAnonymousConstMeta,
 901          argValues: [],
 902          apiImpl: this,
 903        ),
 904      );
 905    }
 906  
 907    TaskConstMeta get kCrateApiCreateHandshakeInitiatorAnonymousConstMeta =>
 908        const TaskConstMeta(
 909          debugName: "create_handshake_initiator_anonymous",
 910          argNames: [],
 911        );
 912  
 913    @override
 914    HandshakeHandle crateApiCreateHandshakeResponder() {
 915      return handler.executeSync(
 916        SyncTask(
 917          callFfi: () {
 918            final serializer = SseSerializer(generalizedFrbRustBinding);
 919            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 16)!;
 920          },
 921          codec: SseCodec(
 922            decodeSuccessData: sse_decode_handshake_handle,
 923            decodeErrorData: sse_decode_String,
 924          ),
 925          constMeta: kCrateApiCreateHandshakeResponderConstMeta,
 926          argValues: [],
 927          apiImpl: this,
 928        ),
 929      );
 930    }
 931  
 932    TaskConstMeta get kCrateApiCreateHandshakeResponderConstMeta =>
 933        const TaskConstMeta(
 934          debugName: "create_handshake_responder",
 935          argNames: [],
 936        );
 937  
 938    @override
 939    IdentityInfo crateApiCreateIdentity() {
 940      return handler.executeSync(
 941        SyncTask(
 942          callFfi: () {
 943            final serializer = SseSerializer(generalizedFrbRustBinding);
 944            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 17)!;
 945          },
 946          codec: SseCodec(
 947            decodeSuccessData: sse_decode_identity_info,
 948            decodeErrorData: sse_decode_String,
 949          ),
 950          constMeta: kCrateApiCreateIdentityConstMeta,
 951          argValues: [],
 952          apiImpl: this,
 953        ),
 954      );
 955    }
 956  
 957    TaskConstMeta get kCrateApiCreateIdentityConstMeta =>
 958        const TaskConstMeta(debugName: "create_identity", argNames: []);
 959  
 960    @override
 961    Future<void> crateApiDeclineGroupInvite({required List<int> groupId}) {
 962      return handler.executeNormal(
 963        NormalTask(
 964          callFfi: (port_) {
 965            final serializer = SseSerializer(generalizedFrbRustBinding);
 966            sse_encode_list_prim_u_8_loose(groupId, serializer);
 967            pdeCallFfi(
 968              generalizedFrbRustBinding,
 969              serializer,
 970              funcId: 18,
 971              port: port_,
 972            );
 973          },
 974          codec: SseCodec(
 975            decodeSuccessData: sse_decode_unit,
 976            decodeErrorData: sse_decode_String,
 977          ),
 978          constMeta: kCrateApiDeclineGroupInviteConstMeta,
 979          argValues: [groupId],
 980          apiImpl: this,
 981        ),
 982      );
 983    }
 984  
 985    TaskConstMeta get kCrateApiDeclineGroupInviteConstMeta => const TaskConstMeta(
 986      debugName: "decline_group_invite",
 987      argNames: ["groupId"],
 988    );
 989  
 990    @override
 991    void crateApiDeleteAllData() {
 992      return handler.executeSync(
 993        SyncTask(
 994          callFfi: () {
 995            final serializer = SseSerializer(generalizedFrbRustBinding);
 996            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 19)!;
 997          },
 998          codec: SseCodec(
 999            decodeSuccessData: sse_decode_unit,
1000            decodeErrorData: sse_decode_String,
1001          ),
1002          constMeta: kCrateApiDeleteAllDataConstMeta,
1003          argValues: [],
1004          apiImpl: this,
1005        ),
1006      );
1007    }
1008  
1009    TaskConstMeta get kCrateApiDeleteAllDataConstMeta =>
1010        const TaskConstMeta(debugName: "delete_all_data", argNames: []);
1011  
1012    @override
1013    void crateApiDeleteContact({required List<int> contactId}) {
1014      return handler.executeSync(
1015        SyncTask(
1016          callFfi: () {
1017            final serializer = SseSerializer(generalizedFrbRustBinding);
1018            sse_encode_list_prim_u_8_loose(contactId, serializer);
1019            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 20)!;
1020          },
1021          codec: SseCodec(
1022            decodeSuccessData: sse_decode_unit,
1023            decodeErrorData: sse_decode_String,
1024          ),
1025          constMeta: kCrateApiDeleteContactConstMeta,
1026          argValues: [contactId],
1027          apiImpl: this,
1028        ),
1029      );
1030    }
1031  
1032    TaskConstMeta get kCrateApiDeleteContactConstMeta =>
1033        const TaskConstMeta(debugName: "delete_contact", argNames: ["contactId"]);
1034  
1035    @override
1036    void crateApiDeleteMessage({required List<int> messageId}) {
1037      return handler.executeSync(
1038        SyncTask(
1039          callFfi: () {
1040            final serializer = SseSerializer(generalizedFrbRustBinding);
1041            sse_encode_list_prim_u_8_loose(messageId, serializer);
1042            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 21)!;
1043          },
1044          codec: SseCodec(
1045            decodeSuccessData: sse_decode_unit,
1046            decodeErrorData: sse_decode_String,
1047          ),
1048          constMeta: kCrateApiDeleteMessageConstMeta,
1049          argValues: [messageId],
1050          apiImpl: this,
1051        ),
1052      );
1053    }
1054  
1055    TaskConstMeta get kCrateApiDeleteMessageConstMeta =>
1056        const TaskConstMeta(debugName: "delete_message", argNames: ["messageId"]);
1057  
1058    @override
1059    Future<DhtStateDto> crateApiDhtStateDtoFromInternal({
1060      required DhtState state,
1061    }) {
1062      return handler.executeNormal(
1063        NormalTask(
1064          callFfi: (port_) {
1065            final serializer = SseSerializer(generalizedFrbRustBinding);
1066            sse_encode_box_autoadd_dht_state(state, serializer);
1067            pdeCallFfi(
1068              generalizedFrbRustBinding,
1069              serializer,
1070              funcId: 22,
1071              port: port_,
1072            );
1073          },
1074          codec: SseCodec(
1075            decodeSuccessData: sse_decode_dht_state_dto,
1076            decodeErrorData: null,
1077          ),
1078          constMeta: kCrateApiDhtStateDtoFromInternalConstMeta,
1079          argValues: [state],
1080          apiImpl: this,
1081        ),
1082      );
1083    }
1084  
1085    TaskConstMeta get kCrateApiDhtStateDtoFromInternalConstMeta =>
1086        const TaskConstMeta(
1087          debugName: "dht_state_dto_from_internal",
1088          argNames: ["state"],
1089        );
1090  
1091    @override
1092    Future<void> crateApiDisconnectDht() {
1093      return handler.executeNormal(
1094        NormalTask(
1095          callFfi: (port_) {
1096            final serializer = SseSerializer(generalizedFrbRustBinding);
1097            pdeCallFfi(
1098              generalizedFrbRustBinding,
1099              serializer,
1100              funcId: 23,
1101              port: port_,
1102            );
1103          },
1104          codec: SseCodec(
1105            decodeSuccessData: sse_decode_unit,
1106            decodeErrorData: sse_decode_String,
1107          ),
1108          constMeta: kCrateApiDisconnectDhtConstMeta,
1109          argValues: [],
1110          apiImpl: this,
1111        ),
1112      );
1113    }
1114  
1115    TaskConstMeta get kCrateApiDisconnectDhtConstMeta =>
1116        const TaskConstMeta(debugName: "disconnect_dht", argNames: []);
1117  
1118    @override
1119    void crateApiDisconnectRelay() {
1120      return handler.executeSync(
1121        SyncTask(
1122          callFfi: () {
1123            final serializer = SseSerializer(generalizedFrbRustBinding);
1124            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 24)!;
1125          },
1126          codec: SseCodec(
1127            decodeSuccessData: sse_decode_unit,
1128            decodeErrorData: sse_decode_String,
1129          ),
1130          constMeta: kCrateApiDisconnectRelayConstMeta,
1131          argValues: [],
1132          apiImpl: this,
1133        ),
1134      );
1135    }
1136  
1137    TaskConstMeta get kCrateApiDisconnectRelayConstMeta =>
1138        const TaskConstMeta(debugName: "disconnect_relay", argNames: []);
1139  
1140    @override
1141    int crateApiEnforceForwardingLimit() {
1142      return handler.executeSync(
1143        SyncTask(
1144          callFfi: () {
1145            final serializer = SseSerializer(generalizedFrbRustBinding);
1146            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 25)!;
1147          },
1148          codec: SseCodec(
1149            decodeSuccessData: sse_decode_u_32,
1150            decodeErrorData: sse_decode_String,
1151          ),
1152          constMeta: kCrateApiEnforceForwardingLimitConstMeta,
1153          argValues: [],
1154          apiImpl: this,
1155        ),
1156      );
1157    }
1158  
1159    TaskConstMeta get kCrateApiEnforceForwardingLimitConstMeta =>
1160        const TaskConstMeta(debugName: "enforce_forwarding_limit", argNames: []);
1161  
1162    @override
1163    void crateApiExchangeCancel({required ExchangeHandle handle}) {
1164      return handler.executeSync(
1165        SyncTask(
1166          callFfi: () {
1167            final serializer = SseSerializer(generalizedFrbRustBinding);
1168            sse_encode_box_autoadd_exchange_handle(handle, serializer);
1169            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 26)!;
1170          },
1171          codec: SseCodec(
1172            decodeSuccessData: sse_decode_unit,
1173            decodeErrorData: sse_decode_String,
1174          ),
1175          constMeta: kCrateApiExchangeCancelConstMeta,
1176          argValues: [handle],
1177          apiImpl: this,
1178        ),
1179      );
1180    }
1181  
1182    TaskConstMeta get kCrateApiExchangeCancelConstMeta =>
1183        const TaskConstMeta(debugName: "exchange_cancel", argNames: ["handle"]);
1184  
1185    @override
1186    ExchangeComplete crateApiExchangeFinalize({required ExchangeHandle handle}) {
1187      return handler.executeSync(
1188        SyncTask(
1189          callFfi: () {
1190            final serializer = SseSerializer(generalizedFrbRustBinding);
1191            sse_encode_box_autoadd_exchange_handle(handle, serializer);
1192            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 27)!;
1193          },
1194          codec: SseCodec(
1195            decodeSuccessData: sse_decode_exchange_complete,
1196            decodeErrorData: sse_decode_String,
1197          ),
1198          constMeta: kCrateApiExchangeFinalizeConstMeta,
1199          argValues: [handle],
1200          apiImpl: this,
1201        ),
1202      );
1203    }
1204  
1205    TaskConstMeta get kCrateApiExchangeFinalizeConstMeta =>
1206        const TaskConstMeta(debugName: "exchange_finalize", argNames: ["handle"]);
1207  
1208    @override
1209    (ExchangeComplete, GossipExchangeHandle) crateApiExchangeFinalizeForGossip({
1210      required ExchangeHandle handle,
1211    }) {
1212      return handler.executeSync(
1213        SyncTask(
1214          callFfi: () {
1215            final serializer = SseSerializer(generalizedFrbRustBinding);
1216            sse_encode_box_autoadd_exchange_handle(handle, serializer);
1217            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 28)!;
1218          },
1219          codec: SseCodec(
1220            decodeSuccessData:
1221                sse_decode_record_exchange_complete_gossip_exchange_handle,
1222            decodeErrorData: sse_decode_String,
1223          ),
1224          constMeta: kCrateApiExchangeFinalizeForGossipConstMeta,
1225          argValues: [handle],
1226          apiImpl: this,
1227        ),
1228      );
1229    }
1230  
1231    TaskConstMeta get kCrateApiExchangeFinalizeForGossipConstMeta =>
1232        const TaskConstMeta(
1233          debugName: "exchange_finalize_for_gossip",
1234          argNames: ["handle"],
1235        );
1236  
1237    @override
1238    ExchangeResultDto crateApiExchangeReceive({
1239      required ExchangeHandle handle,
1240      required List<int> data,
1241    }) {
1242      return handler.executeSync(
1243        SyncTask(
1244          callFfi: () {
1245            final serializer = SseSerializer(generalizedFrbRustBinding);
1246            sse_encode_box_autoadd_exchange_handle(handle, serializer);
1247            sse_encode_list_prim_u_8_loose(data, serializer);
1248            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 29)!;
1249          },
1250          codec: SseCodec(
1251            decodeSuccessData: sse_decode_exchange_result_dto,
1252            decodeErrorData: sse_decode_String,
1253          ),
1254          constMeta: kCrateApiExchangeReceiveConstMeta,
1255          argValues: [handle, data],
1256          apiImpl: this,
1257        ),
1258      );
1259    }
1260  
1261    TaskConstMeta get kCrateApiExchangeReceiveConstMeta => const TaskConstMeta(
1262      debugName: "exchange_receive",
1263      argNames: ["handle", "data"],
1264    );
1265  
1266    @override
1267    Uint8List? crateApiExchangeSend({required ExchangeHandle handle}) {
1268      return handler.executeSync(
1269        SyncTask(
1270          callFfi: () {
1271            final serializer = SseSerializer(generalizedFrbRustBinding);
1272            sse_encode_box_autoadd_exchange_handle(handle, serializer);
1273            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 30)!;
1274          },
1275          codec: SseCodec(
1276            decodeSuccessData: sse_decode_opt_list_prim_u_8_strict,
1277            decodeErrorData: sse_decode_String,
1278          ),
1279          constMeta: kCrateApiExchangeSendConstMeta,
1280          argValues: [handle],
1281          apiImpl: this,
1282        ),
1283      );
1284    }
1285  
1286    TaskConstMeta get kCrateApiExchangeSendConstMeta =>
1287        const TaskConstMeta(debugName: "exchange_send", argNames: ["handle"]);
1288  
1289    @override
1290    int crateApiExpirePendingRelay({required PlatformInt64 maxAgeSecs}) {
1291      return handler.executeSync(
1292        SyncTask(
1293          callFfi: () {
1294            final serializer = SseSerializer(generalizedFrbRustBinding);
1295            sse_encode_i_64(maxAgeSecs, serializer);
1296            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 31)!;
1297          },
1298          codec: SseCodec(
1299            decodeSuccessData: sse_decode_i_32,
1300            decodeErrorData: null,
1301          ),
1302          constMeta: kCrateApiExpirePendingRelayConstMeta,
1303          argValues: [maxAgeSecs],
1304          apiImpl: this,
1305        ),
1306      );
1307    }
1308  
1309    TaskConstMeta get kCrateApiExpirePendingRelayConstMeta => const TaskConstMeta(
1310      debugName: "expire_pending_relay",
1311      argNames: ["maxAgeSecs"],
1312    );
1313  
1314    @override
1315    int crateApiExpireStaleMessages({required PlatformInt64 maxAgeSecs}) {
1316      return handler.executeSync(
1317        SyncTask(
1318          callFfi: () {
1319            final serializer = SseSerializer(generalizedFrbRustBinding);
1320            sse_encode_i_64(maxAgeSecs, serializer);
1321            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 32)!;
1322          },
1323          codec: SseCodec(
1324            decodeSuccessData: sse_decode_i_32,
1325            decodeErrorData: null,
1326          ),
1327          constMeta: kCrateApiExpireStaleMessagesConstMeta,
1328          argValues: [maxAgeSecs],
1329          apiImpl: this,
1330        ),
1331      );
1332    }
1333  
1334    TaskConstMeta get kCrateApiExpireStaleMessagesConstMeta =>
1335        const TaskConstMeta(
1336          debugName: "expire_stale_messages",
1337          argNames: ["maxAgeSecs"],
1338        );
1339  
1340    @override
1341    Future<String?> crateApiFetchContactIrohEndpointId({
1342      required List<int> contactId,
1343    }) {
1344      return handler.executeNormal(
1345        NormalTask(
1346          callFfi: (port_) {
1347            final serializer = SseSerializer(generalizedFrbRustBinding);
1348            sse_encode_list_prim_u_8_loose(contactId, serializer);
1349            pdeCallFfi(
1350              generalizedFrbRustBinding,
1351              serializer,
1352              funcId: 33,
1353              port: port_,
1354            );
1355          },
1356          codec: SseCodec(
1357            decodeSuccessData: sse_decode_opt_String,
1358            decodeErrorData: sse_decode_String,
1359          ),
1360          constMeta: kCrateApiFetchContactIrohEndpointIdConstMeta,
1361          argValues: [contactId],
1362          apiImpl: this,
1363        ),
1364      );
1365    }
1366  
1367    TaskConstMeta get kCrateApiFetchContactIrohEndpointIdConstMeta =>
1368        const TaskConstMeta(
1369          debugName: "fetch_contact_iroh_endpoint_id",
1370          argNames: ["contactId"],
1371        );
1372  
1373    @override
1374    Future<String?> crateApiFetchContactOnionAddress({
1375      required List<int> contactId,
1376    }) {
1377      return handler.executeNormal(
1378        NormalTask(
1379          callFfi: (port_) {
1380            final serializer = SseSerializer(generalizedFrbRustBinding);
1381            sse_encode_list_prim_u_8_loose(contactId, serializer);
1382            pdeCallFfi(
1383              generalizedFrbRustBinding,
1384              serializer,
1385              funcId: 34,
1386              port: port_,
1387            );
1388          },
1389          codec: SseCodec(
1390            decodeSuccessData: sse_decode_opt_String,
1391            decodeErrorData: sse_decode_String,
1392          ),
1393          constMeta: kCrateApiFetchContactOnionAddressConstMeta,
1394          argValues: [contactId],
1395          apiImpl: this,
1396        ),
1397      );
1398    }
1399  
1400    TaskConstMeta get kCrateApiFetchContactOnionAddressConstMeta =>
1401        const TaskConstMeta(
1402          debugName: "fetch_contact_onion_address",
1403          argNames: ["contactId"],
1404        );
1405  
1406    @override
1407    Future<DhtFetchResult> crateApiFetchMessagesFromDht() {
1408      return handler.executeNormal(
1409        NormalTask(
1410          callFfi: (port_) {
1411            final serializer = SseSerializer(generalizedFrbRustBinding);
1412            pdeCallFfi(
1413              generalizedFrbRustBinding,
1414              serializer,
1415              funcId: 35,
1416              port: port_,
1417            );
1418          },
1419          codec: SseCodec(
1420            decodeSuccessData: sse_decode_dht_fetch_result,
1421            decodeErrorData: sse_decode_String,
1422          ),
1423          constMeta: kCrateApiFetchMessagesFromDhtConstMeta,
1424          argValues: [],
1425          apiImpl: this,
1426        ),
1427      );
1428    }
1429  
1430    TaskConstMeta get kCrateApiFetchMessagesFromDhtConstMeta =>
1431        const TaskConstMeta(debugName: "fetch_messages_from_dht", argNames: []);
1432  
1433    @override
1434    Uint8List crateApiGenerateGossipDigest() {
1435      return handler.executeSync(
1436        SyncTask(
1437          callFfi: () {
1438            final serializer = SseSerializer(generalizedFrbRustBinding);
1439            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 36)!;
1440          },
1441          codec: SseCodec(
1442            decodeSuccessData: sse_decode_list_prim_u_8_strict,
1443            decodeErrorData: sse_decode_String,
1444          ),
1445          constMeta: kCrateApiGenerateGossipDigestConstMeta,
1446          argValues: [],
1447          apiImpl: this,
1448        ),
1449      );
1450    }
1451  
1452    TaskConstMeta get kCrateApiGenerateGossipDigestConstMeta =>
1453        const TaskConstMeta(debugName: "generate_gossip_digest", argNames: []);
1454  
1455    @override
1456    String crateApiGenerateQrPayload() {
1457      return handler.executeSync(
1458        SyncTask(
1459          callFfi: () {
1460            final serializer = SseSerializer(generalizedFrbRustBinding);
1461            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 37)!;
1462          },
1463          codec: SseCodec(
1464            decodeSuccessData: sse_decode_String,
1465            decodeErrorData: sse_decode_String,
1466          ),
1467          constMeta: kCrateApiGenerateQrPayloadConstMeta,
1468          argValues: [],
1469          apiImpl: this,
1470        ),
1471      );
1472    }
1473  
1474    TaskConstMeta get kCrateApiGenerateQrPayloadConstMeta =>
1475        const TaskConstMeta(debugName: "generate_qr_payload", argNames: []);
1476  
1477    @override
1478    List<AchievementInfo> crateApiGetAchievements() {
1479      return handler.executeSync(
1480        SyncTask(
1481          callFfi: () {
1482            final serializer = SseSerializer(generalizedFrbRustBinding);
1483            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 38)!;
1484          },
1485          codec: SseCodec(
1486            decodeSuccessData: sse_decode_list_achievement_info,
1487            decodeErrorData: sse_decode_String,
1488          ),
1489          constMeta: kCrateApiGetAchievementsConstMeta,
1490          argValues: [],
1491          apiImpl: this,
1492        ),
1493      );
1494    }
1495  
1496    TaskConstMeta get kCrateApiGetAchievementsConstMeta =>
1497        const TaskConstMeta(debugName: "get_achievements", argNames: []);
1498  
1499    @override
1500    List<TransportInfoDto> crateApiGetAvailableTransports() {
1501      return handler.executeSync(
1502        SyncTask(
1503          callFfi: () {
1504            final serializer = SseSerializer(generalizedFrbRustBinding);
1505            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 39)!;
1506          },
1507          codec: SseCodec(
1508            decodeSuccessData: sse_decode_list_transport_info_dto,
1509            decodeErrorData: null,
1510          ),
1511          constMeta: kCrateApiGetAvailableTransportsConstMeta,
1512          argValues: [],
1513          apiImpl: this,
1514        ),
1515      );
1516    }
1517  
1518    TaskConstMeta get kCrateApiGetAvailableTransportsConstMeta =>
1519        const TaskConstMeta(debugName: "get_available_transports", argNames: []);
1520  
1521    @override
1522    Future<List<CachedIrohEndpoint>> crateApiGetCachedIrohEndpointIds() {
1523      return handler.executeNormal(
1524        NormalTask(
1525          callFfi: (port_) {
1526            final serializer = SseSerializer(generalizedFrbRustBinding);
1527            pdeCallFfi(
1528              generalizedFrbRustBinding,
1529              serializer,
1530              funcId: 40,
1531              port: port_,
1532            );
1533          },
1534          codec: SseCodec(
1535            decodeSuccessData: sse_decode_list_cached_iroh_endpoint,
1536            decodeErrorData: sse_decode_String,
1537          ),
1538          constMeta: kCrateApiGetCachedIrohEndpointIdsConstMeta,
1539          argValues: [],
1540          apiImpl: this,
1541        ),
1542      );
1543    }
1544  
1545    TaskConstMeta get kCrateApiGetCachedIrohEndpointIdsConstMeta =>
1546        const TaskConstMeta(
1547          debugName: "get_cached_iroh_endpoint_ids",
1548          argNames: [],
1549        );
1550  
1551    @override
1552    Future<List<CachedOnionAddress>> crateApiGetCachedOnionAddresses() {
1553      return handler.executeNormal(
1554        NormalTask(
1555          callFfi: (port_) {
1556            final serializer = SseSerializer(generalizedFrbRustBinding);
1557            pdeCallFfi(
1558              generalizedFrbRustBinding,
1559              serializer,
1560              funcId: 41,
1561              port: port_,
1562            );
1563          },
1564          codec: SseCodec(
1565            decodeSuccessData: sse_decode_list_cached_onion_address,
1566            decodeErrorData: sse_decode_String,
1567          ),
1568          constMeta: kCrateApiGetCachedOnionAddressesConstMeta,
1569          argValues: [],
1570          apiImpl: this,
1571        ),
1572      );
1573    }
1574  
1575    TaskConstMeta get kCrateApiGetCachedOnionAddressesConstMeta =>
1576        const TaskConstMeta(
1577          debugName: "get_cached_onion_addresses",
1578          argNames: [],
1579        );
1580  
1581    @override
1582    ContactInfo crateApiGetContact({required List<int> contactId}) {
1583      return handler.executeSync(
1584        SyncTask(
1585          callFfi: () {
1586            final serializer = SseSerializer(generalizedFrbRustBinding);
1587            sse_encode_list_prim_u_8_loose(contactId, serializer);
1588            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 42)!;
1589          },
1590          codec: SseCodec(
1591            decodeSuccessData: sse_decode_contact_info,
1592            decodeErrorData: sse_decode_String,
1593          ),
1594          constMeta: kCrateApiGetContactConstMeta,
1595          argValues: [contactId],
1596          apiImpl: this,
1597        ),
1598      );
1599    }
1600  
1601    TaskConstMeta get kCrateApiGetContactConstMeta =>
1602        const TaskConstMeta(debugName: "get_contact", argNames: ["contactId"]);
1603  
1604    @override
1605    Future<Uint8List?> crateApiGetContactIdByIdentityKey({
1606      required List<int> identityKey,
1607    }) {
1608      return handler.executeNormal(
1609        NormalTask(
1610          callFfi: (port_) {
1611            final serializer = SseSerializer(generalizedFrbRustBinding);
1612            sse_encode_list_prim_u_8_loose(identityKey, serializer);
1613            pdeCallFfi(
1614              generalizedFrbRustBinding,
1615              serializer,
1616              funcId: 43,
1617              port: port_,
1618            );
1619          },
1620          codec: SseCodec(
1621            decodeSuccessData: sse_decode_opt_list_prim_u_8_strict,
1622            decodeErrorData: sse_decode_String,
1623          ),
1624          constMeta: kCrateApiGetContactIdByIdentityKeyConstMeta,
1625          argValues: [identityKey],
1626          apiImpl: this,
1627        ),
1628      );
1629    }
1630  
1631    TaskConstMeta get kCrateApiGetContactIdByIdentityKeyConstMeta =>
1632        const TaskConstMeta(
1633          debugName: "get_contact_id_by_identity_key",
1634          argNames: ["identityKey"],
1635        );
1636  
1637    @override
1638    Uint8List crateApiGetContactIdentityKey({required List<int> contactId}) {
1639      return handler.executeSync(
1640        SyncTask(
1641          callFfi: () {
1642            final serializer = SseSerializer(generalizedFrbRustBinding);
1643            sse_encode_list_prim_u_8_loose(contactId, serializer);
1644            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 44)!;
1645          },
1646          codec: SseCodec(
1647            decodeSuccessData: sse_decode_list_prim_u_8_strict,
1648            decodeErrorData: sse_decode_String,
1649          ),
1650          constMeta: kCrateApiGetContactIdentityKeyConstMeta,
1651          argValues: [contactId],
1652          apiImpl: this,
1653        ),
1654      );
1655    }
1656  
1657    TaskConstMeta get kCrateApiGetContactIdentityKeyConstMeta =>
1658        const TaskConstMeta(
1659          debugName: "get_contact_identity_key",
1660          argNames: ["contactId"],
1661        );
1662  
1663    @override
1664    bool crateApiGetContactMuted({required List<int> contactId}) {
1665      return handler.executeSync(
1666        SyncTask(
1667          callFfi: () {
1668            final serializer = SseSerializer(generalizedFrbRustBinding);
1669            sse_encode_list_prim_u_8_loose(contactId, serializer);
1670            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 45)!;
1671          },
1672          codec: SseCodec(
1673            decodeSuccessData: sse_decode_bool,
1674            decodeErrorData: sse_decode_String,
1675          ),
1676          constMeta: kCrateApiGetContactMutedConstMeta,
1677          argValues: [contactId],
1678          apiImpl: this,
1679        ),
1680      );
1681    }
1682  
1683    TaskConstMeta get kCrateApiGetContactMutedConstMeta => const TaskConstMeta(
1684      debugName: "get_contact_muted",
1685      argNames: ["contactId"],
1686    );
1687  
1688    @override
1689    List<MessageInfo> crateApiGetConversation({required List<int> contactId}) {
1690      return handler.executeSync(
1691        SyncTask(
1692          callFfi: () {
1693            final serializer = SseSerializer(generalizedFrbRustBinding);
1694            sse_encode_list_prim_u_8_loose(contactId, serializer);
1695            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 46)!;
1696          },
1697          codec: SseCodec(
1698            decodeSuccessData: sse_decode_list_message_info,
1699            decodeErrorData: sse_decode_String,
1700          ),
1701          constMeta: kCrateApiGetConversationConstMeta,
1702          argValues: [contactId],
1703          apiImpl: this,
1704        ),
1705      );
1706    }
1707  
1708    TaskConstMeta get kCrateApiGetConversationConstMeta => const TaskConstMeta(
1709      debugName: "get_conversation",
1710      argNames: ["contactId"],
1711    );
1712  
1713    @override
1714    DhtStateDto crateApiGetDhtState() {
1715      return handler.executeSync(
1716        SyncTask(
1717          callFfi: () {
1718            final serializer = SseSerializer(generalizedFrbRustBinding);
1719            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 47)!;
1720          },
1721          codec: SseCodec(
1722            decodeSuccessData: sse_decode_dht_state_dto,
1723            decodeErrorData: null,
1724          ),
1725          constMeta: kCrateApiGetDhtStateConstMeta,
1726          argValues: [],
1727          apiImpl: this,
1728        ),
1729      );
1730    }
1731  
1732    TaskConstMeta get kCrateApiGetDhtStateConstMeta =>
1733        const TaskConstMeta(debugName: "get_dht_state", argNames: []);
1734  
1735    @override
1736    BigInt crateApiGetDisappearingDuration({required List<int> contactId}) {
1737      return handler.executeSync(
1738        SyncTask(
1739          callFfi: () {
1740            final serializer = SseSerializer(generalizedFrbRustBinding);
1741            sse_encode_list_prim_u_8_loose(contactId, serializer);
1742            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 48)!;
1743          },
1744          codec: SseCodec(
1745            decodeSuccessData: sse_decode_u_64,
1746            decodeErrorData: sse_decode_String,
1747          ),
1748          constMeta: kCrateApiGetDisappearingDurationConstMeta,
1749          argValues: [contactId],
1750          apiImpl: this,
1751        ),
1752      );
1753    }
1754  
1755    TaskConstMeta get kCrateApiGetDisappearingDurationConstMeta =>
1756        const TaskConstMeta(
1757          debugName: "get_disappearing_duration",
1758          argNames: ["contactId"],
1759        );
1760  
1761    @override
1762    (String, BigInt)? crateApiGetDocumentInfo({required List<int> documentId}) {
1763      return handler.executeSync(
1764        SyncTask(
1765          callFfi: () {
1766            final serializer = SseSerializer(generalizedFrbRustBinding);
1767            sse_encode_list_prim_u_8_loose(documentId, serializer);
1768            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 49)!;
1769          },
1770          codec: SseCodec(
1771            decodeSuccessData: sse_decode_opt_box_autoadd_record_string_u_64,
1772            decodeErrorData: sse_decode_String,
1773          ),
1774          constMeta: kCrateApiGetDocumentInfoConstMeta,
1775          argValues: [documentId],
1776          apiImpl: this,
1777        ),
1778      );
1779    }
1780  
1781    TaskConstMeta get kCrateApiGetDocumentInfoConstMeta => const TaskConstMeta(
1782      debugName: "get_document_info",
1783      argNames: ["documentId"],
1784    );
1785  
1786    @override
1787    ForwardingInfo crateApiGetForwardingStats() {
1788      return handler.executeSync(
1789        SyncTask(
1790          callFfi: () {
1791            final serializer = SseSerializer(generalizedFrbRustBinding);
1792            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 50)!;
1793          },
1794          codec: SseCodec(
1795            decodeSuccessData: sse_decode_forwarding_info,
1796            decodeErrorData: sse_decode_String,
1797          ),
1798          constMeta: kCrateApiGetForwardingStatsConstMeta,
1799          argValues: [],
1800          apiImpl: this,
1801        ),
1802      );
1803    }
1804  
1805    TaskConstMeta get kCrateApiGetForwardingStatsConstMeta =>
1806        const TaskConstMeta(debugName: "get_forwarding_stats", argNames: []);
1807  
1808    @override
1809    List<MessageInfo> crateApiGetGroupConversation({required List<int> groupId}) {
1810      return handler.executeSync(
1811        SyncTask(
1812          callFfi: () {
1813            final serializer = SseSerializer(generalizedFrbRustBinding);
1814            sse_encode_list_prim_u_8_loose(groupId, serializer);
1815            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 51)!;
1816          },
1817          codec: SseCodec(
1818            decodeSuccessData: sse_decode_list_message_info,
1819            decodeErrorData: sse_decode_String,
1820          ),
1821          constMeta: kCrateApiGetGroupConversationConstMeta,
1822          argValues: [groupId],
1823          apiImpl: this,
1824        ),
1825      );
1826    }
1827  
1828    TaskConstMeta get kCrateApiGetGroupConversationConstMeta =>
1829        const TaskConstMeta(
1830          debugName: "get_group_conversation",
1831          argNames: ["groupId"],
1832        );
1833  
1834    @override
1835    List<GroupMemberInfoDto> crateApiGetGroupMembers({
1836      required List<int> groupId,
1837    }) {
1838      return handler.executeSync(
1839        SyncTask(
1840          callFfi: () {
1841            final serializer = SseSerializer(generalizedFrbRustBinding);
1842            sse_encode_list_prim_u_8_loose(groupId, serializer);
1843            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 52)!;
1844          },
1845          codec: SseCodec(
1846            decodeSuccessData: sse_decode_list_group_member_info_dto,
1847            decodeErrorData: sse_decode_String,
1848          ),
1849          constMeta: kCrateApiGetGroupMembersConstMeta,
1850          argValues: [groupId],
1851          apiImpl: this,
1852        ),
1853      );
1854    }
1855  
1856    TaskConstMeta get kCrateApiGetGroupMembersConstMeta => const TaskConstMeta(
1857      debugName: "get_group_members",
1858      argNames: ["groupId"],
1859    );
1860  
1861    @override
1862    IdentityInfo crateApiGetIdentity() {
1863      return handler.executeSync(
1864        SyncTask(
1865          callFfi: () {
1866            final serializer = SseSerializer(generalizedFrbRustBinding);
1867            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 53)!;
1868          },
1869          codec: SseCodec(
1870            decodeSuccessData: sse_decode_identity_info,
1871            decodeErrorData: sse_decode_String,
1872          ),
1873          constMeta: kCrateApiGetIdentityConstMeta,
1874          argValues: [],
1875          apiImpl: this,
1876        ),
1877      );
1878    }
1879  
1880    TaskConstMeta get kCrateApiGetIdentityConstMeta =>
1881        const TaskConstMeta(debugName: "get_identity", argNames: []);
1882  
1883    @override
1884    IrohStateDto crateApiGetIrohState() {
1885      return handler.executeSync(
1886        SyncTask(
1887          callFfi: () {
1888            final serializer = SseSerializer(generalizedFrbRustBinding);
1889            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 54)!;
1890          },
1891          codec: SseCodec(
1892            decodeSuccessData: sse_decode_iroh_state_dto,
1893            decodeErrorData: null,
1894          ),
1895          constMeta: kCrateApiGetIrohStateConstMeta,
1896          argValues: [],
1897          apiImpl: this,
1898        ),
1899      );
1900    }
1901  
1902    TaskConstMeta get kCrateApiGetIrohStateConstMeta =>
1903        const TaskConstMeta(debugName: "get_iroh_state", argNames: []);
1904  
1905    @override
1906    List<MessageInfo> crateApiGetMessages({required List<int> contactId}) {
1907      return handler.executeSync(
1908        SyncTask(
1909          callFfi: () {
1910            final serializer = SseSerializer(generalizedFrbRustBinding);
1911            sse_encode_list_prim_u_8_loose(contactId, serializer);
1912            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 55)!;
1913          },
1914          codec: SseCodec(
1915            decodeSuccessData: sse_decode_list_message_info,
1916            decodeErrorData: sse_decode_String,
1917          ),
1918          constMeta: kCrateApiGetMessagesConstMeta,
1919          argValues: [contactId],
1920          apiImpl: this,
1921        ),
1922      );
1923    }
1924  
1925    TaskConstMeta get kCrateApiGetMessagesConstMeta =>
1926        const TaskConstMeta(debugName: "get_messages", argNames: ["contactId"]);
1927  
1928    @override
1929    List<Uint8List> crateApiGetMyRotatingIds() {
1930      return handler.executeSync(
1931        SyncTask(
1932          callFfi: () {
1933            final serializer = SseSerializer(generalizedFrbRustBinding);
1934            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 56)!;
1935          },
1936          codec: SseCodec(
1937            decodeSuccessData: sse_decode_list_list_prim_u_8_strict,
1938            decodeErrorData: sse_decode_String,
1939          ),
1940          constMeta: kCrateApiGetMyRotatingIdsConstMeta,
1941          argValues: [],
1942          apiImpl: this,
1943        ),
1944      );
1945    }
1946  
1947    TaskConstMeta get kCrateApiGetMyRotatingIdsConstMeta =>
1948        const TaskConstMeta(debugName: "get_my_rotating_ids", argNames: []);
1949  
1950    @override
1951    List<MessageInfo> crateApiGetOutboundQueue({required List<int> contactId}) {
1952      return handler.executeSync(
1953        SyncTask(
1954          callFfi: () {
1955            final serializer = SseSerializer(generalizedFrbRustBinding);
1956            sse_encode_list_prim_u_8_loose(contactId, serializer);
1957            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 57)!;
1958          },
1959          codec: SseCodec(
1960            decodeSuccessData: sse_decode_list_message_info,
1961            decodeErrorData: sse_decode_String,
1962          ),
1963          constMeta: kCrateApiGetOutboundQueueConstMeta,
1964          argValues: [contactId],
1965          apiImpl: this,
1966        ),
1967      );
1968    }
1969  
1970    TaskConstMeta get kCrateApiGetOutboundQueueConstMeta => const TaskConstMeta(
1971      debugName: "get_outbound_queue",
1972      argNames: ["contactId"],
1973    );
1974  
1975    @override
1976    Future<List<EncryptedPayload>> crateApiGetQueuedEncrypted({
1977      required List<int> contactId,
1978    }) {
1979      return handler.executeNormal(
1980        NormalTask(
1981          callFfi: (port_) {
1982            final serializer = SseSerializer(generalizedFrbRustBinding);
1983            sse_encode_list_prim_u_8_loose(contactId, serializer);
1984            pdeCallFfi(
1985              generalizedFrbRustBinding,
1986              serializer,
1987              funcId: 58,
1988              port: port_,
1989            );
1990          },
1991          codec: SseCodec(
1992            decodeSuccessData: sse_decode_list_encrypted_payload,
1993            decodeErrorData: sse_decode_String,
1994          ),
1995          constMeta: kCrateApiGetQueuedEncryptedConstMeta,
1996          argValues: [contactId],
1997          apiImpl: this,
1998        ),
1999      );
2000    }
2001  
2002    TaskConstMeta get kCrateApiGetQueuedEncryptedConstMeta => const TaskConstMeta(
2003      debugName: "get_queued_encrypted",
2004      argNames: ["contactId"],
2005    );
2006  
2007    @override
2008    (int, int)? crateApiGetReceiveProgress({required List<int> documentId}) {
2009      return handler.executeSync(
2010        SyncTask(
2011          callFfi: () {
2012            final serializer = SseSerializer(generalizedFrbRustBinding);
2013            sse_encode_list_prim_u_8_loose(documentId, serializer);
2014            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 59)!;
2015          },
2016          codec: SseCodec(
2017            decodeSuccessData: sse_decode_opt_box_autoadd_record_u_32_u_32,
2018            decodeErrorData: sse_decode_String,
2019          ),
2020          constMeta: kCrateApiGetReceiveProgressConstMeta,
2021          argValues: [documentId],
2022          apiImpl: this,
2023        ),
2024      );
2025    }
2026  
2027    TaskConstMeta get kCrateApiGetReceiveProgressConstMeta => const TaskConstMeta(
2028      debugName: "get_receive_progress",
2029      argNames: ["documentId"],
2030    );
2031  
2032    @override
2033    RelayStateDto crateApiGetRelayState() {
2034      return handler.executeSync(
2035        SyncTask(
2036          callFfi: () {
2037            final serializer = SseSerializer(generalizedFrbRustBinding);
2038            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 60)!;
2039          },
2040          codec: SseCodec(
2041            decodeSuccessData: sse_decode_relay_state_dto,
2042            decodeErrorData: null,
2043          ),
2044          constMeta: kCrateApiGetRelayStateConstMeta,
2045          argValues: [],
2046          apiImpl: this,
2047        ),
2048      );
2049    }
2050  
2051    TaskConstMeta get kCrateApiGetRelayStateConstMeta =>
2052        const TaskConstMeta(debugName: "get_relay_state", argNames: []);
2053  
2054    @override
2055    ReputationInfo crateApiGetReputation() {
2056      return handler.executeSync(
2057        SyncTask(
2058          callFfi: () {
2059            final serializer = SseSerializer(generalizedFrbRustBinding);
2060            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 61)!;
2061          },
2062          codec: SseCodec(
2063            decodeSuccessData: sse_decode_reputation_info,
2064            decodeErrorData: sse_decode_String,
2065          ),
2066          constMeta: kCrateApiGetReputationConstMeta,
2067          argValues: [],
2068          apiImpl: this,
2069        ),
2070      );
2071    }
2072  
2073    TaskConstMeta get kCrateApiGetReputationConstMeta =>
2074        const TaskConstMeta(debugName: "get_reputation", argNames: []);
2075  
2076    @override
2077    (int, int)? crateApiGetSendProgress({required List<int> documentId}) {
2078      return handler.executeSync(
2079        SyncTask(
2080          callFfi: () {
2081            final serializer = SseSerializer(generalizedFrbRustBinding);
2082            sse_encode_list_prim_u_8_loose(documentId, serializer);
2083            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 62)!;
2084          },
2085          codec: SseCodec(
2086            decodeSuccessData: sse_decode_opt_box_autoadd_record_u_32_u_32,
2087            decodeErrorData: sse_decode_String,
2088          ),
2089          constMeta: kCrateApiGetSendProgressConstMeta,
2090          argValues: [documentId],
2091          apiImpl: this,
2092        ),
2093      );
2094    }
2095  
2096    TaskConstMeta get kCrateApiGetSendProgressConstMeta => const TaskConstMeta(
2097      debugName: "get_send_progress",
2098      argNames: ["documentId"],
2099    );
2100  
2101    @override
2102    String crateApiGetStatistics() {
2103      return handler.executeSync(
2104        SyncTask(
2105          callFfi: () {
2106            final serializer = SseSerializer(generalizedFrbRustBinding);
2107            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 63)!;
2108          },
2109          codec: SseCodec(
2110            decodeSuccessData: sse_decode_String,
2111            decodeErrorData: sse_decode_String,
2112          ),
2113          constMeta: kCrateApiGetStatisticsConstMeta,
2114          argValues: [],
2115          apiImpl: this,
2116        ),
2117      );
2118    }
2119  
2120    TaskConstMeta get kCrateApiGetStatisticsConstMeta =>
2121        const TaskConstMeta(debugName: "get_statistics", argNames: []);
2122  
2123    @override
2124    String crateApiGetTransportName({required TransportTypeDto transportType}) {
2125      return handler.executeSync(
2126        SyncTask(
2127          callFfi: () {
2128            final serializer = SseSerializer(generalizedFrbRustBinding);
2129            sse_encode_transport_type_dto(transportType, serializer);
2130            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 64)!;
2131          },
2132          codec: SseCodec(
2133            decodeSuccessData: sse_decode_String,
2134            decodeErrorData: null,
2135          ),
2136          constMeta: kCrateApiGetTransportNameConstMeta,
2137          argValues: [transportType],
2138          apiImpl: this,
2139        ),
2140      );
2141    }
2142  
2143    TaskConstMeta get kCrateApiGetTransportNameConstMeta => const TaskConstMeta(
2144      debugName: "get_transport_name",
2145      argNames: ["transportType"],
2146    );
2147  
2148    @override
2149    NetworkTransportPreference crateApiGetTransportPreferenceValue() {
2150      return handler.executeSync(
2151        SyncTask(
2152          callFfi: () {
2153            final serializer = SseSerializer(generalizedFrbRustBinding);
2154            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 65)!;
2155          },
2156          codec: SseCodec(
2157            decodeSuccessData: sse_decode_network_transport_preference,
2158            decodeErrorData: null,
2159          ),
2160          constMeta: kCrateApiGetTransportPreferenceValueConstMeta,
2161          argValues: [],
2162          apiImpl: this,
2163        ),
2164      );
2165    }
2166  
2167    TaskConstMeta get kCrateApiGetTransportPreferenceValueConstMeta =>
2168        const TaskConstMeta(
2169          debugName: "get_transport_preference_value",
2170          argNames: [],
2171        );
2172  
2173    @override
2174    TransportStatsInfo crateApiGetTransportStats() {
2175      return handler.executeSync(
2176        SyncTask(
2177          callFfi: () {
2178            final serializer = SseSerializer(generalizedFrbRustBinding);
2179            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 66)!;
2180          },
2181          codec: SseCodec(
2182            decodeSuccessData: sse_decode_transport_stats_info,
2183            decodeErrorData: sse_decode_String,
2184          ),
2185          constMeta: kCrateApiGetTransportStatsConstMeta,
2186          argValues: [],
2187          apiImpl: this,
2188        ),
2189      );
2190    }
2191  
2192    TaskConstMeta get kCrateApiGetTransportStatsConstMeta =>
2193        const TaskConstMeta(debugName: "get_transport_stats", argNames: []);
2194  
2195    @override
2196    int crateApiGetUnreadCount() {
2197      return handler.executeSync(
2198        SyncTask(
2199          callFfi: () {
2200            final serializer = SseSerializer(generalizedFrbRustBinding);
2201            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 67)!;
2202          },
2203          codec: SseCodec(
2204            decodeSuccessData: sse_decode_u_32,
2205            decodeErrorData: sse_decode_String,
2206          ),
2207          constMeta: kCrateApiGetUnreadCountConstMeta,
2208          argValues: [],
2209          apiImpl: this,
2210        ),
2211      );
2212    }
2213  
2214    TaskConstMeta get kCrateApiGetUnreadCountConstMeta =>
2215        const TaskConstMeta(debugName: "get_unread_count", argNames: []);
2216  
2217    @override
2218    void crateApiGossipExchangeCancel({required GossipExchangeHandle handle}) {
2219      return handler.executeSync(
2220        SyncTask(
2221          callFfi: () {
2222            final serializer = SseSerializer(generalizedFrbRustBinding);
2223            sse_encode_box_autoadd_gossip_exchange_handle(handle, serializer);
2224            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 68)!;
2225          },
2226          codec: SseCodec(
2227            decodeSuccessData: sse_decode_unit,
2228            decodeErrorData: sse_decode_String,
2229          ),
2230          constMeta: kCrateApiGossipExchangeCancelConstMeta,
2231          argValues: [handle],
2232          apiImpl: this,
2233        ),
2234      );
2235    }
2236  
2237    TaskConstMeta get kCrateApiGossipExchangeCancelConstMeta =>
2238        const TaskConstMeta(
2239          debugName: "gossip_exchange_cancel",
2240          argNames: ["handle"],
2241        );
2242  
2243    @override
2244    GossipExchangeComplete crateApiGossipExchangeFinalize({
2245      required GossipExchangeHandle handle,
2246    }) {
2247      return handler.executeSync(
2248        SyncTask(
2249          callFfi: () {
2250            final serializer = SseSerializer(generalizedFrbRustBinding);
2251            sse_encode_box_autoadd_gossip_exchange_handle(handle, serializer);
2252            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 69)!;
2253          },
2254          codec: SseCodec(
2255            decodeSuccessData: sse_decode_gossip_exchange_complete,
2256            decodeErrorData: sse_decode_String,
2257          ),
2258          constMeta: kCrateApiGossipExchangeFinalizeConstMeta,
2259          argValues: [handle],
2260          apiImpl: this,
2261        ),
2262      );
2263    }
2264  
2265    TaskConstMeta get kCrateApiGossipExchangeFinalizeConstMeta =>
2266        const TaskConstMeta(
2267          debugName: "gossip_exchange_finalize",
2268          argNames: ["handle"],
2269        );
2270  
2271    @override
2272    GossipFinalizeKeepTransportResult
2273    crateApiGossipExchangeFinalizeKeepTransport({
2274      required GossipExchangeHandle handle,
2275    }) {
2276      return handler.executeSync(
2277        SyncTask(
2278          callFfi: () {
2279            final serializer = SseSerializer(generalizedFrbRustBinding);
2280            sse_encode_box_autoadd_gossip_exchange_handle(handle, serializer);
2281            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 70)!;
2282          },
2283          codec: SseCodec(
2284            decodeSuccessData: sse_decode_gossip_finalize_keep_transport_result,
2285            decodeErrorData: sse_decode_String,
2286          ),
2287          constMeta: kCrateApiGossipExchangeFinalizeKeepTransportConstMeta,
2288          argValues: [handle],
2289          apiImpl: this,
2290        ),
2291      );
2292    }
2293  
2294    TaskConstMeta get kCrateApiGossipExchangeFinalizeKeepTransportConstMeta =>
2295        const TaskConstMeta(
2296          debugName: "gossip_exchange_finalize_keep_transport",
2297          argNames: ["handle"],
2298        );
2299  
2300    @override
2301    bool crateApiGossipExchangeReceive({
2302      required GossipExchangeHandle handle,
2303      required List<int> data,
2304    }) {
2305      return handler.executeSync(
2306        SyncTask(
2307          callFfi: () {
2308            final serializer = SseSerializer(generalizedFrbRustBinding);
2309            sse_encode_box_autoadd_gossip_exchange_handle(handle, serializer);
2310            sse_encode_list_prim_u_8_loose(data, serializer);
2311            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 71)!;
2312          },
2313          codec: SseCodec(
2314            decodeSuccessData: sse_decode_bool,
2315            decodeErrorData: sse_decode_String,
2316          ),
2317          constMeta: kCrateApiGossipExchangeReceiveConstMeta,
2318          argValues: [handle, data],
2319          apiImpl: this,
2320        ),
2321      );
2322    }
2323  
2324    TaskConstMeta get kCrateApiGossipExchangeReceiveConstMeta =>
2325        const TaskConstMeta(
2326          debugName: "gossip_exchange_receive",
2327          argNames: ["handle", "data"],
2328        );
2329  
2330    @override
2331    Uint8List? crateApiGossipExchangeSend({
2332      required GossipExchangeHandle handle,
2333    }) {
2334      return handler.executeSync(
2335        SyncTask(
2336          callFfi: () {
2337            final serializer = SseSerializer(generalizedFrbRustBinding);
2338            sse_encode_box_autoadd_gossip_exchange_handle(handle, serializer);
2339            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 72)!;
2340          },
2341          codec: SseCodec(
2342            decodeSuccessData: sse_decode_opt_list_prim_u_8_strict,
2343            decodeErrorData: sse_decode_String,
2344          ),
2345          constMeta: kCrateApiGossipExchangeSendConstMeta,
2346          argValues: [handle],
2347          apiImpl: this,
2348        ),
2349      );
2350    }
2351  
2352    TaskConstMeta get kCrateApiGossipExchangeSendConstMeta => const TaskConstMeta(
2353      debugName: "gossip_exchange_send",
2354      argNames: ["handle"],
2355    );
2356  
2357    @override
2358    GossipExchangeHandle crateApiGossipStartNewRound({
2359      required BigInt transportHandle,
2360    }) {
2361      return handler.executeSync(
2362        SyncTask(
2363          callFfi: () {
2364            final serializer = SseSerializer(generalizedFrbRustBinding);
2365            sse_encode_u_64(transportHandle, serializer);
2366            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 73)!;
2367          },
2368          codec: SseCodec(
2369            decodeSuccessData: sse_decode_gossip_exchange_handle,
2370            decodeErrorData: sse_decode_String,
2371          ),
2372          constMeta: kCrateApiGossipStartNewRoundConstMeta,
2373          argValues: [transportHandle],
2374          apiImpl: this,
2375        ),
2376      );
2377    }
2378  
2379    TaskConstMeta get kCrateApiGossipStartNewRoundConstMeta =>
2380        const TaskConstMeta(
2381          debugName: "gossip_start_new_round",
2382          argNames: ["transportHandle"],
2383        );
2384  
2385    @override
2386    void crateApiGossipTransportRelease({required BigInt transportHandle}) {
2387      return handler.executeSync(
2388        SyncTask(
2389          callFfi: () {
2390            final serializer = SseSerializer(generalizedFrbRustBinding);
2391            sse_encode_u_64(transportHandle, serializer);
2392            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 74)!;
2393          },
2394          codec: SseCodec(
2395            decodeSuccessData: sse_decode_unit,
2396            decodeErrorData: sse_decode_String,
2397          ),
2398          constMeta: kCrateApiGossipTransportReleaseConstMeta,
2399          argValues: [transportHandle],
2400          apiImpl: this,
2401        ),
2402      );
2403    }
2404  
2405    TaskConstMeta get kCrateApiGossipTransportReleaseConstMeta =>
2406        const TaskConstMeta(
2407          debugName: "gossip_transport_release",
2408          argNames: ["transportHandle"],
2409        );
2410  
2411    @override
2412    Uint8List crateApiHandleGossipRequest({required List<int> requestBytes}) {
2413      return handler.executeSync(
2414        SyncTask(
2415          callFfi: () {
2416            final serializer = SseSerializer(generalizedFrbRustBinding);
2417            sse_encode_list_prim_u_8_loose(requestBytes, serializer);
2418            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 75)!;
2419          },
2420          codec: SseCodec(
2421            decodeSuccessData: sse_decode_list_prim_u_8_strict,
2422            decodeErrorData: sse_decode_String,
2423          ),
2424          constMeta: kCrateApiHandleGossipRequestConstMeta,
2425          argValues: [requestBytes],
2426          apiImpl: this,
2427        ),
2428      );
2429    }
2430  
2431    TaskConstMeta get kCrateApiHandleGossipRequestConstMeta =>
2432        const TaskConstMeta(
2433          debugName: "handle_gossip_request",
2434          argNames: ["requestBytes"],
2435        );
2436  
2437    @override
2438    void crateApiHandshakeCancel({required HandshakeHandle handle}) {
2439      return handler.executeSync(
2440        SyncTask(
2441          callFfi: () {
2442            final serializer = SseSerializer(generalizedFrbRustBinding);
2443            sse_encode_box_autoadd_handshake_handle(handle, serializer);
2444            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 76)!;
2445          },
2446          codec: SseCodec(
2447            decodeSuccessData: sse_decode_unit,
2448            decodeErrorData: sse_decode_String,
2449          ),
2450          constMeta: kCrateApiHandshakeCancelConstMeta,
2451          argValues: [handle],
2452          apiImpl: this,
2453        ),
2454      );
2455    }
2456  
2457    TaskConstMeta get kCrateApiHandshakeCancelConstMeta =>
2458        const TaskConstMeta(debugName: "handshake_cancel", argNames: ["handle"]);
2459  
2460    @override
2461    ExchangeHandle crateApiHandshakeFinalize({required HandshakeHandle handle}) {
2462      return handler.executeSync(
2463        SyncTask(
2464          callFfi: () {
2465            final serializer = SseSerializer(generalizedFrbRustBinding);
2466            sse_encode_box_autoadd_handshake_handle(handle, serializer);
2467            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 77)!;
2468          },
2469          codec: SseCodec(
2470            decodeSuccessData: sse_decode_exchange_handle,
2471            decodeErrorData: sse_decode_String,
2472          ),
2473          constMeta: kCrateApiHandshakeFinalizeConstMeta,
2474          argValues: [handle],
2475          apiImpl: this,
2476        ),
2477      );
2478    }
2479  
2480    TaskConstMeta get kCrateApiHandshakeFinalizeConstMeta => const TaskConstMeta(
2481      debugName: "handshake_finalize",
2482      argNames: ["handle"],
2483    );
2484  
2485    @override
2486    GossipExchangeHandle crateApiHandshakeFinalizeForGossip({
2487      required HandshakeHandle handle,
2488    }) {
2489      return handler.executeSync(
2490        SyncTask(
2491          callFfi: () {
2492            final serializer = SseSerializer(generalizedFrbRustBinding);
2493            sse_encode_box_autoadd_handshake_handle(handle, serializer);
2494            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 78)!;
2495          },
2496          codec: SseCodec(
2497            decodeSuccessData: sse_decode_gossip_exchange_handle,
2498            decodeErrorData: sse_decode_String,
2499          ),
2500          constMeta: kCrateApiHandshakeFinalizeForGossipConstMeta,
2501          argValues: [handle],
2502          apiImpl: this,
2503        ),
2504      );
2505    }
2506  
2507    TaskConstMeta get kCrateApiHandshakeFinalizeForGossipConstMeta =>
2508        const TaskConstMeta(
2509          debugName: "handshake_finalize_for_gossip",
2510          argNames: ["handle"],
2511        );
2512  
2513    @override
2514    Uint8List crateApiHandshakeGenerate({required HandshakeHandle handle}) {
2515      return handler.executeSync(
2516        SyncTask(
2517          callFfi: () {
2518            final serializer = SseSerializer(generalizedFrbRustBinding);
2519            sse_encode_box_autoadd_handshake_handle(handle, serializer);
2520            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 79)!;
2521          },
2522          codec: SseCodec(
2523            decodeSuccessData: sse_decode_list_prim_u_8_strict,
2524            decodeErrorData: sse_decode_String,
2525          ),
2526          constMeta: kCrateApiHandshakeGenerateConstMeta,
2527          argValues: [handle],
2528          apiImpl: this,
2529        ),
2530      );
2531    }
2532  
2533    TaskConstMeta get kCrateApiHandshakeGenerateConstMeta => const TaskConstMeta(
2534      debugName: "handshake_generate",
2535      argNames: ["handle"],
2536    );
2537  
2538    @override
2539    HandshakeResult crateApiHandshakeProcess({
2540      required HandshakeHandle handle,
2541      required List<int> data,
2542    }) {
2543      return handler.executeSync(
2544        SyncTask(
2545          callFfi: () {
2546            final serializer = SseSerializer(generalizedFrbRustBinding);
2547            sse_encode_box_autoadd_handshake_handle(handle, serializer);
2548            sse_encode_list_prim_u_8_loose(data, serializer);
2549            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 80)!;
2550          },
2551          codec: SseCodec(
2552            decodeSuccessData: sse_decode_handshake_result,
2553            decodeErrorData: sse_decode_String,
2554          ),
2555          constMeta: kCrateApiHandshakeProcessConstMeta,
2556          argValues: [handle, data],
2557          apiImpl: this,
2558        ),
2559      );
2560    }
2561  
2562    TaskConstMeta get kCrateApiHandshakeProcessConstMeta => const TaskConstMeta(
2563      debugName: "handshake_process",
2564      argNames: ["handle", "data"],
2565    );
2566  
2567    @override
2568    bool crateApiHasIdentity() {
2569      return handler.executeSync(
2570        SyncTask(
2571          callFfi: () {
2572            final serializer = SseSerializer(generalizedFrbRustBinding);
2573            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 81)!;
2574          },
2575          codec: SseCodec(
2576            decodeSuccessData: sse_decode_bool,
2577            decodeErrorData: sse_decode_String,
2578          ),
2579          constMeta: kCrateApiHasIdentityConstMeta,
2580          argValues: [],
2581          apiImpl: this,
2582        ),
2583      );
2584    }
2585  
2586    TaskConstMeta get kCrateApiHasIdentityConstMeta =>
2587        const TaskConstMeta(debugName: "has_identity", argNames: []);
2588  
2589    @override
2590    void crateApiInitialize({
2591      required String storagePath,
2592      required String passphrase,
2593    }) {
2594      return handler.executeSync(
2595        SyncTask(
2596          callFfi: () {
2597            final serializer = SseSerializer(generalizedFrbRustBinding);
2598            sse_encode_String(storagePath, serializer);
2599            sse_encode_String(passphrase, serializer);
2600            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 82)!;
2601          },
2602          codec: SseCodec(
2603            decodeSuccessData: sse_decode_unit,
2604            decodeErrorData: sse_decode_String,
2605          ),
2606          constMeta: kCrateApiInitializeConstMeta,
2607          argValues: [storagePath, passphrase],
2608          apiImpl: this,
2609        ),
2610      );
2611    }
2612  
2613    TaskConstMeta get kCrateApiInitializeConstMeta => const TaskConstMeta(
2614      debugName: "initialize",
2615      argNames: ["storagePath", "passphrase"],
2616    );
2617  
2618    @override
2619    bool crateApiIsDocumentComplete({required List<int> documentId}) {
2620      return handler.executeSync(
2621        SyncTask(
2622          callFfi: () {
2623            final serializer = SseSerializer(generalizedFrbRustBinding);
2624            sse_encode_list_prim_u_8_loose(documentId, serializer);
2625            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 83)!;
2626          },
2627          codec: SseCodec(
2628            decodeSuccessData: sse_decode_bool,
2629            decodeErrorData: sse_decode_String,
2630          ),
2631          constMeta: kCrateApiIsDocumentCompleteConstMeta,
2632          argValues: [documentId],
2633          apiImpl: this,
2634        ),
2635      );
2636    }
2637  
2638    TaskConstMeta get kCrateApiIsDocumentCompleteConstMeta => const TaskConstMeta(
2639      debugName: "is_document_complete",
2640      argNames: ["documentId"],
2641    );
2642  
2643    @override
2644    bool crateApiIsGroupAccepted({required List<int> groupId}) {
2645      return handler.executeSync(
2646        SyncTask(
2647          callFfi: () {
2648            final serializer = SseSerializer(generalizedFrbRustBinding);
2649            sse_encode_list_prim_u_8_loose(groupId, serializer);
2650            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 84)!;
2651          },
2652          codec: SseCodec(
2653            decodeSuccessData: sse_decode_bool,
2654            decodeErrorData: sse_decode_String,
2655          ),
2656          constMeta: kCrateApiIsGroupAcceptedConstMeta,
2657          argValues: [groupId],
2658          apiImpl: this,
2659        ),
2660      );
2661    }
2662  
2663    TaskConstMeta get kCrateApiIsGroupAcceptedConstMeta => const TaskConstMeta(
2664      debugName: "is_group_accepted",
2665      argNames: ["groupId"],
2666    );
2667  
2668    @override
2669    bool crateApiIsInitialized() {
2670      return handler.executeSync(
2671        SyncTask(
2672          callFfi: () {
2673            final serializer = SseSerializer(generalizedFrbRustBinding);
2674            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 85)!;
2675          },
2676          codec: SseCodec(
2677            decodeSuccessData: sse_decode_bool,
2678            decodeErrorData: null,
2679          ),
2680          constMeta: kCrateApiIsInitializedConstMeta,
2681          argValues: [],
2682          apiImpl: this,
2683        ),
2684      );
2685    }
2686  
2687    TaskConstMeta get kCrateApiIsInitializedConstMeta =>
2688        const TaskConstMeta(debugName: "is_initialized", argNames: []);
2689  
2690    @override
2691    bool crateApiIsTransportAvailable({required TransportTypeDto transportType}) {
2692      return handler.executeSync(
2693        SyncTask(
2694          callFfi: () {
2695            final serializer = SseSerializer(generalizedFrbRustBinding);
2696            sse_encode_transport_type_dto(transportType, serializer);
2697            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 86)!;
2698          },
2699          codec: SseCodec(
2700            decodeSuccessData: sse_decode_bool,
2701            decodeErrorData: null,
2702          ),
2703          constMeta: kCrateApiIsTransportAvailableConstMeta,
2704          argValues: [transportType],
2705          apiImpl: this,
2706        ),
2707      );
2708    }
2709  
2710    TaskConstMeta get kCrateApiIsTransportAvailableConstMeta =>
2711        const TaskConstMeta(
2712          debugName: "is_transport_available",
2713          argNames: ["transportType"],
2714        );
2715  
2716    @override
2717    Future<void> crateApiLeaveGroup({required List<int> groupId}) {
2718      return handler.executeNormal(
2719        NormalTask(
2720          callFfi: (port_) {
2721            final serializer = SseSerializer(generalizedFrbRustBinding);
2722            sse_encode_list_prim_u_8_loose(groupId, serializer);
2723            pdeCallFfi(
2724              generalizedFrbRustBinding,
2725              serializer,
2726              funcId: 87,
2727              port: port_,
2728            );
2729          },
2730          codec: SseCodec(
2731            decodeSuccessData: sse_decode_unit,
2732            decodeErrorData: sse_decode_String,
2733          ),
2734          constMeta: kCrateApiLeaveGroupConstMeta,
2735          argValues: [groupId],
2736          apiImpl: this,
2737        ),
2738      );
2739    }
2740  
2741    TaskConstMeta get kCrateApiLeaveGroupConstMeta =>
2742        const TaskConstMeta(debugName: "leave_group", argNames: ["groupId"]);
2743  
2744    @override
2745    List<ContactInfo> crateApiListContacts() {
2746      return handler.executeSync(
2747        SyncTask(
2748          callFfi: () {
2749            final serializer = SseSerializer(generalizedFrbRustBinding);
2750            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 88)!;
2751          },
2752          codec: SseCodec(
2753            decodeSuccessData: sse_decode_list_contact_info,
2754            decodeErrorData: sse_decode_String,
2755          ),
2756          constMeta: kCrateApiListContactsConstMeta,
2757          argValues: [],
2758          apiImpl: this,
2759        ),
2760      );
2761    }
2762  
2763    TaskConstMeta get kCrateApiListContactsConstMeta =>
2764        const TaskConstMeta(debugName: "list_contacts", argNames: []);
2765  
2766    @override
2767    List<GroupInfo> crateApiListGroups() {
2768      return handler.executeSync(
2769        SyncTask(
2770          callFfi: () {
2771            final serializer = SseSerializer(generalizedFrbRustBinding);
2772            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 89)!;
2773          },
2774          codec: SseCodec(
2775            decodeSuccessData: sse_decode_list_group_info,
2776            decodeErrorData: sse_decode_String,
2777          ),
2778          constMeta: kCrateApiListGroupsConstMeta,
2779          argValues: [],
2780          apiImpl: this,
2781        ),
2782      );
2783    }
2784  
2785    TaskConstMeta get kCrateApiListGroupsConstMeta =>
2786        const TaskConstMeta(debugName: "list_groups", argNames: []);
2787  
2788    @override
2789    Future<void> crateApiMarkDeliveredViaTor({
2790      required List<Uint8List> messageIds,
2791    }) {
2792      return handler.executeNormal(
2793        NormalTask(
2794          callFfi: (port_) {
2795            final serializer = SseSerializer(generalizedFrbRustBinding);
2796            sse_encode_list_list_prim_u_8_strict(messageIds, serializer);
2797            pdeCallFfi(
2798              generalizedFrbRustBinding,
2799              serializer,
2800              funcId: 90,
2801              port: port_,
2802            );
2803          },
2804          codec: SseCodec(
2805            decodeSuccessData: sse_decode_unit,
2806            decodeErrorData: sse_decode_String,
2807          ),
2808          constMeta: kCrateApiMarkDeliveredViaTorConstMeta,
2809          argValues: [messageIds],
2810          apiImpl: this,
2811        ),
2812      );
2813    }
2814  
2815    TaskConstMeta get kCrateApiMarkDeliveredViaTorConstMeta =>
2816        const TaskConstMeta(
2817          debugName: "mark_delivered_via_tor",
2818          argNames: ["messageIds"],
2819        );
2820  
2821    @override
2822    void crateApiMarkRead({required List<int> messageId}) {
2823      return handler.executeSync(
2824        SyncTask(
2825          callFfi: () {
2826            final serializer = SseSerializer(generalizedFrbRustBinding);
2827            sse_encode_list_prim_u_8_loose(messageId, serializer);
2828            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 91)!;
2829          },
2830          codec: SseCodec(
2831            decodeSuccessData: sse_decode_unit,
2832            decodeErrorData: sse_decode_String,
2833          ),
2834          constMeta: kCrateApiMarkReadConstMeta,
2835          argValues: [messageId],
2836          apiImpl: this,
2837        ),
2838      );
2839    }
2840  
2841    TaskConstMeta get kCrateApiMarkReadConstMeta =>
2842        const TaskConstMeta(debugName: "mark_read", argNames: ["messageId"]);
2843  
2844    @override
2845    Future<NetworkTransportPreference>
2846    crateApiNetworkTransportPreferenceDefault() {
2847      return handler.executeNormal(
2848        NormalTask(
2849          callFfi: (port_) {
2850            final serializer = SseSerializer(generalizedFrbRustBinding);
2851            pdeCallFfi(
2852              generalizedFrbRustBinding,
2853              serializer,
2854              funcId: 92,
2855              port: port_,
2856            );
2857          },
2858          codec: SseCodec(
2859            decodeSuccessData: sse_decode_network_transport_preference,
2860            decodeErrorData: null,
2861          ),
2862          constMeta: kCrateApiNetworkTransportPreferenceDefaultConstMeta,
2863          argValues: [],
2864          apiImpl: this,
2865        ),
2866      );
2867    }
2868  
2869    TaskConstMeta get kCrateApiNetworkTransportPreferenceDefaultConstMeta =>
2870        const TaskConstMeta(
2871          debugName: "network_transport_preference_default",
2872          argNames: [],
2873        );
2874  
2875    @override
2876    Future<IrohIncomingMessage?> crateApiPollIrohIncoming() {
2877      return handler.executeNormal(
2878        NormalTask(
2879          callFfi: (port_) {
2880            final serializer = SseSerializer(generalizedFrbRustBinding);
2881            pdeCallFfi(
2882              generalizedFrbRustBinding,
2883              serializer,
2884              funcId: 93,
2885              port: port_,
2886            );
2887          },
2888          codec: SseCodec(
2889            decodeSuccessData: sse_decode_opt_box_autoadd_iroh_incoming_message,
2890            decodeErrorData: sse_decode_String,
2891          ),
2892          constMeta: kCrateApiPollIrohIncomingConstMeta,
2893          argValues: [],
2894          apiImpl: this,
2895        ),
2896      );
2897    }
2898  
2899    TaskConstMeta get kCrateApiPollIrohIncomingConstMeta =>
2900        const TaskConstMeta(debugName: "poll_iroh_incoming", argNames: []);
2901  
2902    @override
2903    Uint8List? crateApiProcessGossipDigest({required List<int> digestBytes}) {
2904      return handler.executeSync(
2905        SyncTask(
2906          callFfi: () {
2907            final serializer = SseSerializer(generalizedFrbRustBinding);
2908            sse_encode_list_prim_u_8_loose(digestBytes, serializer);
2909            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 94)!;
2910          },
2911          codec: SseCodec(
2912            decodeSuccessData: sse_decode_opt_list_prim_u_8_strict,
2913            decodeErrorData: sse_decode_String,
2914          ),
2915          constMeta: kCrateApiProcessGossipDigestConstMeta,
2916          argValues: [digestBytes],
2917          apiImpl: this,
2918        ),
2919      );
2920    }
2921  
2922    TaskConstMeta get kCrateApiProcessGossipDigestConstMeta =>
2923        const TaskConstMeta(
2924          debugName: "process_gossip_digest",
2925          argNames: ["digestBytes"],
2926        );
2927  
2928    @override
2929    GossipResult crateApiProcessGossipResponse({
2930      required List<int> responseBytes,
2931    }) {
2932      return handler.executeSync(
2933        SyncTask(
2934          callFfi: () {
2935            final serializer = SseSerializer(generalizedFrbRustBinding);
2936            sse_encode_list_prim_u_8_loose(responseBytes, serializer);
2937            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 95)!;
2938          },
2939          codec: SseCodec(
2940            decodeSuccessData: sse_decode_gossip_result,
2941            decodeErrorData: sse_decode_String,
2942          ),
2943          constMeta: kCrateApiProcessGossipResponseConstMeta,
2944          argValues: [responseBytes],
2945          apiImpl: this,
2946        ),
2947      );
2948    }
2949  
2950    TaskConstMeta get kCrateApiProcessGossipResponseConstMeta =>
2951        const TaskConstMeta(
2952          debugName: "process_gossip_response",
2953          argNames: ["responseBytes"],
2954        );
2955  
2956    @override
2957    Future<MessageInfo?> crateApiProcessIrohMessage({
2958      required List<int> senderIdentityKey,
2959      required List<int> payload,
2960    }) {
2961      return handler.executeNormal(
2962        NormalTask(
2963          callFfi: (port_) {
2964            final serializer = SseSerializer(generalizedFrbRustBinding);
2965            sse_encode_list_prim_u_8_loose(senderIdentityKey, serializer);
2966            sse_encode_list_prim_u_8_loose(payload, serializer);
2967            pdeCallFfi(
2968              generalizedFrbRustBinding,
2969              serializer,
2970              funcId: 96,
2971              port: port_,
2972            );
2973          },
2974          codec: SseCodec(
2975            decodeSuccessData: sse_decode_opt_box_autoadd_message_info,
2976            decodeErrorData: sse_decode_String,
2977          ),
2978          constMeta: kCrateApiProcessIrohMessageConstMeta,
2979          argValues: [senderIdentityKey, payload],
2980          apiImpl: this,
2981        ),
2982      );
2983    }
2984  
2985    TaskConstMeta get kCrateApiProcessIrohMessageConstMeta => const TaskConstMeta(
2986      debugName: "process_iroh_message",
2987      argNames: ["senderIdentityKey", "payload"],
2988    );
2989  
2990    @override
2991    Future<MessageInfo?> crateApiProcessIrohMessageUnknownSender({
2992      required List<int> payload,
2993    }) {
2994      return handler.executeNormal(
2995        NormalTask(
2996          callFfi: (port_) {
2997            final serializer = SseSerializer(generalizedFrbRustBinding);
2998            sse_encode_list_prim_u_8_loose(payload, serializer);
2999            pdeCallFfi(
3000              generalizedFrbRustBinding,
3001              serializer,
3002              funcId: 97,
3003              port: port_,
3004            );
3005          },
3006          codec: SseCodec(
3007            decodeSuccessData: sse_decode_opt_box_autoadd_message_info,
3008            decodeErrorData: sse_decode_String,
3009          ),
3010          constMeta: kCrateApiProcessIrohMessageUnknownSenderConstMeta,
3011          argValues: [payload],
3012          apiImpl: this,
3013        ),
3014      );
3015    }
3016  
3017    TaskConstMeta get kCrateApiProcessIrohMessageUnknownSenderConstMeta =>
3018        const TaskConstMeta(
3019          debugName: "process_iroh_message_unknown_sender",
3020          argNames: ["payload"],
3021        );
3022  
3023    @override
3024    PendingContact crateApiProcessQrCode({required String payload}) {
3025      return handler.executeSync(
3026        SyncTask(
3027          callFfi: () {
3028            final serializer = SseSerializer(generalizedFrbRustBinding);
3029            sse_encode_String(payload, serializer);
3030            return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 98)!;
3031          },
3032          codec: SseCodec(
3033            decodeSuccessData: sse_decode_pending_contact,
3034            decodeErrorData: sse_decode_String,
3035          ),
3036          constMeta: kCrateApiProcessQrCodeConstMeta,
3037          argValues: [payload],
3038          apiImpl: this,
3039        ),
3040      );
3041    }
3042  
3043    TaskConstMeta get kCrateApiProcessQrCodeConstMeta =>
3044        const TaskConstMeta(debugName: "process_qr_code", argNames: ["payload"]);
3045  
3046    @override
3047    Future<MessageInfo?> crateApiProcessTorMessage({
3048      required List<int> senderIdentityKey,
3049      required List<int> payload,
3050    }) {
3051      return handler.executeNormal(
3052        NormalTask(
3053          callFfi: (port_) {
3054            final serializer = SseSerializer(generalizedFrbRustBinding);
3055            sse_encode_list_prim_u_8_loose(senderIdentityKey, serializer);
3056            sse_encode_list_prim_u_8_loose(payload, serializer);
3057            pdeCallFfi(
3058              generalizedFrbRustBinding,
3059              serializer,
3060              funcId: 99,
3061              port: port_,
3062            );
3063          },
3064          codec: SseCodec(
3065            decodeSuccessData: sse_decode_opt_box_autoadd_message_info,
3066            decodeErrorData: sse_decode_String,
3067          ),
3068          constMeta: kCrateApiProcessTorMessageConstMeta,
3069          argValues: [senderIdentityKey, payload],
3070          apiImpl: this,
3071        ),
3072      );
3073    }
3074  
3075    TaskConstMeta get kCrateApiProcessTorMessageConstMeta => const TaskConstMeta(
3076      debugName: "process_tor_message",
3077      argNames: ["senderIdentityKey", "payload"],
3078    );
3079  
3080    @override
3081    int crateApiPromoteToGossipRelay({required PlatformInt64 minAgeSecs}) {
3082      return handler.executeSync(
3083        SyncTask(
3084          callFfi: () {
3085            final serializer = SseSerializer(generalizedFrbRustBinding);
3086            sse_encode_i_64(minAgeSecs, serializer);
3087            return pdeCallFfi(
3088              generalizedFrbRustBinding,
3089              serializer,
3090              funcId: 100,
3091            )!;
3092          },
3093          codec: SseCodec(
3094            decodeSuccessData: sse_decode_i_32,
3095            decodeErrorData: null,
3096          ),
3097          constMeta: kCrateApiPromoteToGossipRelayConstMeta,
3098          argValues: [minAgeSecs],
3099          apiImpl: this,
3100        ),
3101      );
3102    }
3103  
3104    TaskConstMeta get kCrateApiPromoteToGossipRelayConstMeta =>
3105        const TaskConstMeta(
3106          debugName: "promote_to_gossip_relay",
3107          argNames: ["minAgeSecs"],
3108        );
3109  
3110    @override
3111    Future<void> crateApiPublishIrohEndpointId() {
3112      return handler.executeNormal(
3113        NormalTask(
3114          callFfi: (port_) {
3115            final serializer = SseSerializer(generalizedFrbRustBinding);
3116            pdeCallFfi(
3117              generalizedFrbRustBinding,
3118              serializer,
3119              funcId: 101,
3120              port: port_,
3121            );
3122          },
3123          codec: SseCodec(
3124            decodeSuccessData: sse_decode_unit,
3125            decodeErrorData: sse_decode_String,
3126          ),
3127          constMeta: kCrateApiPublishIrohEndpointIdConstMeta,
3128          argValues: [],
3129          apiImpl: this,
3130        ),
3131      );
3132    }
3133  
3134    TaskConstMeta get kCrateApiPublishIrohEndpointIdConstMeta =>
3135        const TaskConstMeta(debugName: "publish_iroh_endpoint_id", argNames: []);
3136  
3137    @override
3138    Future<DhtPublishResult> crateApiPublishMessagesToDht({
3139      required List<int> contactId,
3140    }) {
3141      return handler.executeNormal(
3142        NormalTask(
3143          callFfi: (port_) {
3144            final serializer = SseSerializer(generalizedFrbRustBinding);
3145            sse_encode_list_prim_u_8_loose(contactId, serializer);
3146            pdeCallFfi(
3147              generalizedFrbRustBinding,
3148              serializer,
3149              funcId: 102,
3150              port: port_,
3151            );
3152          },
3153          codec: SseCodec(
3154            decodeSuccessData: sse_decode_dht_publish_result,
3155            decodeErrorData: sse_decode_String,
3156          ),
3157          constMeta: kCrateApiPublishMessagesToDhtConstMeta,
3158          argValues: [contactId],
3159          apiImpl: this,
3160        ),
3161      );
3162    }
3163  
3164    TaskConstMeta get kCrateApiPublishMessagesToDhtConstMeta =>
3165        const TaskConstMeta(
3166          debugName: "publish_messages_to_dht",
3167          argNames: ["contactId"],
3168        );
3169  
3170    @override
3171    Future<void> crateApiPublishOnionAddress({required String onionAddress}) {
3172      return handler.executeNormal(
3173        NormalTask(
3174          callFfi: (port_) {
3175            final serializer = SseSerializer(generalizedFrbRustBinding);
3176            sse_encode_String(onionAddress, serializer);
3177            pdeCallFfi(
3178              generalizedFrbRustBinding,
3179              serializer,
3180              funcId: 103,
3181              port: port_,
3182            );
3183          },
3184          codec: SseCodec(
3185            decodeSuccessData: sse_decode_unit,
3186            decodeErrorData: sse_decode_String,
3187          ),
3188          constMeta: kCrateApiPublishOnionAddressConstMeta,
3189          argValues: [onionAddress],
3190          apiImpl: this,
3191        ),
3192      );
3193    }
3194  
3195    TaskConstMeta get kCrateApiPublishOnionAddressConstMeta =>
3196        const TaskConstMeta(
3197          debugName: "publish_onion_address",
3198          argNames: ["onionAddress"],
3199        );
3200  
3201    @override
3202    bool crateApiQueueForGossipRelay({required List<int> messageId}) {
3203      return handler.executeSync(
3204        SyncTask(
3205          callFfi: () {
3206            final serializer = SseSerializer(generalizedFrbRustBinding);
3207            sse_encode_list_prim_u_8_loose(messageId, serializer);
3208            return pdeCallFfi(
3209              generalizedFrbRustBinding,
3210              serializer,
3211              funcId: 104,
3212            )!;
3213          },
3214          codec: SseCodec(
3215            decodeSuccessData: sse_decode_bool,
3216            decodeErrorData: sse_decode_String,
3217          ),
3218          constMeta: kCrateApiQueueForGossipRelayConstMeta,
3219          argValues: [messageId],
3220          apiImpl: this,
3221        ),
3222      );
3223    }
3224  
3225    TaskConstMeta get kCrateApiQueueForGossipRelayConstMeta =>
3226        const TaskConstMeta(
3227          debugName: "queue_for_gossip_relay",
3228          argNames: ["messageId"],
3229        );
3230  
3231    @override
3232    DocumentInfo crateApiReassembleDocument({required List<int> documentId}) {
3233      return handler.executeSync(
3234        SyncTask(
3235          callFfi: () {
3236            final serializer = SseSerializer(generalizedFrbRustBinding);
3237            sse_encode_list_prim_u_8_loose(documentId, serializer);
3238            return pdeCallFfi(
3239              generalizedFrbRustBinding,
3240              serializer,
3241              funcId: 105,
3242            )!;
3243          },
3244          codec: SseCodec(
3245            decodeSuccessData: sse_decode_document_info,
3246            decodeErrorData: sse_decode_String,
3247          ),
3248          constMeta: kCrateApiReassembleDocumentConstMeta,
3249          argValues: [documentId],
3250          apiImpl: this,
3251        ),
3252      );
3253    }
3254  
3255    TaskConstMeta get kCrateApiReassembleDocumentConstMeta => const TaskConstMeta(
3256      debugName: "reassemble_document",
3257      argNames: ["documentId"],
3258    );
3259  
3260    @override
3261    List<String> crateApiRecordDeliveryConfirmation({
3262      required List<int> messageHash,
3263    }) {
3264      return handler.executeSync(
3265        SyncTask(
3266          callFfi: () {
3267            final serializer = SseSerializer(generalizedFrbRustBinding);
3268            sse_encode_list_prim_u_8_loose(messageHash, serializer);
3269            return pdeCallFfi(
3270              generalizedFrbRustBinding,
3271              serializer,
3272              funcId: 106,
3273            )!;
3274          },
3275          codec: SseCodec(
3276            decodeSuccessData: sse_decode_list_String,
3277            decodeErrorData: sse_decode_String,
3278          ),
3279          constMeta: kCrateApiRecordDeliveryConfirmationConstMeta,
3280          argValues: [messageHash],
3281          apiImpl: this,
3282        ),
3283      );
3284    }
3285  
3286    TaskConstMeta get kCrateApiRecordDeliveryConfirmationConstMeta =>
3287        const TaskConstMeta(
3288          debugName: "record_delivery_confirmation",
3289          argNames: ["messageHash"],
3290        );
3291  
3292    @override
3293    List<String> crateApiRecordMessageForwarded({
3294      required List<int> recipientKeyHash,
3295    }) {
3296      return handler.executeSync(
3297        SyncTask(
3298          callFfi: () {
3299            final serializer = SseSerializer(generalizedFrbRustBinding);
3300            sse_encode_list_prim_u_8_loose(recipientKeyHash, serializer);
3301            return pdeCallFfi(
3302              generalizedFrbRustBinding,
3303              serializer,
3304              funcId: 107,
3305            )!;
3306          },
3307          codec: SseCodec(
3308            decodeSuccessData: sse_decode_list_String,
3309            decodeErrorData: sse_decode_String,
3310          ),
3311          constMeta: kCrateApiRecordMessageForwardedConstMeta,
3312          argValues: [recipientKeyHash],
3313          apiImpl: this,
3314        ),
3315      );
3316    }
3317  
3318    TaskConstMeta get kCrateApiRecordMessageForwardedConstMeta =>
3319        const TaskConstMeta(
3320          debugName: "record_message_forwarded",
3321          argNames: ["recipientKeyHash"],
3322        );
3323  
3324    @override
3325    void crateApiRefreshContactKeys({
3326      required List<int> contactId,
3327      required String qrPayload,
3328    }) {
3329      return handler.executeSync(
3330        SyncTask(
3331          callFfi: () {
3332            final serializer = SseSerializer(generalizedFrbRustBinding);
3333            sse_encode_list_prim_u_8_loose(contactId, serializer);
3334            sse_encode_String(qrPayload, serializer);
3335            return pdeCallFfi(
3336              generalizedFrbRustBinding,
3337              serializer,
3338              funcId: 108,
3339            )!;
3340          },
3341          codec: SseCodec(
3342            decodeSuccessData: sse_decode_unit,
3343            decodeErrorData: sse_decode_String,
3344          ),
3345          constMeta: kCrateApiRefreshContactKeysConstMeta,
3346          argValues: [contactId, qrPayload],
3347          apiImpl: this,
3348        ),
3349      );
3350    }
3351  
3352    TaskConstMeta get kCrateApiRefreshContactKeysConstMeta => const TaskConstMeta(
3353      debugName: "refresh_contact_keys",
3354      argNames: ["contactId", "qrPayload"],
3355    );
3356  
3357    @override
3358    Future<RelayStateDto> crateApiRelayStateDtoFromInternal({
3359      required RelayState state,
3360    }) {
3361      return handler.executeNormal(
3362        NormalTask(
3363          callFfi: (port_) {
3364            final serializer = SseSerializer(generalizedFrbRustBinding);
3365            sse_encode_box_autoadd_relay_state(state, serializer);
3366            pdeCallFfi(
3367              generalizedFrbRustBinding,
3368              serializer,
3369              funcId: 109,
3370              port: port_,
3371            );
3372          },
3373          codec: SseCodec(
3374            decodeSuccessData: sse_decode_relay_state_dto,
3375            decodeErrorData: null,
3376          ),
3377          constMeta: kCrateApiRelayStateDtoFromInternalConstMeta,
3378          argValues: [state],
3379          apiImpl: this,
3380        ),
3381      );
3382    }
3383  
3384    TaskConstMeta get kCrateApiRelayStateDtoFromInternalConstMeta =>
3385        const TaskConstMeta(
3386          debugName: "relay_state_dto_from_internal",
3387          argNames: ["state"],
3388        );
3389  
3390    @override
3391    Future<void> crateApiRemoveGroupMember({
3392      required List<int> groupId,
3393      required List<int> contactId,
3394    }) {
3395      return handler.executeNormal(
3396        NormalTask(
3397          callFfi: (port_) {
3398            final serializer = SseSerializer(generalizedFrbRustBinding);
3399            sse_encode_list_prim_u_8_loose(groupId, serializer);
3400            sse_encode_list_prim_u_8_loose(contactId, serializer);
3401            pdeCallFfi(
3402              generalizedFrbRustBinding,
3403              serializer,
3404              funcId: 110,
3405              port: port_,
3406            );
3407          },
3408          codec: SseCodec(
3409            decodeSuccessData: sse_decode_unit,
3410            decodeErrorData: sse_decode_String,
3411          ),
3412          constMeta: kCrateApiRemoveGroupMemberConstMeta,
3413          argValues: [groupId, contactId],
3414          apiImpl: this,
3415        ),
3416      );
3417    }
3418  
3419    TaskConstMeta get kCrateApiRemoveGroupMemberConstMeta => const TaskConstMeta(
3420      debugName: "remove_group_member",
3421      argNames: ["groupId", "contactId"],
3422    );
3423  
3424    @override
3425    void crateApiRemoveReaction({
3426      required List<int> messageId,
3427      required String emoji,
3428    }) {
3429      return handler.executeSync(
3430        SyncTask(
3431          callFfi: () {
3432            final serializer = SseSerializer(generalizedFrbRustBinding);
3433            sse_encode_list_prim_u_8_loose(messageId, serializer);
3434            sse_encode_String(emoji, serializer);
3435            return pdeCallFfi(
3436              generalizedFrbRustBinding,
3437              serializer,
3438              funcId: 111,
3439            )!;
3440          },
3441          codec: SseCodec(
3442            decodeSuccessData: sse_decode_unit,
3443            decodeErrorData: sse_decode_String,
3444          ),
3445          constMeta: kCrateApiRemoveReactionConstMeta,
3446          argValues: [messageId, emoji],
3447          apiImpl: this,
3448        ),
3449      );
3450    }
3451  
3452    TaskConstMeta get kCrateApiRemoveReactionConstMeta => const TaskConstMeta(
3453      debugName: "remove_reaction",
3454      argNames: ["messageId", "emoji"],
3455    );
3456  
3457    @override
3458    Future<void> crateApiRenameGroup({
3459      required List<int> groupId,
3460      required String newName,
3461    }) {
3462      return handler.executeNormal(
3463        NormalTask(
3464          callFfi: (port_) {
3465            final serializer = SseSerializer(generalizedFrbRustBinding);
3466            sse_encode_list_prim_u_8_loose(groupId, serializer);
3467            sse_encode_String(newName, serializer);
3468            pdeCallFfi(
3469              generalizedFrbRustBinding,
3470              serializer,
3471              funcId: 112,
3472              port: port_,
3473            );
3474          },
3475          codec: SseCodec(
3476            decodeSuccessData: sse_decode_unit,
3477            decodeErrorData: sse_decode_String,
3478          ),
3479          constMeta: kCrateApiRenameGroupConstMeta,
3480          argValues: [groupId, newName],
3481          apiImpl: this,
3482        ),
3483      );
3484    }
3485  
3486    TaskConstMeta get kCrateApiRenameGroupConstMeta => const TaskConstMeta(
3487      debugName: "rename_group",
3488      argNames: ["groupId", "newName"],
3489    );
3490  
3491    @override
3492    Future<int> crateApiRequeueFailedMessages({required List<int> contactId}) {
3493      return handler.executeNormal(
3494        NormalTask(
3495          callFfi: (port_) {
3496            final serializer = SseSerializer(generalizedFrbRustBinding);
3497            sse_encode_list_prim_u_8_loose(contactId, serializer);
3498            pdeCallFfi(
3499              generalizedFrbRustBinding,
3500              serializer,
3501              funcId: 113,
3502              port: port_,
3503            );
3504          },
3505          codec: SseCodec(
3506            decodeSuccessData: sse_decode_u_32,
3507            decodeErrorData: sse_decode_String,
3508          ),
3509          constMeta: kCrateApiRequeueFailedMessagesConstMeta,
3510          argValues: [contactId],
3511          apiImpl: this,
3512        ),
3513      );
3514    }
3515  
3516    TaskConstMeta get kCrateApiRequeueFailedMessagesConstMeta =>
3517        const TaskConstMeta(
3518          debugName: "requeue_failed_messages",
3519          argNames: ["contactId"],
3520        );
3521  
3522    @override
3523    void crateApiRetryMessage({required List<int> messageId}) {
3524      return handler.executeSync(
3525        SyncTask(
3526          callFfi: () {
3527            final serializer = SseSerializer(generalizedFrbRustBinding);
3528            sse_encode_list_prim_u_8_loose(messageId, serializer);
3529            return pdeCallFfi(
3530              generalizedFrbRustBinding,
3531              serializer,
3532              funcId: 114,
3533            )!;
3534          },
3535          codec: SseCodec(
3536            decodeSuccessData: sse_decode_unit,
3537            decodeErrorData: sse_decode_String,
3538          ),
3539          constMeta: kCrateApiRetryMessageConstMeta,
3540          argValues: [messageId],
3541          apiImpl: this,
3542        ),
3543      );
3544    }
3545  
3546    TaskConstMeta get kCrateApiRetryMessageConstMeta =>
3547        const TaskConstMeta(debugName: "retry_message", argNames: ["messageId"]);
3548  
3549    @override
3550    int crateApiRetryStuckMessages({required PlatformInt64 timeoutSecs}) {
3551      return handler.executeSync(
3552        SyncTask(
3553          callFfi: () {
3554            final serializer = SseSerializer(generalizedFrbRustBinding);
3555            sse_encode_i_64(timeoutSecs, serializer);
3556            return pdeCallFfi(
3557              generalizedFrbRustBinding,
3558              serializer,
3559              funcId: 115,
3560            )!;
3561          },
3562          codec: SseCodec(
3563            decodeSuccessData: sse_decode_i_32,
3564            decodeErrorData: null,
3565          ),
3566          constMeta: kCrateApiRetryStuckMessagesConstMeta,
3567          argValues: [timeoutSecs],
3568          apiImpl: this,
3569        ),
3570      );
3571    }
3572  
3573    TaskConstMeta get kCrateApiRetryStuckMessagesConstMeta => const TaskConstMeta(
3574      debugName: "retry_stuck_messages",
3575      argNames: ["timeoutSecs"],
3576    );
3577  
3578    @override
3579    int crateApiRunMaintenance() {
3580      return handler.executeSync(
3581        SyncTask(
3582          callFfi: () {
3583            final serializer = SseSerializer(generalizedFrbRustBinding);
3584            return pdeCallFfi(
3585              generalizedFrbRustBinding,
3586              serializer,
3587              funcId: 116,
3588            )!;
3589          },
3590          codec: SseCodec(
3591            decodeSuccessData: sse_decode_u_32,
3592            decodeErrorData: sse_decode_String,
3593          ),
3594          constMeta: kCrateApiRunMaintenanceConstMeta,
3595          argValues: [],
3596          apiImpl: this,
3597        ),
3598      );
3599    }
3600  
3601    TaskConstMeta get kCrateApiRunMaintenanceConstMeta =>
3602        const TaskConstMeta(debugName: "run_maintenance", argNames: []);
3603  
3604    @override
3605    List<SearchResultInfo> crateApiSearchAllMessages({
3606      required String query,
3607      required int limit,
3608    }) {
3609      return handler.executeSync(
3610        SyncTask(
3611          callFfi: () {
3612            final serializer = SseSerializer(generalizedFrbRustBinding);
3613            sse_encode_String(query, serializer);
3614            sse_encode_u_32(limit, serializer);
3615            return pdeCallFfi(
3616              generalizedFrbRustBinding,
3617              serializer,
3618              funcId: 117,
3619            )!;
3620          },
3621          codec: SseCodec(
3622            decodeSuccessData: sse_decode_list_search_result_info,
3623            decodeErrorData: sse_decode_String,
3624          ),
3625          constMeta: kCrateApiSearchAllMessagesConstMeta,
3626          argValues: [query, limit],
3627          apiImpl: this,
3628        ),
3629      );
3630    }
3631  
3632    TaskConstMeta get kCrateApiSearchAllMessagesConstMeta => const TaskConstMeta(
3633      debugName: "search_all_messages",
3634      argNames: ["query", "limit"],
3635    );
3636  
3637    @override
3638    List<SearchResultInfo> crateApiSearchConversation({
3639      required List<int> contactId,
3640      required String query,
3641      required int limit,
3642    }) {
3643      return handler.executeSync(
3644        SyncTask(
3645          callFfi: () {
3646            final serializer = SseSerializer(generalizedFrbRustBinding);
3647            sse_encode_list_prim_u_8_loose(contactId, serializer);
3648            sse_encode_String(query, serializer);
3649            sse_encode_u_32(limit, serializer);
3650            return pdeCallFfi(
3651              generalizedFrbRustBinding,
3652              serializer,
3653              funcId: 118,
3654            )!;
3655          },
3656          codec: SseCodec(
3657            decodeSuccessData: sse_decode_list_search_result_info,
3658            decodeErrorData: sse_decode_String,
3659          ),
3660          constMeta: kCrateApiSearchConversationConstMeta,
3661          argValues: [contactId, query, limit],
3662          apiImpl: this,
3663        ),
3664      );
3665    }
3666  
3667    TaskConstMeta get kCrateApiSearchConversationConstMeta => const TaskConstMeta(
3668      debugName: "search_conversation",
3669      argNames: ["contactId", "query", "limit"],
3670    );
3671  
3672    @override
3673    Future<Uint8List> crateApiSendDocument({
3674      required List<int> recipientId,
3675      required List<int> content,
3676      required String filename,
3677      int? ttlDays,
3678    }) {
3679      return handler.executeNormal(
3680        NormalTask(
3681          callFfi: (port_) {
3682            final serializer = SseSerializer(generalizedFrbRustBinding);
3683            sse_encode_list_prim_u_8_loose(recipientId, serializer);
3684            sse_encode_list_prim_u_8_loose(content, serializer);
3685            sse_encode_String(filename, serializer);
3686            sse_encode_opt_box_autoadd_u_32(ttlDays, serializer);
3687            pdeCallFfi(
3688              generalizedFrbRustBinding,
3689              serializer,
3690              funcId: 119,
3691              port: port_,
3692            );
3693          },
3694          codec: SseCodec(
3695            decodeSuccessData: sse_decode_list_prim_u_8_strict,
3696            decodeErrorData: sse_decode_String,
3697          ),
3698          constMeta: kCrateApiSendDocumentConstMeta,
3699          argValues: [recipientId, content, filename, ttlDays],
3700          apiImpl: this,
3701        ),
3702      );
3703    }
3704  
3705    TaskConstMeta get kCrateApiSendDocumentConstMeta => const TaskConstMeta(
3706      debugName: "send_document",
3707      argNames: ["recipientId", "content", "filename", "ttlDays"],
3708    );
3709  
3710    @override
3711    Future<Uint8List> crateApiSendGroupDocument({
3712      required List<int> groupId,
3713      required List<int> content,
3714      required String filename,
3715    }) {
3716      return handler.executeNormal(
3717        NormalTask(
3718          callFfi: (port_) {
3719            final serializer = SseSerializer(generalizedFrbRustBinding);
3720            sse_encode_list_prim_u_8_loose(groupId, serializer);
3721            sse_encode_list_prim_u_8_loose(content, serializer);
3722            sse_encode_String(filename, serializer);
3723            pdeCallFfi(
3724              generalizedFrbRustBinding,
3725              serializer,
3726              funcId: 120,
3727              port: port_,
3728            );
3729          },
3730          codec: SseCodec(
3731            decodeSuccessData: sse_decode_list_prim_u_8_strict,
3732            decodeErrorData: sse_decode_String,
3733          ),
3734          constMeta: kCrateApiSendGroupDocumentConstMeta,
3735          argValues: [groupId, content, filename],
3736          apiImpl: this,
3737        ),
3738      );
3739    }
3740  
3741    TaskConstMeta get kCrateApiSendGroupDocumentConstMeta => const TaskConstMeta(
3742      debugName: "send_group_document",
3743      argNames: ["groupId", "content", "filename"],
3744    );
3745  
3746    @override
3747    Future<Uint8List> crateApiSendGroupMessage({
3748      required List<int> groupId,
3749      required List<int> content,
3750      required int contentType,
3751      String? filename,
3752    }) {
3753      return handler.executeNormal(
3754        NormalTask(
3755          callFfi: (port_) {
3756            final serializer = SseSerializer(generalizedFrbRustBinding);
3757            sse_encode_list_prim_u_8_loose(groupId, serializer);
3758            sse_encode_list_prim_u_8_loose(content, serializer);
3759            sse_encode_u_8(contentType, serializer);
3760            sse_encode_opt_String(filename, serializer);
3761            pdeCallFfi(
3762              generalizedFrbRustBinding,
3763              serializer,
3764              funcId: 121,
3765              port: port_,
3766            );
3767          },
3768          codec: SseCodec(
3769            decodeSuccessData: sse_decode_list_prim_u_8_strict,
3770            decodeErrorData: sse_decode_String,
3771          ),
3772          constMeta: kCrateApiSendGroupMessageConstMeta,
3773          argValues: [groupId, content, contentType, filename],
3774          apiImpl: this,
3775        ),
3776      );
3777    }
3778  
3779    TaskConstMeta get kCrateApiSendGroupMessageConstMeta => const TaskConstMeta(
3780      debugName: "send_group_message",
3781      argNames: ["groupId", "content", "contentType", "filename"],
3782    );
3783  
3784    @override
3785    Future<Uint8List> crateApiSendMessage({
3786      required List<int> recipientId,
3787      required List<int> content,
3788      required int contentType,
3789      String? filename,
3790      int? ttlDays,
3791    }) {
3792      return handler.executeNormal(
3793        NormalTask(
3794          callFfi: (port_) {
3795            final serializer = SseSerializer(generalizedFrbRustBinding);
3796            sse_encode_list_prim_u_8_loose(recipientId, serializer);
3797            sse_encode_list_prim_u_8_loose(content, serializer);
3798            sse_encode_u_8(contentType, serializer);
3799            sse_encode_opt_String(filename, serializer);
3800            sse_encode_opt_box_autoadd_u_32(ttlDays, serializer);
3801            pdeCallFfi(
3802              generalizedFrbRustBinding,
3803              serializer,
3804              funcId: 122,
3805              port: port_,
3806            );
3807          },
3808          codec: SseCodec(
3809            decodeSuccessData: sse_decode_list_prim_u_8_strict,
3810            decodeErrorData: sse_decode_String,
3811          ),
3812          constMeta: kCrateApiSendMessageConstMeta,
3813          argValues: [recipientId, content, contentType, filename, ttlDays],
3814          apiImpl: this,
3815        ),
3816      );
3817    }
3818  
3819    TaskConstMeta get kCrateApiSendMessageConstMeta => const TaskConstMeta(
3820      debugName: "send_message",
3821      argNames: ["recipientId", "content", "contentType", "filename", "ttlDays"],
3822    );
3823  
3824    @override
3825    Future<void> crateApiSendViaIroh({
3826      required String endpointId,
3827      required List<int> payload,
3828    }) {
3829      return handler.executeNormal(
3830        NormalTask(
3831          callFfi: (port_) {
3832            final serializer = SseSerializer(generalizedFrbRustBinding);
3833            sse_encode_String(endpointId, serializer);
3834            sse_encode_list_prim_u_8_loose(payload, serializer);
3835            pdeCallFfi(
3836              generalizedFrbRustBinding,
3837              serializer,
3838              funcId: 123,
3839              port: port_,
3840            );
3841          },
3842          codec: SseCodec(
3843            decodeSuccessData: sse_decode_unit,
3844            decodeErrorData: sse_decode_String,
3845          ),
3846          constMeta: kCrateApiSendViaIrohConstMeta,
3847          argValues: [endpointId, payload],
3848          apiImpl: this,
3849        ),
3850      );
3851    }
3852  
3853    TaskConstMeta get kCrateApiSendViaIrohConstMeta => const TaskConstMeta(
3854      debugName: "send_via_iroh",
3855      argNames: ["endpointId", "payload"],
3856    );
3857  
3858    @override
3859    void crateApiSetContactIrohEndpoint({
3860      required List<int> contactId,
3861      required String endpointId,
3862    }) {
3863      return handler.executeSync(
3864        SyncTask(
3865          callFfi: () {
3866            final serializer = SseSerializer(generalizedFrbRustBinding);
3867            sse_encode_list_prim_u_8_loose(contactId, serializer);
3868            sse_encode_String(endpointId, serializer);
3869            return pdeCallFfi(
3870              generalizedFrbRustBinding,
3871              serializer,
3872              funcId: 124,
3873            )!;
3874          },
3875          codec: SseCodec(
3876            decodeSuccessData: sse_decode_unit,
3877            decodeErrorData: sse_decode_String,
3878          ),
3879          constMeta: kCrateApiSetContactIrohEndpointConstMeta,
3880          argValues: [contactId, endpointId],
3881          apiImpl: this,
3882        ),
3883      );
3884    }
3885  
3886    TaskConstMeta get kCrateApiSetContactIrohEndpointConstMeta =>
3887        const TaskConstMeta(
3888          debugName: "set_contact_iroh_endpoint",
3889          argNames: ["contactId", "endpointId"],
3890        );
3891  
3892    @override
3893    void crateApiSetContactMuted({
3894      required List<int> contactId,
3895      required bool muted,
3896    }) {
3897      return handler.executeSync(
3898        SyncTask(
3899          callFfi: () {
3900            final serializer = SseSerializer(generalizedFrbRustBinding);
3901            sse_encode_list_prim_u_8_loose(contactId, serializer);
3902            sse_encode_bool(muted, serializer);
3903            return pdeCallFfi(
3904              generalizedFrbRustBinding,
3905              serializer,
3906              funcId: 125,
3907            )!;
3908          },
3909          codec: SseCodec(
3910            decodeSuccessData: sse_decode_unit,
3911            decodeErrorData: sse_decode_String,
3912          ),
3913          constMeta: kCrateApiSetContactMutedConstMeta,
3914          argValues: [contactId, muted],
3915          apiImpl: this,
3916        ),
3917      );
3918    }
3919  
3920    TaskConstMeta get kCrateApiSetContactMutedConstMeta => const TaskConstMeta(
3921      debugName: "set_contact_muted",
3922      argNames: ["contactId", "muted"],
3923    );
3924  
3925    @override
3926    void crateApiSetDisappearingDuration({
3927      required List<int> contactId,
3928      required BigInt durationSecs,
3929    }) {
3930      return handler.executeSync(
3931        SyncTask(
3932          callFfi: () {
3933            final serializer = SseSerializer(generalizedFrbRustBinding);
3934            sse_encode_list_prim_u_8_loose(contactId, serializer);
3935            sse_encode_u_64(durationSecs, serializer);
3936            return pdeCallFfi(
3937              generalizedFrbRustBinding,
3938              serializer,
3939              funcId: 126,
3940            )!;
3941          },
3942          codec: SseCodec(
3943            decodeSuccessData: sse_decode_unit,
3944            decodeErrorData: sse_decode_String,
3945          ),
3946          constMeta: kCrateApiSetDisappearingDurationConstMeta,
3947          argValues: [contactId, durationSecs],
3948          apiImpl: this,
3949        ),
3950      );
3951    }
3952  
3953    TaskConstMeta get kCrateApiSetDisappearingDurationConstMeta =>
3954        const TaskConstMeta(
3955          debugName: "set_disappearing_duration",
3956          argNames: ["contactId", "durationSecs"],
3957        );
3958  
3959    @override
3960    void crateApiSetGroupDisappearing({
3961      required List<int> groupId,
3962      required BigInt duration,
3963    }) {
3964      return handler.executeSync(
3965        SyncTask(
3966          callFfi: () {
3967            final serializer = SseSerializer(generalizedFrbRustBinding);
3968            sse_encode_list_prim_u_8_loose(groupId, serializer);
3969            sse_encode_u_64(duration, serializer);
3970            return pdeCallFfi(
3971              generalizedFrbRustBinding,
3972              serializer,
3973              funcId: 127,
3974            )!;
3975          },
3976          codec: SseCodec(
3977            decodeSuccessData: sse_decode_unit,
3978            decodeErrorData: sse_decode_String,
3979          ),
3980          constMeta: kCrateApiSetGroupDisappearingConstMeta,
3981          argValues: [groupId, duration],
3982          apiImpl: this,
3983        ),
3984      );
3985    }
3986  
3987    TaskConstMeta get kCrateApiSetGroupDisappearingConstMeta =>
3988        const TaskConstMeta(
3989          debugName: "set_group_disappearing",
3990          argNames: ["groupId", "duration"],
3991        );
3992  
3993    @override
3994    void crateApiSetGroupMuted({
3995      required List<int> groupId,
3996      required bool isMuted,
3997    }) {
3998      return handler.executeSync(
3999        SyncTask(
4000          callFfi: () {
4001            final serializer = SseSerializer(generalizedFrbRustBinding);
4002            sse_encode_list_prim_u_8_loose(groupId, serializer);
4003            sse_encode_bool(isMuted, serializer);
4004            return pdeCallFfi(
4005              generalizedFrbRustBinding,
4006              serializer,
4007              funcId: 128,
4008            )!;
4009          },
4010          codec: SseCodec(
4011            decodeSuccessData: sse_decode_unit,
4012            decodeErrorData: sse_decode_String,
4013          ),
4014          constMeta: kCrateApiSetGroupMutedConstMeta,
4015          argValues: [groupId, isMuted],
4016          apiImpl: this,
4017        ),
4018      );
4019    }
4020  
4021    TaskConstMeta get kCrateApiSetGroupMutedConstMeta => const TaskConstMeta(
4022      debugName: "set_group_muted",
4023      argNames: ["groupId", "isMuted"],
4024    );
4025  
4026    @override
4027    Future<void> crateApiSetOutboundTransport({
4028      required List<Uint8List> messageIds,
4029      required String transport,
4030    }) {
4031      return handler.executeNormal(
4032        NormalTask(
4033          callFfi: (port_) {
4034            final serializer = SseSerializer(generalizedFrbRustBinding);
4035            sse_encode_list_list_prim_u_8_strict(messageIds, serializer);
4036            sse_encode_String(transport, serializer);
4037            pdeCallFfi(
4038              generalizedFrbRustBinding,
4039              serializer,
4040              funcId: 129,
4041              port: port_,
4042            );
4043          },
4044          codec: SseCodec(
4045            decodeSuccessData: sse_decode_unit,
4046            decodeErrorData: sse_decode_String,
4047          ),
4048          constMeta: kCrateApiSetOutboundTransportConstMeta,
4049          argValues: [messageIds, transport],
4050          apiImpl: this,
4051        ),
4052      );
4053    }
4054  
4055    TaskConstMeta get kCrateApiSetOutboundTransportConstMeta =>
4056        const TaskConstMeta(
4057          debugName: "set_outbound_transport",
4058          argNames: ["messageIds", "transport"],
4059        );
4060  
4061    @override
4062    void crateApiSetTransportPreference({
4063      required NetworkTransportPreference preference,
4064    }) {
4065      return handler.executeSync(
4066        SyncTask(
4067          callFfi: () {
4068            final serializer = SseSerializer(generalizedFrbRustBinding);
4069            sse_encode_network_transport_preference(preference, serializer);
4070            return pdeCallFfi(
4071              generalizedFrbRustBinding,
4072              serializer,
4073              funcId: 130,
4074            )!;
4075          },
4076          codec: SseCodec(
4077            decodeSuccessData: sse_decode_unit,
4078            decodeErrorData: sse_decode_String,
4079          ),
4080          constMeta: kCrateApiSetTransportPreferenceConstMeta,
4081          argValues: [preference],
4082          apiImpl: this,
4083        ),
4084      );
4085    }
4086  
4087    TaskConstMeta get kCrateApiSetTransportPreferenceConstMeta =>
4088        const TaskConstMeta(
4089          debugName: "set_transport_preference",
4090          argNames: ["preference"],
4091        );
4092  
4093    @override
4094    Future<void> crateApiStartIroh() {
4095      return handler.executeNormal(
4096        NormalTask(
4097          callFfi: (port_) {
4098            final serializer = SseSerializer(generalizedFrbRustBinding);
4099            pdeCallFfi(
4100              generalizedFrbRustBinding,
4101              serializer,
4102              funcId: 131,
4103              port: port_,
4104            );
4105          },
4106          codec: SseCodec(
4107            decodeSuccessData: sse_decode_unit,
4108            decodeErrorData: sse_decode_String,
4109          ),
4110          constMeta: kCrateApiStartIrohConstMeta,
4111          argValues: [],
4112          apiImpl: this,
4113        ),
4114      );
4115    }
4116  
4117    TaskConstMeta get kCrateApiStartIrohConstMeta =>
4118        const TaskConstMeta(debugName: "start_iroh", argNames: []);
4119  
4120    @override
4121    Future<void> crateApiStopIroh() {
4122      return handler.executeNormal(
4123        NormalTask(
4124          callFfi: (port_) {
4125            final serializer = SseSerializer(generalizedFrbRustBinding);
4126            pdeCallFfi(
4127              generalizedFrbRustBinding,
4128              serializer,
4129              funcId: 132,
4130              port: port_,
4131            );
4132          },
4133          codec: SseCodec(
4134            decodeSuccessData: sse_decode_unit,
4135            decodeErrorData: sse_decode_String,
4136          ),
4137          constMeta: kCrateApiStopIrohConstMeta,
4138          argValues: [],
4139          apiImpl: this,
4140        ),
4141      );
4142    }
4143  
4144    TaskConstMeta get kCrateApiStopIrohConstMeta =>
4145        const TaskConstMeta(debugName: "stop_iroh", argNames: []);
4146  
4147    @override
4148    bool crateApiToggleReaction({
4149      required List<int> messageId,
4150      required String emoji,
4151    }) {
4152      return handler.executeSync(
4153        SyncTask(
4154          callFfi: () {
4155            final serializer = SseSerializer(generalizedFrbRustBinding);
4156            sse_encode_list_prim_u_8_loose(messageId, serializer);
4157            sse_encode_String(emoji, serializer);
4158            return pdeCallFfi(
4159              generalizedFrbRustBinding,
4160              serializer,
4161              funcId: 133,
4162            )!;
4163          },
4164          codec: SseCodec(
4165            decodeSuccessData: sse_decode_bool,
4166            decodeErrorData: sse_decode_String,
4167          ),
4168          constMeta: kCrateApiToggleReactionConstMeta,
4169          argValues: [messageId, emoji],
4170          apiImpl: this,
4171        ),
4172      );
4173    }
4174  
4175    TaskConstMeta get kCrateApiToggleReactionConstMeta => const TaskConstMeta(
4176      debugName: "toggle_reaction",
4177      argNames: ["messageId", "emoji"],
4178    );
4179  
4180    @override
4181    Future<TransportAddressDto?> crateApiTransportAddressDtoFromInternal({
4182      required TransportAddress addr,
4183    }) {
4184      return handler.executeNormal(
4185        NormalTask(
4186          callFfi: (port_) {
4187            final serializer = SseSerializer(generalizedFrbRustBinding);
4188            sse_encode_box_autoadd_transport_address(addr, serializer);
4189            pdeCallFfi(
4190              generalizedFrbRustBinding,
4191              serializer,
4192              funcId: 134,
4193              port: port_,
4194            );
4195          },
4196          codec: SseCodec(
4197            decodeSuccessData: sse_decode_opt_box_autoadd_transport_address_dto,
4198            decodeErrorData: null,
4199          ),
4200          constMeta: kCrateApiTransportAddressDtoFromInternalConstMeta,
4201          argValues: [addr],
4202          apiImpl: this,
4203        ),
4204      );
4205    }
4206  
4207    TaskConstMeta get kCrateApiTransportAddressDtoFromInternalConstMeta =>
4208        const TaskConstMeta(
4209          debugName: "transport_address_dto_from_internal",
4210          argNames: ["addr"],
4211        );
4212  
4213    @override
4214    Future<TransportStatsInfo> crateApiTransportStatsInfoDefault() {
4215      return handler.executeNormal(
4216        NormalTask(
4217          callFfi: (port_) {
4218            final serializer = SseSerializer(generalizedFrbRustBinding);
4219            pdeCallFfi(
4220              generalizedFrbRustBinding,
4221              serializer,
4222              funcId: 135,
4223              port: port_,
4224            );
4225          },
4226          codec: SseCodec(
4227            decodeSuccessData: sse_decode_transport_stats_info,
4228            decodeErrorData: null,
4229          ),
4230          constMeta: kCrateApiTransportStatsInfoDefaultConstMeta,
4231          argValues: [],
4232          apiImpl: this,
4233        ),
4234      );
4235    }
4236  
4237    TaskConstMeta get kCrateApiTransportStatsInfoDefaultConstMeta =>
4238        const TaskConstMeta(
4239          debugName: "transport_stats_info_default",
4240          argNames: [],
4241        );
4242  
4243    @override
4244    Future<TransportTypeDto?> crateApiTransportTypeDtoFromInternal({
4245      required TransportType tt,
4246    }) {
4247      return handler.executeNormal(
4248        NormalTask(
4249          callFfi: (port_) {
4250            final serializer = SseSerializer(generalizedFrbRustBinding);
4251            sse_encode_transport_type(tt, serializer);
4252            pdeCallFfi(
4253              generalizedFrbRustBinding,
4254              serializer,
4255              funcId: 136,
4256              port: port_,
4257            );
4258          },
4259          codec: SseCodec(
4260            decodeSuccessData: sse_decode_opt_box_autoadd_transport_type_dto,
4261            decodeErrorData: null,
4262          ),
4263          constMeta: kCrateApiTransportTypeDtoFromInternalConstMeta,
4264          argValues: [tt],
4265          apiImpl: this,
4266        ),
4267      );
4268    }
4269  
4270    TaskConstMeta get kCrateApiTransportTypeDtoFromInternalConstMeta =>
4271        const TaskConstMeta(
4272          debugName: "transport_type_dto_from_internal",
4273          argNames: ["tt"],
4274        );
4275  
4276    @override
4277    Future<TransportType> crateApiTransportTypeDtoToInternal({
4278      required TransportTypeDto that,
4279    }) {
4280      return handler.executeNormal(
4281        NormalTask(
4282          callFfi: (port_) {
4283            final serializer = SseSerializer(generalizedFrbRustBinding);
4284            sse_encode_transport_type_dto(that, serializer);
4285            pdeCallFfi(
4286              generalizedFrbRustBinding,
4287              serializer,
4288              funcId: 137,
4289              port: port_,
4290            );
4291          },
4292          codec: SseCodec(
4293            decodeSuccessData: sse_decode_transport_type,
4294            decodeErrorData: null,
4295          ),
4296          constMeta: kCrateApiTransportTypeDtoToInternalConstMeta,
4297          argValues: [that],
4298          apiImpl: this,
4299        ),
4300      );
4301    }
4302  
4303    TaskConstMeta get kCrateApiTransportTypeDtoToInternalConstMeta =>
4304        const TaskConstMeta(
4305          debugName: "transport_type_dto_to_internal",
4306          argNames: ["that"],
4307        );
4308  
4309    @override
4310    void crateApiUnblockContact({required List<int> contactId}) {
4311      return handler.executeSync(
4312        SyncTask(
4313          callFfi: () {
4314            final serializer = SseSerializer(generalizedFrbRustBinding);
4315            sse_encode_list_prim_u_8_loose(contactId, serializer);
4316            return pdeCallFfi(
4317              generalizedFrbRustBinding,
4318              serializer,
4319              funcId: 138,
4320            )!;
4321          },
4322          codec: SseCodec(
4323            decodeSuccessData: sse_decode_unit,
4324            decodeErrorData: sse_decode_String,
4325          ),
4326          constMeta: kCrateApiUnblockContactConstMeta,
4327          argValues: [contactId],
4328          apiImpl: this,
4329        ),
4330      );
4331    }
4332  
4333    TaskConstMeta get kCrateApiUnblockContactConstMeta => const TaskConstMeta(
4334      debugName: "unblock_contact",
4335      argNames: ["contactId"],
4336    );
4337  
4338    @override
4339    void crateApiUpdateContactNickname({
4340      required List<int> contactId,
4341      String? nickname,
4342    }) {
4343      return handler.executeSync(
4344        SyncTask(
4345          callFfi: () {
4346            final serializer = SseSerializer(generalizedFrbRustBinding);
4347            sse_encode_list_prim_u_8_loose(contactId, serializer);
4348            sse_encode_opt_String(nickname, serializer);
4349            return pdeCallFfi(
4350              generalizedFrbRustBinding,
4351              serializer,
4352              funcId: 139,
4353            )!;
4354          },
4355          codec: SseCodec(
4356            decodeSuccessData: sse_decode_unit,
4357            decodeErrorData: sse_decode_String,
4358          ),
4359          constMeta: kCrateApiUpdateContactNicknameConstMeta,
4360          argValues: [contactId, nickname],
4361          apiImpl: this,
4362        ),
4363      );
4364    }
4365  
4366    TaskConstMeta get kCrateApiUpdateContactNicknameConstMeta =>
4367        const TaskConstMeta(
4368          debugName: "update_contact_nickname",
4369          argNames: ["contactId", "nickname"],
4370        );
4371  
4372    @protected
4373    String dco_decode_String(dynamic raw) {
4374      // Codec=Dco (DartCObject based), see doc to use other codecs
4375      return raw as String;
4376    }
4377  
4378    @protected
4379    AchievementInfo dco_decode_achievement_info(dynamic raw) {
4380      // Codec=Dco (DartCObject based), see doc to use other codecs
4381      final arr = raw as List<dynamic>;
4382      if (arr.length != 4)
4383        throw Exception('unexpected arr length: expect 4 but see ${arr.length}');
4384      return AchievementInfo(
4385        id: dco_decode_u_8(arr[0]),
4386        name: dco_decode_String(arr[1]),
4387        description: dco_decode_String(arr[2]),
4388        unlocked: dco_decode_bool(arr[3]),
4389      );
4390    }
4391  
4392    @protected
4393    bool dco_decode_bool(dynamic raw) {
4394      // Codec=Dco (DartCObject based), see doc to use other codecs
4395      return raw as bool;
4396    }
4397  
4398    @protected
4399    DhtState dco_decode_box_autoadd_dht_state(dynamic raw) {
4400      // Codec=Dco (DartCObject based), see doc to use other codecs
4401      return dco_decode_dht_state(raw);
4402    }
4403  
4404    @protected
4405    ExchangeHandle dco_decode_box_autoadd_exchange_handle(dynamic raw) {
4406      // Codec=Dco (DartCObject based), see doc to use other codecs
4407      return dco_decode_exchange_handle(raw);
4408    }
4409  
4410    @protected
4411    GossipExchangeHandle dco_decode_box_autoadd_gossip_exchange_handle(
4412      dynamic raw,
4413    ) {
4414      // Codec=Dco (DartCObject based), see doc to use other codecs
4415      return dco_decode_gossip_exchange_handle(raw);
4416    }
4417  
4418    @protected
4419    HandshakeHandle dco_decode_box_autoadd_handshake_handle(dynamic raw) {
4420      // Codec=Dco (DartCObject based), see doc to use other codecs
4421      return dco_decode_handshake_handle(raw);
4422    }
4423  
4424    @protected
4425    PlatformInt64 dco_decode_box_autoadd_i_64(dynamic raw) {
4426      // Codec=Dco (DartCObject based), see doc to use other codecs
4427      return dco_decode_i_64(raw);
4428    }
4429  
4430    @protected
4431    IrohIncomingMessage dco_decode_box_autoadd_iroh_incoming_message(
4432      dynamic raw,
4433    ) {
4434      // Codec=Dco (DartCObject based), see doc to use other codecs
4435      return dco_decode_iroh_incoming_message(raw);
4436    }
4437  
4438    @protected
4439    MessageInfo dco_decode_box_autoadd_message_info(dynamic raw) {
4440      // Codec=Dco (DartCObject based), see doc to use other codecs
4441      return dco_decode_message_info(raw);
4442    }
4443  
4444    @protected
4445    PendingContact dco_decode_box_autoadd_pending_contact(dynamic raw) {
4446      // Codec=Dco (DartCObject based), see doc to use other codecs
4447      return dco_decode_pending_contact(raw);
4448    }
4449  
4450    @protected
4451    (String, BigInt) dco_decode_box_autoadd_record_string_u_64(dynamic raw) {
4452      // Codec=Dco (DartCObject based), see doc to use other codecs
4453      return raw as (String, BigInt);
4454    }
4455  
4456    @protected
4457    (int, int) dco_decode_box_autoadd_record_u_32_u_32(dynamic raw) {
4458      // Codec=Dco (DartCObject based), see doc to use other codecs
4459      return raw as (int, int);
4460    }
4461  
4462    @protected
4463    RelayState dco_decode_box_autoadd_relay_state(dynamic raw) {
4464      // Codec=Dco (DartCObject based), see doc to use other codecs
4465      return dco_decode_relay_state(raw);
4466    }
4467  
4468    @protected
4469    TransportAddress dco_decode_box_autoadd_transport_address(dynamic raw) {
4470      // Codec=Dco (DartCObject based), see doc to use other codecs
4471      return dco_decode_transport_address(raw);
4472    }
4473  
4474    @protected
4475    TransportAddressDto dco_decode_box_autoadd_transport_address_dto(
4476      dynamic raw,
4477    ) {
4478      // Codec=Dco (DartCObject based), see doc to use other codecs
4479      return dco_decode_transport_address_dto(raw);
4480    }
4481  
4482    @protected
4483    TransportTypeDto dco_decode_box_autoadd_transport_type_dto(dynamic raw) {
4484      // Codec=Dco (DartCObject based), see doc to use other codecs
4485      return dco_decode_transport_type_dto(raw);
4486    }
4487  
4488    @protected
4489    int dco_decode_box_autoadd_u_32(dynamic raw) {
4490      // Codec=Dco (DartCObject based), see doc to use other codecs
4491      return raw as int;
4492    }
4493  
4494    @protected
4495    CachedIrohEndpoint dco_decode_cached_iroh_endpoint(dynamic raw) {
4496      // Codec=Dco (DartCObject based), see doc to use other codecs
4497      final arr = raw as List<dynamic>;
4498      if (arr.length != 2)
4499        throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
4500      return CachedIrohEndpoint(
4501        contactId: dco_decode_list_prim_u_8_strict(arr[0]),
4502        endpointId: dco_decode_String(arr[1]),
4503      );
4504    }
4505  
4506    @protected
4507    CachedOnionAddress dco_decode_cached_onion_address(dynamic raw) {
4508      // Codec=Dco (DartCObject based), see doc to use other codecs
4509      final arr = raw as List<dynamic>;
4510      if (arr.length != 2)
4511        throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
4512      return CachedOnionAddress(
4513        contactId: dco_decode_list_prim_u_8_strict(arr[0]),
4514        onionAddress: dco_decode_String(arr[1]),
4515      );
4516    }
4517  
4518    @protected
4519    ContactInfo dco_decode_contact_info(dynamic raw) {
4520      // Codec=Dco (DartCObject based), see doc to use other codecs
4521      final arr = raw as List<dynamic>;
4522      if (arr.length != 10)
4523        throw Exception('unexpected arr length: expect 10 but see ${arr.length}');
4524      return ContactInfo(
4525        contactId: dco_decode_list_prim_u_8_strict(arr[0]),
4526        nickname: dco_decode_opt_String(arr[1]),
4527        state: dco_decode_u_8(arr[2]),
4528        fingerprint: dco_decode_String(arr[3]),
4529        createdAt: dco_decode_i_64(arr[4]),
4530        lastSeen: dco_decode_opt_box_autoadd_i_64(arr[5]),
4531        queuedCount: dco_decode_u_32(arr[6]),
4532        unreadCount: dco_decode_u_32(arr[7]),
4533        disappearingDuration: dco_decode_u_64(arr[8]),
4534        isMuted: dco_decode_bool(arr[9]),
4535      );
4536    }
4537  
4538    @protected
4539    DhtFetchResult dco_decode_dht_fetch_result(dynamic raw) {
4540      // Codec=Dco (DartCObject based), see doc to use other codecs
4541      final arr = raw as List<dynamic>;
4542      if (arr.length != 3)
4543        throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
4544      return DhtFetchResult(
4545        messages: dco_decode_list_message_info(arr[0]),
4546        contactsWithReactions: dco_decode_list_list_prim_u_8_strict(arr[1]),
4547        hadGroupManagement: dco_decode_bool(arr[2]),
4548      );
4549    }
4550  
4551    @protected
4552    DhtPublishResult dco_decode_dht_publish_result(dynamic raw) {
4553      // Codec=Dco (DartCObject based), see doc to use other codecs
4554      final arr = raw as List<dynamic>;
4555      if (arr.length != 2)
4556        throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
4557      return DhtPublishResult(
4558        publishedCount: dco_decode_u_32(arr[0]),
4559        publishedIds: dco_decode_list_list_prim_u_8_strict(arr[1]),
4560      );
4561    }
4562  
4563    @protected
4564    DhtState dco_decode_dht_state(dynamic raw) {
4565      // Codec=Dco (DartCObject based), see doc to use other codecs
4566      switch (raw[0]) {
4567        case 0:
4568          return DhtState_Disconnected();
4569        case 1:
4570          return DhtState_Bootstrapping();
4571        case 2:
4572          return DhtState_Connected(peerCount: dco_decode_usize(raw[1]));
4573        case 3:
4574          return DhtState_Failed(error: dco_decode_String(raw[1]));
4575        default:
4576          throw Exception("unreachable");
4577      }
4578    }
4579  
4580    @protected
4581    DhtStateDto dco_decode_dht_state_dto(dynamic raw) {
4582      // Codec=Dco (DartCObject based), see doc to use other codecs
4583      final arr = raw as List<dynamic>;
4584      if (arr.length != 3)
4585        throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
4586      return DhtStateDto(
4587        state: dco_decode_String(arr[0]),
4588        peerCount: dco_decode_u_32(arr[1]),
4589        error: dco_decode_opt_String(arr[2]),
4590      );
4591    }
4592  
4593    @protected
4594    DocumentInfo dco_decode_document_info(dynamic raw) {
4595      // Codec=Dco (DartCObject based), see doc to use other codecs
4596      final arr = raw as List<dynamic>;
4597      if (arr.length != 4)
4598        throw Exception('unexpected arr length: expect 4 but see ${arr.length}');
4599      return DocumentInfo(
4600        documentId: dco_decode_list_prim_u_8_strict(arr[0]),
4601        filename: dco_decode_String(arr[1]),
4602        size: dco_decode_u_64(arr[2]),
4603        content: dco_decode_list_prim_u_8_strict(arr[3]),
4604      );
4605    }
4606  
4607    @protected
4608    EncryptedPayload dco_decode_encrypted_payload(dynamic raw) {
4609      // Codec=Dco (DartCObject based), see doc to use other codecs
4610      final arr = raw as List<dynamic>;
4611      if (arr.length != 2)
4612        throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
4613      return EncryptedPayload(
4614        messageId: dco_decode_list_prim_u_8_strict(arr[0]),
4615        payload: dco_decode_list_prim_u_8_strict(arr[1]),
4616      );
4617    }
4618  
4619    @protected
4620    ExchangeComplete dco_decode_exchange_complete(dynamic raw) {
4621      // Codec=Dco (DartCObject based), see doc to use other codecs
4622      final arr = raw as List<dynamic>;
4623      if (arr.length != 3)
4624        throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
4625      return ExchangeComplete(
4626        contactId: dco_decode_list_prim_u_8_strict(arr[0]),
4627        deliveredIds: dco_decode_list_list_prim_u_8_strict(arr[1]),
4628        receivedMessages: dco_decode_list_message_info(arr[2]),
4629      );
4630    }
4631  
4632    @protected
4633    ExchangeHandle dco_decode_exchange_handle(dynamic raw) {
4634      // Codec=Dco (DartCObject based), see doc to use other codecs
4635      final arr = raw as List<dynamic>;
4636      if (arr.length != 1)
4637        throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
4638      return ExchangeHandle(id: dco_decode_u_64(arr[0]));
4639    }
4640  
4641    @protected
4642    ExchangeResultDto dco_decode_exchange_result_dto(dynamic raw) {
4643      // Codec=Dco (DartCObject based), see doc to use other codecs
4644      final arr = raw as List<dynamic>;
4645      if (arr.length != 2)
4646        throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
4647      return ExchangeResultDto(
4648        complete: dco_decode_bool(arr[0]),
4649        response: dco_decode_opt_list_prim_u_8_strict(arr[1]),
4650      );
4651    }
4652  
4653    @protected
4654    double dco_decode_f_64(dynamic raw) {
4655      // Codec=Dco (DartCObject based), see doc to use other codecs
4656      return raw as double;
4657    }
4658  
4659    @protected
4660    ForwardingInfo dco_decode_forwarding_info(dynamic raw) {
4661      // Codec=Dco (DartCObject based), see doc to use other codecs
4662      final arr = raw as List<dynamic>;
4663      if (arr.length != 5)
4664        throw Exception('unexpected arr length: expect 5 but see ${arr.length}');
4665      return ForwardingInfo(
4666        messageCount: dco_decode_u_32(arr[0]),
4667        storageUsed: dco_decode_u_64(arr[1]),
4668        storageLimit: dco_decode_u_64(arr[2]),
4669        uniqueRecipients: dco_decode_u_32(arr[3]),
4670        fillPercentage: dco_decode_f_64(arr[4]),
4671      );
4672    }
4673  
4674    @protected
4675    GossipExchangeComplete dco_decode_gossip_exchange_complete(dynamic raw) {
4676      // Codec=Dco (DartCObject based), see doc to use other codecs
4677      final arr = raw as List<dynamic>;
4678      if (arr.length != 2)
4679        throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
4680      return GossipExchangeComplete(
4681        storedCount: dco_decode_u_32(arr[0]),
4682        messagesForUsCount: dco_decode_u_32(arr[1]),
4683      );
4684    }
4685  
4686    @protected
4687    GossipExchangeHandle dco_decode_gossip_exchange_handle(dynamic raw) {
4688      // Codec=Dco (DartCObject based), see doc to use other codecs
4689      final arr = raw as List<dynamic>;
4690      if (arr.length != 1)
4691        throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
4692      return GossipExchangeHandle(id: dco_decode_u_64(arr[0]));
4693    }
4694  
4695    @protected
4696    GossipFinalizeKeepTransportResult
4697    dco_decode_gossip_finalize_keep_transport_result(dynamic raw) {
4698      // Codec=Dco (DartCObject based), see doc to use other codecs
4699      final arr = raw as List<dynamic>;
4700      if (arr.length != 2)
4701        throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
4702      return GossipFinalizeKeepTransportResult(
4703        result: dco_decode_gossip_exchange_complete(arr[0]),
4704        transportHandle: dco_decode_u_64(arr[1]),
4705      );
4706    }
4707  
4708    @protected
4709    GossipResult dco_decode_gossip_result(dynamic raw) {
4710      // Codec=Dco (DartCObject based), see doc to use other codecs
4711      final arr = raw as List<dynamic>;
4712      if (arr.length != 2)
4713        throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
4714      return GossipResult(
4715        storedCount: dco_decode_u_32(arr[0]),
4716        messagesForUs: dco_decode_u_32(arr[1]),
4717      );
4718    }
4719  
4720    @protected
4721    GroupInfo dco_decode_group_info(dynamic raw) {
4722      // Codec=Dco (DartCObject based), see doc to use other codecs
4723      final arr = raw as List<dynamic>;
4724      if (arr.length != 10)
4725        throw Exception('unexpected arr length: expect 10 but see ${arr.length}');
4726      return GroupInfo(
4727        groupId: dco_decode_list_prim_u_8_strict(arr[0]),
4728        name: dco_decode_String(arr[1]),
4729        createdAt: dco_decode_i_64(arr[2]),
4730        memberCount: dco_decode_u_32(arr[3]),
4731        unreadCount: dco_decode_u_32(arr[4]),
4732        disappearingDuration: dco_decode_u_64(arr[5]),
4733        isMuted: dco_decode_bool(arr[6]),
4734        lastMessageAt: dco_decode_opt_box_autoadd_i_64(arr[7]),
4735        accepted: dco_decode_bool(arr[8]),
4736        isCreator: dco_decode_bool(arr[9]),
4737      );
4738    }
4739  
4740    @protected
4741    GroupMemberInfoDto dco_decode_group_member_info_dto(dynamic raw) {
4742      // Codec=Dco (DartCObject based), see doc to use other codecs
4743      final arr = raw as List<dynamic>;
4744      if (arr.length != 3)
4745        throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
4746      return GroupMemberInfoDto(
4747        contactId: dco_decode_list_prim_u_8_strict(arr[0]),
4748        nickname: dco_decode_opt_String(arr[1]),
4749        role: dco_decode_u_8(arr[2]),
4750      );
4751    }
4752  
4753    @protected
4754    HandshakeHandle dco_decode_handshake_handle(dynamic raw) {
4755      // Codec=Dco (DartCObject based), see doc to use other codecs
4756      final arr = raw as List<dynamic>;
4757      if (arr.length != 1)
4758        throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
4759      return HandshakeHandle(id: dco_decode_u_64(arr[0]));
4760    }
4761  
4762    @protected
4763    HandshakeResult dco_decode_handshake_result(dynamic raw) {
4764      // Codec=Dco (DartCObject based), see doc to use other codecs
4765      final arr = raw as List<dynamic>;
4766      if (arr.length != 3)
4767        throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
4768      return HandshakeResult(
4769        complete: dco_decode_bool(arr[0]),
4770        response: dco_decode_opt_list_prim_u_8_strict(arr[1]),
4771        remoteIdentity: dco_decode_opt_list_prim_u_8_strict(arr[2]),
4772      );
4773    }
4774  
4775    @protected
4776    int dco_decode_i_32(dynamic raw) {
4777      // Codec=Dco (DartCObject based), see doc to use other codecs
4778      return raw as int;
4779    }
4780  
4781    @protected
4782    PlatformInt64 dco_decode_i_64(dynamic raw) {
4783      // Codec=Dco (DartCObject based), see doc to use other codecs
4784      return dcoDecodeI64(raw);
4785    }
4786  
4787    @protected
4788    IdentityInfo dco_decode_identity_info(dynamic raw) {
4789      // Codec=Dco (DartCObject based), see doc to use other codecs
4790      final arr = raw as List<dynamic>;
4791      if (arr.length != 4)
4792        throw Exception('unexpected arr length: expect 4 but see ${arr.length}');
4793      return IdentityInfo(
4794        identityPublic: dco_decode_list_prim_u_8_strict(arr[0]),
4795        exchangePublic: dco_decode_list_prim_u_8_strict(arr[1]),
4796        fingerprint: dco_decode_String(arr[2]),
4797        createdAt: dco_decode_i_64(arr[3]),
4798      );
4799    }
4800  
4801    @protected
4802    IrohIncomingMessage dco_decode_iroh_incoming_message(dynamic raw) {
4803      // Codec=Dco (DartCObject based), see doc to use other codecs
4804      final arr = raw as List<dynamic>;
4805      if (arr.length != 2)
4806        throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
4807      return IrohIncomingMessage(
4808        senderNodeId: dco_decode_list_prim_u_8_strict(arr[0]),
4809        payload: dco_decode_list_prim_u_8_strict(arr[1]),
4810      );
4811    }
4812  
4813    @protected
4814    IrohStateDto dco_decode_iroh_state_dto(dynamic raw) {
4815      // Codec=Dco (DartCObject based), see doc to use other codecs
4816      final arr = raw as List<dynamic>;
4817      if (arr.length != 3)
4818        throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
4819      return IrohStateDto(
4820        state: dco_decode_String(arr[0]),
4821        endpointId: dco_decode_opt_String(arr[1]),
4822        error: dco_decode_opt_String(arr[2]),
4823      );
4824    }
4825  
4826    @protected
4827    List<String> dco_decode_list_String(dynamic raw) {
4828      // Codec=Dco (DartCObject based), see doc to use other codecs
4829      return (raw as List<dynamic>).map(dco_decode_String).toList();
4830    }
4831  
4832    @protected
4833    List<AchievementInfo> dco_decode_list_achievement_info(dynamic raw) {
4834      // Codec=Dco (DartCObject based), see doc to use other codecs
4835      return (raw as List<dynamic>).map(dco_decode_achievement_info).toList();
4836    }
4837  
4838    @protected
4839    List<CachedIrohEndpoint> dco_decode_list_cached_iroh_endpoint(dynamic raw) {
4840      // Codec=Dco (DartCObject based), see doc to use other codecs
4841      return (raw as List<dynamic>).map(dco_decode_cached_iroh_endpoint).toList();
4842    }
4843  
4844    @protected
4845    List<CachedOnionAddress> dco_decode_list_cached_onion_address(dynamic raw) {
4846      // Codec=Dco (DartCObject based), see doc to use other codecs
4847      return (raw as List<dynamic>).map(dco_decode_cached_onion_address).toList();
4848    }
4849  
4850    @protected
4851    List<ContactInfo> dco_decode_list_contact_info(dynamic raw) {
4852      // Codec=Dco (DartCObject based), see doc to use other codecs
4853      return (raw as List<dynamic>).map(dco_decode_contact_info).toList();
4854    }
4855  
4856    @protected
4857    List<EncryptedPayload> dco_decode_list_encrypted_payload(dynamic raw) {
4858      // Codec=Dco (DartCObject based), see doc to use other codecs
4859      return (raw as List<dynamic>).map(dco_decode_encrypted_payload).toList();
4860    }
4861  
4862    @protected
4863    List<GroupInfo> dco_decode_list_group_info(dynamic raw) {
4864      // Codec=Dco (DartCObject based), see doc to use other codecs
4865      return (raw as List<dynamic>).map(dco_decode_group_info).toList();
4866    }
4867  
4868    @protected
4869    List<GroupMemberInfoDto> dco_decode_list_group_member_info_dto(dynamic raw) {
4870      // Codec=Dco (DartCObject based), see doc to use other codecs
4871      return (raw as List<dynamic>)
4872          .map(dco_decode_group_member_info_dto)
4873          .toList();
4874    }
4875  
4876    @protected
4877    List<Uint8List> dco_decode_list_list_prim_u_8_strict(dynamic raw) {
4878      // Codec=Dco (DartCObject based), see doc to use other codecs
4879      return (raw as List<dynamic>).map(dco_decode_list_prim_u_8_strict).toList();
4880    }
4881  
4882    @protected
4883    List<MessageInfo> dco_decode_list_message_info(dynamic raw) {
4884      // Codec=Dco (DartCObject based), see doc to use other codecs
4885      return (raw as List<dynamic>).map(dco_decode_message_info).toList();
4886    }
4887  
4888    @protected
4889    List<int> dco_decode_list_prim_u_8_loose(dynamic raw) {
4890      // Codec=Dco (DartCObject based), see doc to use other codecs
4891      return raw as List<int>;
4892    }
4893  
4894    @protected
4895    Uint8List dco_decode_list_prim_u_8_strict(dynamic raw) {
4896      // Codec=Dco (DartCObject based), see doc to use other codecs
4897      return raw as Uint8List;
4898    }
4899  
4900    @protected
4901    List<ReactionSummaryDto> dco_decode_list_reaction_summary_dto(dynamic raw) {
4902      // Codec=Dco (DartCObject based), see doc to use other codecs
4903      return (raw as List<dynamic>).map(dco_decode_reaction_summary_dto).toList();
4904    }
4905  
4906    @protected
4907    List<SearchResultInfo> dco_decode_list_search_result_info(dynamic raw) {
4908      // Codec=Dco (DartCObject based), see doc to use other codecs
4909      return (raw as List<dynamic>).map(dco_decode_search_result_info).toList();
4910    }
4911  
4912    @protected
4913    List<TransportInfoDto> dco_decode_list_transport_info_dto(dynamic raw) {
4914      // Codec=Dco (DartCObject based), see doc to use other codecs
4915      return (raw as List<dynamic>).map(dco_decode_transport_info_dto).toList();
4916    }
4917  
4918    @protected
4919    MessageInfo dco_decode_message_info(dynamic raw) {
4920      // Codec=Dco (DartCObject based), see doc to use other codecs
4921      final arr = raw as List<dynamic>;
4922      if (arr.length != 16)
4923        throw Exception('unexpected arr length: expect 16 but see ${arr.length}');
4924      return MessageInfo(
4925        messageId: dco_decode_list_prim_u_8_strict(arr[0]),
4926        contactId: dco_decode_list_prim_u_8_strict(arr[1]),
4927        contentType: dco_decode_u_8(arr[2]),
4928        content: dco_decode_list_prim_u_8_strict(arr[3]),
4929        filename: dco_decode_opt_String(arr[4]),
4930        isOutbound: dco_decode_bool(arr[5]),
4931        state: dco_decode_u_8(arr[6]),
4932        timestamp: dco_decode_i_64(arr[7]),
4933        expiresAt: dco_decode_opt_box_autoadd_i_64(arr[8]),
4934        deliveryTransport: dco_decode_opt_String(arr[9]),
4935        deliveredAt: dco_decode_opt_box_autoadd_i_64(arr[10]),
4936        lastError: dco_decode_opt_String(arr[11]),
4937        reactions: dco_decode_list_reaction_summary_dto(arr[12]),
4938        disappearingDuration: dco_decode_u_64(arr[13]),
4939        senderId: dco_decode_opt_list_prim_u_8_strict(arr[14]),
4940        groupId: dco_decode_opt_list_prim_u_8_strict(arr[15]),
4941      );
4942    }
4943  
4944    @protected
4945    NetworkTransportPreference dco_decode_network_transport_preference(
4946      dynamic raw,
4947    ) {
4948      // Codec=Dco (DartCObject based), see doc to use other codecs
4949      return NetworkTransportPreference.values[raw as int];
4950    }
4951  
4952    @protected
4953    String? dco_decode_opt_String(dynamic raw) {
4954      // Codec=Dco (DartCObject based), see doc to use other codecs
4955      return raw == null ? null : dco_decode_String(raw);
4956    }
4957  
4958    @protected
4959    PlatformInt64? dco_decode_opt_box_autoadd_i_64(dynamic raw) {
4960      // Codec=Dco (DartCObject based), see doc to use other codecs
4961      return raw == null ? null : dco_decode_box_autoadd_i_64(raw);
4962    }
4963  
4964    @protected
4965    IrohIncomingMessage? dco_decode_opt_box_autoadd_iroh_incoming_message(
4966      dynamic raw,
4967    ) {
4968      // Codec=Dco (DartCObject based), see doc to use other codecs
4969      return raw == null
4970          ? null
4971          : dco_decode_box_autoadd_iroh_incoming_message(raw);
4972    }
4973  
4974    @protected
4975    MessageInfo? dco_decode_opt_box_autoadd_message_info(dynamic raw) {
4976      // Codec=Dco (DartCObject based), see doc to use other codecs
4977      return raw == null ? null : dco_decode_box_autoadd_message_info(raw);
4978    }
4979  
4980    @protected
4981    (String, BigInt)? dco_decode_opt_box_autoadd_record_string_u_64(dynamic raw) {
4982      // Codec=Dco (DartCObject based), see doc to use other codecs
4983      return raw == null ? null : dco_decode_box_autoadd_record_string_u_64(raw);
4984    }
4985  
4986    @protected
4987    (int, int)? dco_decode_opt_box_autoadd_record_u_32_u_32(dynamic raw) {
4988      // Codec=Dco (DartCObject based), see doc to use other codecs
4989      return raw == null ? null : dco_decode_box_autoadd_record_u_32_u_32(raw);
4990    }
4991  
4992    @protected
4993    TransportAddressDto? dco_decode_opt_box_autoadd_transport_address_dto(
4994      dynamic raw,
4995    ) {
4996      // Codec=Dco (DartCObject based), see doc to use other codecs
4997      return raw == null
4998          ? null
4999          : dco_decode_box_autoadd_transport_address_dto(raw);
5000    }
5001  
5002    @protected
5003    TransportTypeDto? dco_decode_opt_box_autoadd_transport_type_dto(dynamic raw) {
5004      // Codec=Dco (DartCObject based), see doc to use other codecs
5005      return raw == null ? null : dco_decode_box_autoadd_transport_type_dto(raw);
5006    }
5007  
5008    @protected
5009    int? dco_decode_opt_box_autoadd_u_32(dynamic raw) {
5010      // Codec=Dco (DartCObject based), see doc to use other codecs
5011      return raw == null ? null : dco_decode_box_autoadd_u_32(raw);
5012    }
5013  
5014    @protected
5015    Uint8List? dco_decode_opt_list_prim_u_8_strict(dynamic raw) {
5016      // Codec=Dco (DartCObject based), see doc to use other codecs
5017      return raw == null ? null : dco_decode_list_prim_u_8_strict(raw);
5018    }
5019  
5020    @protected
5021    PendingContact dco_decode_pending_contact(dynamic raw) {
5022      // Codec=Dco (DartCObject based), see doc to use other codecs
5023      final arr = raw as List<dynamic>;
5024      if (arr.length != 4)
5025        throw Exception('unexpected arr length: expect 4 but see ${arr.length}');
5026      return PendingContact(
5027        contactId: dco_decode_list_prim_u_8_strict(arr[0]),
5028        identityPublic: dco_decode_list_prim_u_8_strict(arr[1]),
5029        exchangePublic: dco_decode_list_prim_u_8_strict(arr[2]),
5030        fingerprint: dco_decode_String(arr[3]),
5031      );
5032    }
5033  
5034    @protected
5035    ReactionSummaryDto dco_decode_reaction_summary_dto(dynamic raw) {
5036      // Codec=Dco (DartCObject based), see doc to use other codecs
5037      final arr = raw as List<dynamic>;
5038      if (arr.length != 3)
5039        throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
5040      return ReactionSummaryDto(
5041        emoji: dco_decode_String(arr[0]),
5042        count: dco_decode_u_32(arr[1]),
5043        includesSelf: dco_decode_bool(arr[2]),
5044      );
5045    }
5046  
5047    @protected
5048    (ExchangeComplete, GossipExchangeHandle)
5049    dco_decode_record_exchange_complete_gossip_exchange_handle(dynamic raw) {
5050      // Codec=Dco (DartCObject based), see doc to use other codecs
5051      final arr = raw as List<dynamic>;
5052      if (arr.length != 2) {
5053        throw Exception('Expected 2 elements, got ${arr.length}');
5054      }
5055      return (
5056        dco_decode_exchange_complete(arr[0]),
5057        dco_decode_gossip_exchange_handle(arr[1]),
5058      );
5059    }
5060  
5061    @protected
5062    (String, BigInt) dco_decode_record_string_u_64(dynamic raw) {
5063      // Codec=Dco (DartCObject based), see doc to use other codecs
5064      final arr = raw as List<dynamic>;
5065      if (arr.length != 2) {
5066        throw Exception('Expected 2 elements, got ${arr.length}');
5067      }
5068      return (dco_decode_String(arr[0]), dco_decode_u_64(arr[1]));
5069    }
5070  
5071    @protected
5072    (int, int) dco_decode_record_u_32_u_32(dynamic raw) {
5073      // Codec=Dco (DartCObject based), see doc to use other codecs
5074      final arr = raw as List<dynamic>;
5075      if (arr.length != 2) {
5076        throw Exception('Expected 2 elements, got ${arr.length}');
5077      }
5078      return (dco_decode_u_32(arr[0]), dco_decode_u_32(arr[1]));
5079    }
5080  
5081    @protected
5082    RelayState dco_decode_relay_state(dynamic raw) {
5083      // Codec=Dco (DartCObject based), see doc to use other codecs
5084      switch (raw[0]) {
5085        case 0:
5086          return RelayState_Disconnected();
5087        case 1:
5088          return RelayState_Connecting();
5089        case 2:
5090          return RelayState_Connected(relayUrl: dco_decode_String(raw[1]));
5091        case 3:
5092          return RelayState_Failed(error: dco_decode_String(raw[1]));
5093        default:
5094          throw Exception("unreachable");
5095      }
5096    }
5097  
5098    @protected
5099    RelayStateDto dco_decode_relay_state_dto(dynamic raw) {
5100      // Codec=Dco (DartCObject based), see doc to use other codecs
5101      final arr = raw as List<dynamic>;
5102      if (arr.length != 3)
5103        throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
5104      return RelayStateDto(
5105        state: dco_decode_String(arr[0]),
5106        connectedRelay: dco_decode_opt_String(arr[1]),
5107        error: dco_decode_opt_String(arr[2]),
5108      );
5109    }
5110  
5111    @protected
5112    ReputationInfo dco_decode_reputation_info(dynamic raw) {
5113      // Codec=Dco (DartCObject based), see doc to use other codecs
5114      final arr = raw as List<dynamic>;
5115      if (arr.length != 9)
5116        throw Exception('unexpected arr length: expect 9 but see ${arr.length}');
5117      return ReputationInfo(
5118        messagesForwarded: dco_decode_u_64(arr[0]),
5119        messagesDelivered: dco_decode_u_64(arr[1]),
5120        recipientsHelped: dco_decode_u_32(arr[2]),
5121        totalXp: dco_decode_u_64(arr[3]),
5122        currentLevel: dco_decode_u_8(arr[4]),
5123        levelTitle: dco_decode_String(arr[5]),
5124        levelProgress: dco_decode_f_64(arr[6]),
5125        xpForNextLevel: dco_decode_u_64(arr[7]),
5126        currentStreak: dco_decode_u_32(arr[8]),
5127      );
5128    }
5129  
5130    @protected
5131    SearchResultInfo dco_decode_search_result_info(dynamic raw) {
5132      // Codec=Dco (DartCObject based), see doc to use other codecs
5133      final arr = raw as List<dynamic>;
5134      if (arr.length != 7)
5135        throw Exception('unexpected arr length: expect 7 but see ${arr.length}');
5136      return SearchResultInfo(
5137        messageId: dco_decode_list_prim_u_8_strict(arr[0]),
5138        contactId: dco_decode_list_prim_u_8_strict(arr[1]),
5139        isOutbound: dco_decode_bool(arr[2]),
5140        contentType: dco_decode_u_8(arr[3]),
5141        content: dco_decode_list_prim_u_8_strict(arr[4]),
5142        filename: dco_decode_opt_String(arr[5]),
5143        timestamp: dco_decode_i_64(arr[6]),
5144      );
5145    }
5146  
5147    @protected
5148    TransportAddress dco_decode_transport_address(dynamic raw) {
5149      // Codec=Dco (DartCObject based), see doc to use other codecs
5150      final arr = raw as List<dynamic>;
5151      if (arr.length != 2)
5152        throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
5153      return TransportAddress(
5154        transportType: dco_decode_transport_type(arr[0]),
5155        address: dco_decode_list_prim_u_8_strict(arr[1]),
5156      );
5157    }
5158  
5159    @protected
5160    TransportAddressDto dco_decode_transport_address_dto(dynamic raw) {
5161      // Codec=Dco (DartCObject based), see doc to use other codecs
5162      final arr = raw as List<dynamic>;
5163      if (arr.length != 2)
5164        throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
5165      return TransportAddressDto(
5166        transportType: dco_decode_transport_type_dto(arr[0]),
5167        address: dco_decode_list_prim_u_8_strict(arr[1]),
5168      );
5169    }
5170  
5171    @protected
5172    TransportInfoDto dco_decode_transport_info_dto(dynamic raw) {
5173      // Codec=Dco (DartCObject based), see doc to use other codecs
5174      final arr = raw as List<dynamic>;
5175      if (arr.length != 4)
5176        throw Exception('unexpected arr length: expect 4 but see ${arr.length}');
5177      return TransportInfoDto(
5178        transportType: dco_decode_transport_type_dto(arr[0]),
5179        name: dco_decode_String(arr[1]),
5180        available: dco_decode_bool(arr[2]),
5181        priority: dco_decode_u_8(arr[3]),
5182      );
5183    }
5184  
5185    @protected
5186    TransportStatsInfo dco_decode_transport_stats_info(dynamic raw) {
5187      // Codec=Dco (DartCObject based), see doc to use other codecs
5188      final arr = raw as List<dynamic>;
5189      if (arr.length != 4)
5190        throw Exception('unexpected arr length: expect 4 but see ${arr.length}');
5191      return TransportStatsInfo(
5192        bleCount: dco_decode_u_32(arr[0]),
5193        dhtCount: dco_decode_u_32(arr[1]),
5194        relayCount: dco_decode_u_32(arr[2]),
5195        irohCount: dco_decode_u_32(arr[3]),
5196      );
5197    }
5198  
5199    @protected
5200    TransportType dco_decode_transport_type(dynamic raw) {
5201      // Codec=Dco (DartCObject based), see doc to use other codecs
5202      return TransportType.values[raw as int];
5203    }
5204  
5205    @protected
5206    TransportTypeDto dco_decode_transport_type_dto(dynamic raw) {
5207      // Codec=Dco (DartCObject based), see doc to use other codecs
5208      return TransportTypeDto.values[raw as int];
5209    }
5210  
5211    @protected
5212    int dco_decode_u_32(dynamic raw) {
5213      // Codec=Dco (DartCObject based), see doc to use other codecs
5214      return raw as int;
5215    }
5216  
5217    @protected
5218    BigInt dco_decode_u_64(dynamic raw) {
5219      // Codec=Dco (DartCObject based), see doc to use other codecs
5220      return dcoDecodeU64(raw);
5221    }
5222  
5223    @protected
5224    int dco_decode_u_8(dynamic raw) {
5225      // Codec=Dco (DartCObject based), see doc to use other codecs
5226      return raw as int;
5227    }
5228  
5229    @protected
5230    void dco_decode_unit(dynamic raw) {
5231      // Codec=Dco (DartCObject based), see doc to use other codecs
5232      return;
5233    }
5234  
5235    @protected
5236    BigInt dco_decode_usize(dynamic raw) {
5237      // Codec=Dco (DartCObject based), see doc to use other codecs
5238      return dcoDecodeU64(raw);
5239    }
5240  
5241    @protected
5242    String sse_decode_String(SseDeserializer deserializer) {
5243      // Codec=Sse (Serialization based), see doc to use other codecs
5244      var inner = sse_decode_list_prim_u_8_strict(deserializer);
5245      return utf8.decoder.convert(inner);
5246    }
5247  
5248    @protected
5249    AchievementInfo sse_decode_achievement_info(SseDeserializer deserializer) {
5250      // Codec=Sse (Serialization based), see doc to use other codecs
5251      var var_id = sse_decode_u_8(deserializer);
5252      var var_name = sse_decode_String(deserializer);
5253      var var_description = sse_decode_String(deserializer);
5254      var var_unlocked = sse_decode_bool(deserializer);
5255      return AchievementInfo(
5256        id: var_id,
5257        name: var_name,
5258        description: var_description,
5259        unlocked: var_unlocked,
5260      );
5261    }
5262  
5263    @protected
5264    bool sse_decode_bool(SseDeserializer deserializer) {
5265      // Codec=Sse (Serialization based), see doc to use other codecs
5266      return deserializer.buffer.getUint8() != 0;
5267    }
5268  
5269    @protected
5270    DhtState sse_decode_box_autoadd_dht_state(SseDeserializer deserializer) {
5271      // Codec=Sse (Serialization based), see doc to use other codecs
5272      return (sse_decode_dht_state(deserializer));
5273    }
5274  
5275    @protected
5276    ExchangeHandle sse_decode_box_autoadd_exchange_handle(
5277      SseDeserializer deserializer,
5278    ) {
5279      // Codec=Sse (Serialization based), see doc to use other codecs
5280      return (sse_decode_exchange_handle(deserializer));
5281    }
5282  
5283    @protected
5284    GossipExchangeHandle sse_decode_box_autoadd_gossip_exchange_handle(
5285      SseDeserializer deserializer,
5286    ) {
5287      // Codec=Sse (Serialization based), see doc to use other codecs
5288      return (sse_decode_gossip_exchange_handle(deserializer));
5289    }
5290  
5291    @protected
5292    HandshakeHandle sse_decode_box_autoadd_handshake_handle(
5293      SseDeserializer deserializer,
5294    ) {
5295      // Codec=Sse (Serialization based), see doc to use other codecs
5296      return (sse_decode_handshake_handle(deserializer));
5297    }
5298  
5299    @protected
5300    PlatformInt64 sse_decode_box_autoadd_i_64(SseDeserializer deserializer) {
5301      // Codec=Sse (Serialization based), see doc to use other codecs
5302      return (sse_decode_i_64(deserializer));
5303    }
5304  
5305    @protected
5306    IrohIncomingMessage sse_decode_box_autoadd_iroh_incoming_message(
5307      SseDeserializer deserializer,
5308    ) {
5309      // Codec=Sse (Serialization based), see doc to use other codecs
5310      return (sse_decode_iroh_incoming_message(deserializer));
5311    }
5312  
5313    @protected
5314    MessageInfo sse_decode_box_autoadd_message_info(
5315      SseDeserializer deserializer,
5316    ) {
5317      // Codec=Sse (Serialization based), see doc to use other codecs
5318      return (sse_decode_message_info(deserializer));
5319    }
5320  
5321    @protected
5322    PendingContact sse_decode_box_autoadd_pending_contact(
5323      SseDeserializer deserializer,
5324    ) {
5325      // Codec=Sse (Serialization based), see doc to use other codecs
5326      return (sse_decode_pending_contact(deserializer));
5327    }
5328  
5329    @protected
5330    (String, BigInt) sse_decode_box_autoadd_record_string_u_64(
5331      SseDeserializer deserializer,
5332    ) {
5333      // Codec=Sse (Serialization based), see doc to use other codecs
5334      return (sse_decode_record_string_u_64(deserializer));
5335    }
5336  
5337    @protected
5338    (int, int) sse_decode_box_autoadd_record_u_32_u_32(
5339      SseDeserializer deserializer,
5340    ) {
5341      // Codec=Sse (Serialization based), see doc to use other codecs
5342      return (sse_decode_record_u_32_u_32(deserializer));
5343    }
5344  
5345    @protected
5346    RelayState sse_decode_box_autoadd_relay_state(SseDeserializer deserializer) {
5347      // Codec=Sse (Serialization based), see doc to use other codecs
5348      return (sse_decode_relay_state(deserializer));
5349    }
5350  
5351    @protected
5352    TransportAddress sse_decode_box_autoadd_transport_address(
5353      SseDeserializer deserializer,
5354    ) {
5355      // Codec=Sse (Serialization based), see doc to use other codecs
5356      return (sse_decode_transport_address(deserializer));
5357    }
5358  
5359    @protected
5360    TransportAddressDto sse_decode_box_autoadd_transport_address_dto(
5361      SseDeserializer deserializer,
5362    ) {
5363      // Codec=Sse (Serialization based), see doc to use other codecs
5364      return (sse_decode_transport_address_dto(deserializer));
5365    }
5366  
5367    @protected
5368    TransportTypeDto sse_decode_box_autoadd_transport_type_dto(
5369      SseDeserializer deserializer,
5370    ) {
5371      // Codec=Sse (Serialization based), see doc to use other codecs
5372      return (sse_decode_transport_type_dto(deserializer));
5373    }
5374  
5375    @protected
5376    int sse_decode_box_autoadd_u_32(SseDeserializer deserializer) {
5377      // Codec=Sse (Serialization based), see doc to use other codecs
5378      return (sse_decode_u_32(deserializer));
5379    }
5380  
5381    @protected
5382    CachedIrohEndpoint sse_decode_cached_iroh_endpoint(
5383      SseDeserializer deserializer,
5384    ) {
5385      // Codec=Sse (Serialization based), see doc to use other codecs
5386      var var_contactId = sse_decode_list_prim_u_8_strict(deserializer);
5387      var var_endpointId = sse_decode_String(deserializer);
5388      return CachedIrohEndpoint(
5389        contactId: var_contactId,
5390        endpointId: var_endpointId,
5391      );
5392    }
5393  
5394    @protected
5395    CachedOnionAddress sse_decode_cached_onion_address(
5396      SseDeserializer deserializer,
5397    ) {
5398      // Codec=Sse (Serialization based), see doc to use other codecs
5399      var var_contactId = sse_decode_list_prim_u_8_strict(deserializer);
5400      var var_onionAddress = sse_decode_String(deserializer);
5401      return CachedOnionAddress(
5402        contactId: var_contactId,
5403        onionAddress: var_onionAddress,
5404      );
5405    }
5406  
5407    @protected
5408    ContactInfo sse_decode_contact_info(SseDeserializer deserializer) {
5409      // Codec=Sse (Serialization based), see doc to use other codecs
5410      var var_contactId = sse_decode_list_prim_u_8_strict(deserializer);
5411      var var_nickname = sse_decode_opt_String(deserializer);
5412      var var_state = sse_decode_u_8(deserializer);
5413      var var_fingerprint = sse_decode_String(deserializer);
5414      var var_createdAt = sse_decode_i_64(deserializer);
5415      var var_lastSeen = sse_decode_opt_box_autoadd_i_64(deserializer);
5416      var var_queuedCount = sse_decode_u_32(deserializer);
5417      var var_unreadCount = sse_decode_u_32(deserializer);
5418      var var_disappearingDuration = sse_decode_u_64(deserializer);
5419      var var_isMuted = sse_decode_bool(deserializer);
5420      return ContactInfo(
5421        contactId: var_contactId,
5422        nickname: var_nickname,
5423        state: var_state,
5424        fingerprint: var_fingerprint,
5425        createdAt: var_createdAt,
5426        lastSeen: var_lastSeen,
5427        queuedCount: var_queuedCount,
5428        unreadCount: var_unreadCount,
5429        disappearingDuration: var_disappearingDuration,
5430        isMuted: var_isMuted,
5431      );
5432    }
5433  
5434    @protected
5435    DhtFetchResult sse_decode_dht_fetch_result(SseDeserializer deserializer) {
5436      // Codec=Sse (Serialization based), see doc to use other codecs
5437      var var_messages = sse_decode_list_message_info(deserializer);
5438      var var_contactsWithReactions = sse_decode_list_list_prim_u_8_strict(
5439        deserializer,
5440      );
5441      var var_hadGroupManagement = sse_decode_bool(deserializer);
5442      return DhtFetchResult(
5443        messages: var_messages,
5444        contactsWithReactions: var_contactsWithReactions,
5445        hadGroupManagement: var_hadGroupManagement,
5446      );
5447    }
5448  
5449    @protected
5450    DhtPublishResult sse_decode_dht_publish_result(SseDeserializer deserializer) {
5451      // Codec=Sse (Serialization based), see doc to use other codecs
5452      var var_publishedCount = sse_decode_u_32(deserializer);
5453      var var_publishedIds = sse_decode_list_list_prim_u_8_strict(deserializer);
5454      return DhtPublishResult(
5455        publishedCount: var_publishedCount,
5456        publishedIds: var_publishedIds,
5457      );
5458    }
5459  
5460    @protected
5461    DhtState sse_decode_dht_state(SseDeserializer deserializer) {
5462      // Codec=Sse (Serialization based), see doc to use other codecs
5463  
5464      var tag_ = sse_decode_i_32(deserializer);
5465      switch (tag_) {
5466        case 0:
5467          return DhtState_Disconnected();
5468        case 1:
5469          return DhtState_Bootstrapping();
5470        case 2:
5471          var var_peerCount = sse_decode_usize(deserializer);
5472          return DhtState_Connected(peerCount: var_peerCount);
5473        case 3:
5474          var var_error = sse_decode_String(deserializer);
5475          return DhtState_Failed(error: var_error);
5476        default:
5477          throw UnimplementedError('');
5478      }
5479    }
5480  
5481    @protected
5482    DhtStateDto sse_decode_dht_state_dto(SseDeserializer deserializer) {
5483      // Codec=Sse (Serialization based), see doc to use other codecs
5484      var var_state = sse_decode_String(deserializer);
5485      var var_peerCount = sse_decode_u_32(deserializer);
5486      var var_error = sse_decode_opt_String(deserializer);
5487      return DhtStateDto(
5488        state: var_state,
5489        peerCount: var_peerCount,
5490        error: var_error,
5491      );
5492    }
5493  
5494    @protected
5495    DocumentInfo sse_decode_document_info(SseDeserializer deserializer) {
5496      // Codec=Sse (Serialization based), see doc to use other codecs
5497      var var_documentId = sse_decode_list_prim_u_8_strict(deserializer);
5498      var var_filename = sse_decode_String(deserializer);
5499      var var_size = sse_decode_u_64(deserializer);
5500      var var_content = sse_decode_list_prim_u_8_strict(deserializer);
5501      return DocumentInfo(
5502        documentId: var_documentId,
5503        filename: var_filename,
5504        size: var_size,
5505        content: var_content,
5506      );
5507    }
5508  
5509    @protected
5510    EncryptedPayload sse_decode_encrypted_payload(SseDeserializer deserializer) {
5511      // Codec=Sse (Serialization based), see doc to use other codecs
5512      var var_messageId = sse_decode_list_prim_u_8_strict(deserializer);
5513      var var_payload = sse_decode_list_prim_u_8_strict(deserializer);
5514      return EncryptedPayload(messageId: var_messageId, payload: var_payload);
5515    }
5516  
5517    @protected
5518    ExchangeComplete sse_decode_exchange_complete(SseDeserializer deserializer) {
5519      // Codec=Sse (Serialization based), see doc to use other codecs
5520      var var_contactId = sse_decode_list_prim_u_8_strict(deserializer);
5521      var var_deliveredIds = sse_decode_list_list_prim_u_8_strict(deserializer);
5522      var var_receivedMessages = sse_decode_list_message_info(deserializer);
5523      return ExchangeComplete(
5524        contactId: var_contactId,
5525        deliveredIds: var_deliveredIds,
5526        receivedMessages: var_receivedMessages,
5527      );
5528    }
5529  
5530    @protected
5531    ExchangeHandle sse_decode_exchange_handle(SseDeserializer deserializer) {
5532      // Codec=Sse (Serialization based), see doc to use other codecs
5533      var var_id = sse_decode_u_64(deserializer);
5534      return ExchangeHandle(id: var_id);
5535    }
5536  
5537    @protected
5538    ExchangeResultDto sse_decode_exchange_result_dto(
5539      SseDeserializer deserializer,
5540    ) {
5541      // Codec=Sse (Serialization based), see doc to use other codecs
5542      var var_complete = sse_decode_bool(deserializer);
5543      var var_response = sse_decode_opt_list_prim_u_8_strict(deserializer);
5544      return ExchangeResultDto(complete: var_complete, response: var_response);
5545    }
5546  
5547    @protected
5548    double sse_decode_f_64(SseDeserializer deserializer) {
5549      // Codec=Sse (Serialization based), see doc to use other codecs
5550      return deserializer.buffer.getFloat64();
5551    }
5552  
5553    @protected
5554    ForwardingInfo sse_decode_forwarding_info(SseDeserializer deserializer) {
5555      // Codec=Sse (Serialization based), see doc to use other codecs
5556      var var_messageCount = sse_decode_u_32(deserializer);
5557      var var_storageUsed = sse_decode_u_64(deserializer);
5558      var var_storageLimit = sse_decode_u_64(deserializer);
5559      var var_uniqueRecipients = sse_decode_u_32(deserializer);
5560      var var_fillPercentage = sse_decode_f_64(deserializer);
5561      return ForwardingInfo(
5562        messageCount: var_messageCount,
5563        storageUsed: var_storageUsed,
5564        storageLimit: var_storageLimit,
5565        uniqueRecipients: var_uniqueRecipients,
5566        fillPercentage: var_fillPercentage,
5567      );
5568    }
5569  
5570    @protected
5571    GossipExchangeComplete sse_decode_gossip_exchange_complete(
5572      SseDeserializer deserializer,
5573    ) {
5574      // Codec=Sse (Serialization based), see doc to use other codecs
5575      var var_storedCount = sse_decode_u_32(deserializer);
5576      var var_messagesForUsCount = sse_decode_u_32(deserializer);
5577      return GossipExchangeComplete(
5578        storedCount: var_storedCount,
5579        messagesForUsCount: var_messagesForUsCount,
5580      );
5581    }
5582  
5583    @protected
5584    GossipExchangeHandle sse_decode_gossip_exchange_handle(
5585      SseDeserializer deserializer,
5586    ) {
5587      // Codec=Sse (Serialization based), see doc to use other codecs
5588      var var_id = sse_decode_u_64(deserializer);
5589      return GossipExchangeHandle(id: var_id);
5590    }
5591  
5592    @protected
5593    GossipFinalizeKeepTransportResult
5594    sse_decode_gossip_finalize_keep_transport_result(
5595      SseDeserializer deserializer,
5596    ) {
5597      // Codec=Sse (Serialization based), see doc to use other codecs
5598      var var_result = sse_decode_gossip_exchange_complete(deserializer);
5599      var var_transportHandle = sse_decode_u_64(deserializer);
5600      return GossipFinalizeKeepTransportResult(
5601        result: var_result,
5602        transportHandle: var_transportHandle,
5603      );
5604    }
5605  
5606    @protected
5607    GossipResult sse_decode_gossip_result(SseDeserializer deserializer) {
5608      // Codec=Sse (Serialization based), see doc to use other codecs
5609      var var_storedCount = sse_decode_u_32(deserializer);
5610      var var_messagesForUs = sse_decode_u_32(deserializer);
5611      return GossipResult(
5612        storedCount: var_storedCount,
5613        messagesForUs: var_messagesForUs,
5614      );
5615    }
5616  
5617    @protected
5618    GroupInfo sse_decode_group_info(SseDeserializer deserializer) {
5619      // Codec=Sse (Serialization based), see doc to use other codecs
5620      var var_groupId = sse_decode_list_prim_u_8_strict(deserializer);
5621      var var_name = sse_decode_String(deserializer);
5622      var var_createdAt = sse_decode_i_64(deserializer);
5623      var var_memberCount = sse_decode_u_32(deserializer);
5624      var var_unreadCount = sse_decode_u_32(deserializer);
5625      var var_disappearingDuration = sse_decode_u_64(deserializer);
5626      var var_isMuted = sse_decode_bool(deserializer);
5627      var var_lastMessageAt = sse_decode_opt_box_autoadd_i_64(deserializer);
5628      var var_accepted = sse_decode_bool(deserializer);
5629      var var_isCreator = sse_decode_bool(deserializer);
5630      return GroupInfo(
5631        groupId: var_groupId,
5632        name: var_name,
5633        createdAt: var_createdAt,
5634        memberCount: var_memberCount,
5635        unreadCount: var_unreadCount,
5636        disappearingDuration: var_disappearingDuration,
5637        isMuted: var_isMuted,
5638        lastMessageAt: var_lastMessageAt,
5639        accepted: var_accepted,
5640        isCreator: var_isCreator,
5641      );
5642    }
5643  
5644    @protected
5645    GroupMemberInfoDto sse_decode_group_member_info_dto(
5646      SseDeserializer deserializer,
5647    ) {
5648      // Codec=Sse (Serialization based), see doc to use other codecs
5649      var var_contactId = sse_decode_list_prim_u_8_strict(deserializer);
5650      var var_nickname = sse_decode_opt_String(deserializer);
5651      var var_role = sse_decode_u_8(deserializer);
5652      return GroupMemberInfoDto(
5653        contactId: var_contactId,
5654        nickname: var_nickname,
5655        role: var_role,
5656      );
5657    }
5658  
5659    @protected
5660    HandshakeHandle sse_decode_handshake_handle(SseDeserializer deserializer) {
5661      // Codec=Sse (Serialization based), see doc to use other codecs
5662      var var_id = sse_decode_u_64(deserializer);
5663      return HandshakeHandle(id: var_id);
5664    }
5665  
5666    @protected
5667    HandshakeResult sse_decode_handshake_result(SseDeserializer deserializer) {
5668      // Codec=Sse (Serialization based), see doc to use other codecs
5669      var var_complete = sse_decode_bool(deserializer);
5670      var var_response = sse_decode_opt_list_prim_u_8_strict(deserializer);
5671      var var_remoteIdentity = sse_decode_opt_list_prim_u_8_strict(deserializer);
5672      return HandshakeResult(
5673        complete: var_complete,
5674        response: var_response,
5675        remoteIdentity: var_remoteIdentity,
5676      );
5677    }
5678  
5679    @protected
5680    int sse_decode_i_32(SseDeserializer deserializer) {
5681      // Codec=Sse (Serialization based), see doc to use other codecs
5682      return deserializer.buffer.getInt32();
5683    }
5684  
5685    @protected
5686    PlatformInt64 sse_decode_i_64(SseDeserializer deserializer) {
5687      // Codec=Sse (Serialization based), see doc to use other codecs
5688      return deserializer.buffer.getPlatformInt64();
5689    }
5690  
5691    @protected
5692    IdentityInfo sse_decode_identity_info(SseDeserializer deserializer) {
5693      // Codec=Sse (Serialization based), see doc to use other codecs
5694      var var_identityPublic = sse_decode_list_prim_u_8_strict(deserializer);
5695      var var_exchangePublic = sse_decode_list_prim_u_8_strict(deserializer);
5696      var var_fingerprint = sse_decode_String(deserializer);
5697      var var_createdAt = sse_decode_i_64(deserializer);
5698      return IdentityInfo(
5699        identityPublic: var_identityPublic,
5700        exchangePublic: var_exchangePublic,
5701        fingerprint: var_fingerprint,
5702        createdAt: var_createdAt,
5703      );
5704    }
5705  
5706    @protected
5707    IrohIncomingMessage sse_decode_iroh_incoming_message(
5708      SseDeserializer deserializer,
5709    ) {
5710      // Codec=Sse (Serialization based), see doc to use other codecs
5711      var var_senderNodeId = sse_decode_list_prim_u_8_strict(deserializer);
5712      var var_payload = sse_decode_list_prim_u_8_strict(deserializer);
5713      return IrohIncomingMessage(
5714        senderNodeId: var_senderNodeId,
5715        payload: var_payload,
5716      );
5717    }
5718  
5719    @protected
5720    IrohStateDto sse_decode_iroh_state_dto(SseDeserializer deserializer) {
5721      // Codec=Sse (Serialization based), see doc to use other codecs
5722      var var_state = sse_decode_String(deserializer);
5723      var var_endpointId = sse_decode_opt_String(deserializer);
5724      var var_error = sse_decode_opt_String(deserializer);
5725      return IrohStateDto(
5726        state: var_state,
5727        endpointId: var_endpointId,
5728        error: var_error,
5729      );
5730    }
5731  
5732    @protected
5733    List<String> sse_decode_list_String(SseDeserializer deserializer) {
5734      // Codec=Sse (Serialization based), see doc to use other codecs
5735  
5736      var len_ = sse_decode_i_32(deserializer);
5737      var ans_ = <String>[];
5738      for (var idx_ = 0; idx_ < len_; ++idx_) {
5739        ans_.add(sse_decode_String(deserializer));
5740      }
5741      return ans_;
5742    }
5743  
5744    @protected
5745    List<AchievementInfo> sse_decode_list_achievement_info(
5746      SseDeserializer deserializer,
5747    ) {
5748      // Codec=Sse (Serialization based), see doc to use other codecs
5749  
5750      var len_ = sse_decode_i_32(deserializer);
5751      var ans_ = <AchievementInfo>[];
5752      for (var idx_ = 0; idx_ < len_; ++idx_) {
5753        ans_.add(sse_decode_achievement_info(deserializer));
5754      }
5755      return ans_;
5756    }
5757  
5758    @protected
5759    List<CachedIrohEndpoint> sse_decode_list_cached_iroh_endpoint(
5760      SseDeserializer deserializer,
5761    ) {
5762      // Codec=Sse (Serialization based), see doc to use other codecs
5763  
5764      var len_ = sse_decode_i_32(deserializer);
5765      var ans_ = <CachedIrohEndpoint>[];
5766      for (var idx_ = 0; idx_ < len_; ++idx_) {
5767        ans_.add(sse_decode_cached_iroh_endpoint(deserializer));
5768      }
5769      return ans_;
5770    }
5771  
5772    @protected
5773    List<CachedOnionAddress> sse_decode_list_cached_onion_address(
5774      SseDeserializer deserializer,
5775    ) {
5776      // Codec=Sse (Serialization based), see doc to use other codecs
5777  
5778      var len_ = sse_decode_i_32(deserializer);
5779      var ans_ = <CachedOnionAddress>[];
5780      for (var idx_ = 0; idx_ < len_; ++idx_) {
5781        ans_.add(sse_decode_cached_onion_address(deserializer));
5782      }
5783      return ans_;
5784    }
5785  
5786    @protected
5787    List<ContactInfo> sse_decode_list_contact_info(SseDeserializer deserializer) {
5788      // Codec=Sse (Serialization based), see doc to use other codecs
5789  
5790      var len_ = sse_decode_i_32(deserializer);
5791      var ans_ = <ContactInfo>[];
5792      for (var idx_ = 0; idx_ < len_; ++idx_) {
5793        ans_.add(sse_decode_contact_info(deserializer));
5794      }
5795      return ans_;
5796    }
5797  
5798    @protected
5799    List<EncryptedPayload> sse_decode_list_encrypted_payload(
5800      SseDeserializer deserializer,
5801    ) {
5802      // Codec=Sse (Serialization based), see doc to use other codecs
5803  
5804      var len_ = sse_decode_i_32(deserializer);
5805      var ans_ = <EncryptedPayload>[];
5806      for (var idx_ = 0; idx_ < len_; ++idx_) {
5807        ans_.add(sse_decode_encrypted_payload(deserializer));
5808      }
5809      return ans_;
5810    }
5811  
5812    @protected
5813    List<GroupInfo> sse_decode_list_group_info(SseDeserializer deserializer) {
5814      // Codec=Sse (Serialization based), see doc to use other codecs
5815  
5816      var len_ = sse_decode_i_32(deserializer);
5817      var ans_ = <GroupInfo>[];
5818      for (var idx_ = 0; idx_ < len_; ++idx_) {
5819        ans_.add(sse_decode_group_info(deserializer));
5820      }
5821      return ans_;
5822    }
5823  
5824    @protected
5825    List<GroupMemberInfoDto> sse_decode_list_group_member_info_dto(
5826      SseDeserializer deserializer,
5827    ) {
5828      // Codec=Sse (Serialization based), see doc to use other codecs
5829  
5830      var len_ = sse_decode_i_32(deserializer);
5831      var ans_ = <GroupMemberInfoDto>[];
5832      for (var idx_ = 0; idx_ < len_; ++idx_) {
5833        ans_.add(sse_decode_group_member_info_dto(deserializer));
5834      }
5835      return ans_;
5836    }
5837  
5838    @protected
5839    List<Uint8List> sse_decode_list_list_prim_u_8_strict(
5840      SseDeserializer deserializer,
5841    ) {
5842      // Codec=Sse (Serialization based), see doc to use other codecs
5843  
5844      var len_ = sse_decode_i_32(deserializer);
5845      var ans_ = <Uint8List>[];
5846      for (var idx_ = 0; idx_ < len_; ++idx_) {
5847        ans_.add(sse_decode_list_prim_u_8_strict(deserializer));
5848      }
5849      return ans_;
5850    }
5851  
5852    @protected
5853    List<MessageInfo> sse_decode_list_message_info(SseDeserializer deserializer) {
5854      // Codec=Sse (Serialization based), see doc to use other codecs
5855  
5856      var len_ = sse_decode_i_32(deserializer);
5857      var ans_ = <MessageInfo>[];
5858      for (var idx_ = 0; idx_ < len_; ++idx_) {
5859        ans_.add(sse_decode_message_info(deserializer));
5860      }
5861      return ans_;
5862    }
5863  
5864    @protected
5865    List<int> sse_decode_list_prim_u_8_loose(SseDeserializer deserializer) {
5866      // Codec=Sse (Serialization based), see doc to use other codecs
5867      var len_ = sse_decode_i_32(deserializer);
5868      return deserializer.buffer.getUint8List(len_);
5869    }
5870  
5871    @protected
5872    Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer) {
5873      // Codec=Sse (Serialization based), see doc to use other codecs
5874      var len_ = sse_decode_i_32(deserializer);
5875      return deserializer.buffer.getUint8List(len_);
5876    }
5877  
5878    @protected
5879    List<ReactionSummaryDto> sse_decode_list_reaction_summary_dto(
5880      SseDeserializer deserializer,
5881    ) {
5882      // Codec=Sse (Serialization based), see doc to use other codecs
5883  
5884      var len_ = sse_decode_i_32(deserializer);
5885      var ans_ = <ReactionSummaryDto>[];
5886      for (var idx_ = 0; idx_ < len_; ++idx_) {
5887        ans_.add(sse_decode_reaction_summary_dto(deserializer));
5888      }
5889      return ans_;
5890    }
5891  
5892    @protected
5893    List<SearchResultInfo> sse_decode_list_search_result_info(
5894      SseDeserializer deserializer,
5895    ) {
5896      // Codec=Sse (Serialization based), see doc to use other codecs
5897  
5898      var len_ = sse_decode_i_32(deserializer);
5899      var ans_ = <SearchResultInfo>[];
5900      for (var idx_ = 0; idx_ < len_; ++idx_) {
5901        ans_.add(sse_decode_search_result_info(deserializer));
5902      }
5903      return ans_;
5904    }
5905  
5906    @protected
5907    List<TransportInfoDto> sse_decode_list_transport_info_dto(
5908      SseDeserializer deserializer,
5909    ) {
5910      // Codec=Sse (Serialization based), see doc to use other codecs
5911  
5912      var len_ = sse_decode_i_32(deserializer);
5913      var ans_ = <TransportInfoDto>[];
5914      for (var idx_ = 0; idx_ < len_; ++idx_) {
5915        ans_.add(sse_decode_transport_info_dto(deserializer));
5916      }
5917      return ans_;
5918    }
5919  
5920    @protected
5921    MessageInfo sse_decode_message_info(SseDeserializer deserializer) {
5922      // Codec=Sse (Serialization based), see doc to use other codecs
5923      var var_messageId = sse_decode_list_prim_u_8_strict(deserializer);
5924      var var_contactId = sse_decode_list_prim_u_8_strict(deserializer);
5925      var var_contentType = sse_decode_u_8(deserializer);
5926      var var_content = sse_decode_list_prim_u_8_strict(deserializer);
5927      var var_filename = sse_decode_opt_String(deserializer);
5928      var var_isOutbound = sse_decode_bool(deserializer);
5929      var var_state = sse_decode_u_8(deserializer);
5930      var var_timestamp = sse_decode_i_64(deserializer);
5931      var var_expiresAt = sse_decode_opt_box_autoadd_i_64(deserializer);
5932      var var_deliveryTransport = sse_decode_opt_String(deserializer);
5933      var var_deliveredAt = sse_decode_opt_box_autoadd_i_64(deserializer);
5934      var var_lastError = sse_decode_opt_String(deserializer);
5935      var var_reactions = sse_decode_list_reaction_summary_dto(deserializer);
5936      var var_disappearingDuration = sse_decode_u_64(deserializer);
5937      var var_senderId = sse_decode_opt_list_prim_u_8_strict(deserializer);
5938      var var_groupId = sse_decode_opt_list_prim_u_8_strict(deserializer);
5939      return MessageInfo(
5940        messageId: var_messageId,
5941        contactId: var_contactId,
5942        contentType: var_contentType,
5943        content: var_content,
5944        filename: var_filename,
5945        isOutbound: var_isOutbound,
5946        state: var_state,
5947        timestamp: var_timestamp,
5948        expiresAt: var_expiresAt,
5949        deliveryTransport: var_deliveryTransport,
5950        deliveredAt: var_deliveredAt,
5951        lastError: var_lastError,
5952        reactions: var_reactions,
5953        disappearingDuration: var_disappearingDuration,
5954        senderId: var_senderId,
5955        groupId: var_groupId,
5956      );
5957    }
5958  
5959    @protected
5960    NetworkTransportPreference sse_decode_network_transport_preference(
5961      SseDeserializer deserializer,
5962    ) {
5963      // Codec=Sse (Serialization based), see doc to use other codecs
5964      var inner = sse_decode_i_32(deserializer);
5965      return NetworkTransportPreference.values[inner];
5966    }
5967  
5968    @protected
5969    String? sse_decode_opt_String(SseDeserializer deserializer) {
5970      // Codec=Sse (Serialization based), see doc to use other codecs
5971  
5972      if (sse_decode_bool(deserializer)) {
5973        return (sse_decode_String(deserializer));
5974      } else {
5975        return null;
5976      }
5977    }
5978  
5979    @protected
5980    PlatformInt64? sse_decode_opt_box_autoadd_i_64(SseDeserializer deserializer) {
5981      // Codec=Sse (Serialization based), see doc to use other codecs
5982  
5983      if (sse_decode_bool(deserializer)) {
5984        return (sse_decode_box_autoadd_i_64(deserializer));
5985      } else {
5986        return null;
5987      }
5988    }
5989  
5990    @protected
5991    IrohIncomingMessage? sse_decode_opt_box_autoadd_iroh_incoming_message(
5992      SseDeserializer deserializer,
5993    ) {
5994      // Codec=Sse (Serialization based), see doc to use other codecs
5995  
5996      if (sse_decode_bool(deserializer)) {
5997        return (sse_decode_box_autoadd_iroh_incoming_message(deserializer));
5998      } else {
5999        return null;
6000      }
6001    }
6002  
6003    @protected
6004    MessageInfo? sse_decode_opt_box_autoadd_message_info(
6005      SseDeserializer deserializer,
6006    ) {
6007      // Codec=Sse (Serialization based), see doc to use other codecs
6008  
6009      if (sse_decode_bool(deserializer)) {
6010        return (sse_decode_box_autoadd_message_info(deserializer));
6011      } else {
6012        return null;
6013      }
6014    }
6015  
6016    @protected
6017    (String, BigInt)? sse_decode_opt_box_autoadd_record_string_u_64(
6018      SseDeserializer deserializer,
6019    ) {
6020      // Codec=Sse (Serialization based), see doc to use other codecs
6021  
6022      if (sse_decode_bool(deserializer)) {
6023        return (sse_decode_box_autoadd_record_string_u_64(deserializer));
6024      } else {
6025        return null;
6026      }
6027    }
6028  
6029    @protected
6030    (int, int)? sse_decode_opt_box_autoadd_record_u_32_u_32(
6031      SseDeserializer deserializer,
6032    ) {
6033      // Codec=Sse (Serialization based), see doc to use other codecs
6034  
6035      if (sse_decode_bool(deserializer)) {
6036        return (sse_decode_box_autoadd_record_u_32_u_32(deserializer));
6037      } else {
6038        return null;
6039      }
6040    }
6041  
6042    @protected
6043    TransportAddressDto? sse_decode_opt_box_autoadd_transport_address_dto(
6044      SseDeserializer deserializer,
6045    ) {
6046      // Codec=Sse (Serialization based), see doc to use other codecs
6047  
6048      if (sse_decode_bool(deserializer)) {
6049        return (sse_decode_box_autoadd_transport_address_dto(deserializer));
6050      } else {
6051        return null;
6052      }
6053    }
6054  
6055    @protected
6056    TransportTypeDto? sse_decode_opt_box_autoadd_transport_type_dto(
6057      SseDeserializer deserializer,
6058    ) {
6059      // Codec=Sse (Serialization based), see doc to use other codecs
6060  
6061      if (sse_decode_bool(deserializer)) {
6062        return (sse_decode_box_autoadd_transport_type_dto(deserializer));
6063      } else {
6064        return null;
6065      }
6066    }
6067  
6068    @protected
6069    int? sse_decode_opt_box_autoadd_u_32(SseDeserializer deserializer) {
6070      // Codec=Sse (Serialization based), see doc to use other codecs
6071  
6072      if (sse_decode_bool(deserializer)) {
6073        return (sse_decode_box_autoadd_u_32(deserializer));
6074      } else {
6075        return null;
6076      }
6077    }
6078  
6079    @protected
6080    Uint8List? sse_decode_opt_list_prim_u_8_strict(SseDeserializer deserializer) {
6081      // Codec=Sse (Serialization based), see doc to use other codecs
6082  
6083      if (sse_decode_bool(deserializer)) {
6084        return (sse_decode_list_prim_u_8_strict(deserializer));
6085      } else {
6086        return null;
6087      }
6088    }
6089  
6090    @protected
6091    PendingContact sse_decode_pending_contact(SseDeserializer deserializer) {
6092      // Codec=Sse (Serialization based), see doc to use other codecs
6093      var var_contactId = sse_decode_list_prim_u_8_strict(deserializer);
6094      var var_identityPublic = sse_decode_list_prim_u_8_strict(deserializer);
6095      var var_exchangePublic = sse_decode_list_prim_u_8_strict(deserializer);
6096      var var_fingerprint = sse_decode_String(deserializer);
6097      return PendingContact(
6098        contactId: var_contactId,
6099        identityPublic: var_identityPublic,
6100        exchangePublic: var_exchangePublic,
6101        fingerprint: var_fingerprint,
6102      );
6103    }
6104  
6105    @protected
6106    ReactionSummaryDto sse_decode_reaction_summary_dto(
6107      SseDeserializer deserializer,
6108    ) {
6109      // Codec=Sse (Serialization based), see doc to use other codecs
6110      var var_emoji = sse_decode_String(deserializer);
6111      var var_count = sse_decode_u_32(deserializer);
6112      var var_includesSelf = sse_decode_bool(deserializer);
6113      return ReactionSummaryDto(
6114        emoji: var_emoji,
6115        count: var_count,
6116        includesSelf: var_includesSelf,
6117      );
6118    }
6119  
6120    @protected
6121    (ExchangeComplete, GossipExchangeHandle)
6122    sse_decode_record_exchange_complete_gossip_exchange_handle(
6123      SseDeserializer deserializer,
6124    ) {
6125      // Codec=Sse (Serialization based), see doc to use other codecs
6126      var var_field0 = sse_decode_exchange_complete(deserializer);
6127      var var_field1 = sse_decode_gossip_exchange_handle(deserializer);
6128      return (var_field0, var_field1);
6129    }
6130  
6131    @protected
6132    (String, BigInt) sse_decode_record_string_u_64(SseDeserializer deserializer) {
6133      // Codec=Sse (Serialization based), see doc to use other codecs
6134      var var_field0 = sse_decode_String(deserializer);
6135      var var_field1 = sse_decode_u_64(deserializer);
6136      return (var_field0, var_field1);
6137    }
6138  
6139    @protected
6140    (int, int) sse_decode_record_u_32_u_32(SseDeserializer deserializer) {
6141      // Codec=Sse (Serialization based), see doc to use other codecs
6142      var var_field0 = sse_decode_u_32(deserializer);
6143      var var_field1 = sse_decode_u_32(deserializer);
6144      return (var_field0, var_field1);
6145    }
6146  
6147    @protected
6148    RelayState sse_decode_relay_state(SseDeserializer deserializer) {
6149      // Codec=Sse (Serialization based), see doc to use other codecs
6150  
6151      var tag_ = sse_decode_i_32(deserializer);
6152      switch (tag_) {
6153        case 0:
6154          return RelayState_Disconnected();
6155        case 1:
6156          return RelayState_Connecting();
6157        case 2:
6158          var var_relayUrl = sse_decode_String(deserializer);
6159          return RelayState_Connected(relayUrl: var_relayUrl);
6160        case 3:
6161          var var_error = sse_decode_String(deserializer);
6162          return RelayState_Failed(error: var_error);
6163        default:
6164          throw UnimplementedError('');
6165      }
6166    }
6167  
6168    @protected
6169    RelayStateDto sse_decode_relay_state_dto(SseDeserializer deserializer) {
6170      // Codec=Sse (Serialization based), see doc to use other codecs
6171      var var_state = sse_decode_String(deserializer);
6172      var var_connectedRelay = sse_decode_opt_String(deserializer);
6173      var var_error = sse_decode_opt_String(deserializer);
6174      return RelayStateDto(
6175        state: var_state,
6176        connectedRelay: var_connectedRelay,
6177        error: var_error,
6178      );
6179    }
6180  
6181    @protected
6182    ReputationInfo sse_decode_reputation_info(SseDeserializer deserializer) {
6183      // Codec=Sse (Serialization based), see doc to use other codecs
6184      var var_messagesForwarded = sse_decode_u_64(deserializer);
6185      var var_messagesDelivered = sse_decode_u_64(deserializer);
6186      var var_recipientsHelped = sse_decode_u_32(deserializer);
6187      var var_totalXp = sse_decode_u_64(deserializer);
6188      var var_currentLevel = sse_decode_u_8(deserializer);
6189      var var_levelTitle = sse_decode_String(deserializer);
6190      var var_levelProgress = sse_decode_f_64(deserializer);
6191      var var_xpForNextLevel = sse_decode_u_64(deserializer);
6192      var var_currentStreak = sse_decode_u_32(deserializer);
6193      return ReputationInfo(
6194        messagesForwarded: var_messagesForwarded,
6195        messagesDelivered: var_messagesDelivered,
6196        recipientsHelped: var_recipientsHelped,
6197        totalXp: var_totalXp,
6198        currentLevel: var_currentLevel,
6199        levelTitle: var_levelTitle,
6200        levelProgress: var_levelProgress,
6201        xpForNextLevel: var_xpForNextLevel,
6202        currentStreak: var_currentStreak,
6203      );
6204    }
6205  
6206    @protected
6207    SearchResultInfo sse_decode_search_result_info(SseDeserializer deserializer) {
6208      // Codec=Sse (Serialization based), see doc to use other codecs
6209      var var_messageId = sse_decode_list_prim_u_8_strict(deserializer);
6210      var var_contactId = sse_decode_list_prim_u_8_strict(deserializer);
6211      var var_isOutbound = sse_decode_bool(deserializer);
6212      var var_contentType = sse_decode_u_8(deserializer);
6213      var var_content = sse_decode_list_prim_u_8_strict(deserializer);
6214      var var_filename = sse_decode_opt_String(deserializer);
6215      var var_timestamp = sse_decode_i_64(deserializer);
6216      return SearchResultInfo(
6217        messageId: var_messageId,
6218        contactId: var_contactId,
6219        isOutbound: var_isOutbound,
6220        contentType: var_contentType,
6221        content: var_content,
6222        filename: var_filename,
6223        timestamp: var_timestamp,
6224      );
6225    }
6226  
6227    @protected
6228    TransportAddress sse_decode_transport_address(SseDeserializer deserializer) {
6229      // Codec=Sse (Serialization based), see doc to use other codecs
6230      var var_transportType = sse_decode_transport_type(deserializer);
6231      var var_address = sse_decode_list_prim_u_8_strict(deserializer);
6232      return TransportAddress(
6233        transportType: var_transportType,
6234        address: var_address,
6235      );
6236    }
6237  
6238    @protected
6239    TransportAddressDto sse_decode_transport_address_dto(
6240      SseDeserializer deserializer,
6241    ) {
6242      // Codec=Sse (Serialization based), see doc to use other codecs
6243      var var_transportType = sse_decode_transport_type_dto(deserializer);
6244      var var_address = sse_decode_list_prim_u_8_strict(deserializer);
6245      return TransportAddressDto(
6246        transportType: var_transportType,
6247        address: var_address,
6248      );
6249    }
6250  
6251    @protected
6252    TransportInfoDto sse_decode_transport_info_dto(SseDeserializer deserializer) {
6253      // Codec=Sse (Serialization based), see doc to use other codecs
6254      var var_transportType = sse_decode_transport_type_dto(deserializer);
6255      var var_name = sse_decode_String(deserializer);
6256      var var_available = sse_decode_bool(deserializer);
6257      var var_priority = sse_decode_u_8(deserializer);
6258      return TransportInfoDto(
6259        transportType: var_transportType,
6260        name: var_name,
6261        available: var_available,
6262        priority: var_priority,
6263      );
6264    }
6265  
6266    @protected
6267    TransportStatsInfo sse_decode_transport_stats_info(
6268      SseDeserializer deserializer,
6269    ) {
6270      // Codec=Sse (Serialization based), see doc to use other codecs
6271      var var_bleCount = sse_decode_u_32(deserializer);
6272      var var_dhtCount = sse_decode_u_32(deserializer);
6273      var var_relayCount = sse_decode_u_32(deserializer);
6274      var var_irohCount = sse_decode_u_32(deserializer);
6275      return TransportStatsInfo(
6276        bleCount: var_bleCount,
6277        dhtCount: var_dhtCount,
6278        relayCount: var_relayCount,
6279        irohCount: var_irohCount,
6280      );
6281    }
6282  
6283    @protected
6284    TransportType sse_decode_transport_type(SseDeserializer deserializer) {
6285      // Codec=Sse (Serialization based), see doc to use other codecs
6286      var inner = sse_decode_i_32(deserializer);
6287      return TransportType.values[inner];
6288    }
6289  
6290    @protected
6291    TransportTypeDto sse_decode_transport_type_dto(SseDeserializer deserializer) {
6292      // Codec=Sse (Serialization based), see doc to use other codecs
6293      var inner = sse_decode_i_32(deserializer);
6294      return TransportTypeDto.values[inner];
6295    }
6296  
6297    @protected
6298    int sse_decode_u_32(SseDeserializer deserializer) {
6299      // Codec=Sse (Serialization based), see doc to use other codecs
6300      return deserializer.buffer.getUint32();
6301    }
6302  
6303    @protected
6304    BigInt sse_decode_u_64(SseDeserializer deserializer) {
6305      // Codec=Sse (Serialization based), see doc to use other codecs
6306      return deserializer.buffer.getBigUint64();
6307    }
6308  
6309    @protected
6310    int sse_decode_u_8(SseDeserializer deserializer) {
6311      // Codec=Sse (Serialization based), see doc to use other codecs
6312      return deserializer.buffer.getUint8();
6313    }
6314  
6315    @protected
6316    void sse_decode_unit(SseDeserializer deserializer) {
6317      // Codec=Sse (Serialization based), see doc to use other codecs
6318    }
6319  
6320    @protected
6321    BigInt sse_decode_usize(SseDeserializer deserializer) {
6322      // Codec=Sse (Serialization based), see doc to use other codecs
6323      return deserializer.buffer.getBigUint64();
6324    }
6325  
6326    @protected
6327    void sse_encode_String(String self, SseSerializer serializer) {
6328      // Codec=Sse (Serialization based), see doc to use other codecs
6329      sse_encode_list_prim_u_8_strict(utf8.encoder.convert(self), serializer);
6330    }
6331  
6332    @protected
6333    void sse_encode_achievement_info(
6334      AchievementInfo self,
6335      SseSerializer serializer,
6336    ) {
6337      // Codec=Sse (Serialization based), see doc to use other codecs
6338      sse_encode_u_8(self.id, serializer);
6339      sse_encode_String(self.name, serializer);
6340      sse_encode_String(self.description, serializer);
6341      sse_encode_bool(self.unlocked, serializer);
6342    }
6343  
6344    @protected
6345    void sse_encode_bool(bool self, SseSerializer serializer) {
6346      // Codec=Sse (Serialization based), see doc to use other codecs
6347      serializer.buffer.putUint8(self ? 1 : 0);
6348    }
6349  
6350    @protected
6351    void sse_encode_box_autoadd_dht_state(
6352      DhtState self,
6353      SseSerializer serializer,
6354    ) {
6355      // Codec=Sse (Serialization based), see doc to use other codecs
6356      sse_encode_dht_state(self, serializer);
6357    }
6358  
6359    @protected
6360    void sse_encode_box_autoadd_exchange_handle(
6361      ExchangeHandle self,
6362      SseSerializer serializer,
6363    ) {
6364      // Codec=Sse (Serialization based), see doc to use other codecs
6365      sse_encode_exchange_handle(self, serializer);
6366    }
6367  
6368    @protected
6369    void sse_encode_box_autoadd_gossip_exchange_handle(
6370      GossipExchangeHandle self,
6371      SseSerializer serializer,
6372    ) {
6373      // Codec=Sse (Serialization based), see doc to use other codecs
6374      sse_encode_gossip_exchange_handle(self, serializer);
6375    }
6376  
6377    @protected
6378    void sse_encode_box_autoadd_handshake_handle(
6379      HandshakeHandle self,
6380      SseSerializer serializer,
6381    ) {
6382      // Codec=Sse (Serialization based), see doc to use other codecs
6383      sse_encode_handshake_handle(self, serializer);
6384    }
6385  
6386    @protected
6387    void sse_encode_box_autoadd_i_64(
6388      PlatformInt64 self,
6389      SseSerializer serializer,
6390    ) {
6391      // Codec=Sse (Serialization based), see doc to use other codecs
6392      sse_encode_i_64(self, serializer);
6393    }
6394  
6395    @protected
6396    void sse_encode_box_autoadd_iroh_incoming_message(
6397      IrohIncomingMessage self,
6398      SseSerializer serializer,
6399    ) {
6400      // Codec=Sse (Serialization based), see doc to use other codecs
6401      sse_encode_iroh_incoming_message(self, serializer);
6402    }
6403  
6404    @protected
6405    void sse_encode_box_autoadd_message_info(
6406      MessageInfo self,
6407      SseSerializer serializer,
6408    ) {
6409      // Codec=Sse (Serialization based), see doc to use other codecs
6410      sse_encode_message_info(self, serializer);
6411    }
6412  
6413    @protected
6414    void sse_encode_box_autoadd_pending_contact(
6415      PendingContact self,
6416      SseSerializer serializer,
6417    ) {
6418      // Codec=Sse (Serialization based), see doc to use other codecs
6419      sse_encode_pending_contact(self, serializer);
6420    }
6421  
6422    @protected
6423    void sse_encode_box_autoadd_record_string_u_64(
6424      (String, BigInt) self,
6425      SseSerializer serializer,
6426    ) {
6427      // Codec=Sse (Serialization based), see doc to use other codecs
6428      sse_encode_record_string_u_64(self, serializer);
6429    }
6430  
6431    @protected
6432    void sse_encode_box_autoadd_record_u_32_u_32(
6433      (int, int) self,
6434      SseSerializer serializer,
6435    ) {
6436      // Codec=Sse (Serialization based), see doc to use other codecs
6437      sse_encode_record_u_32_u_32(self, serializer);
6438    }
6439  
6440    @protected
6441    void sse_encode_box_autoadd_relay_state(
6442      RelayState self,
6443      SseSerializer serializer,
6444    ) {
6445      // Codec=Sse (Serialization based), see doc to use other codecs
6446      sse_encode_relay_state(self, serializer);
6447    }
6448  
6449    @protected
6450    void sse_encode_box_autoadd_transport_address(
6451      TransportAddress self,
6452      SseSerializer serializer,
6453    ) {
6454      // Codec=Sse (Serialization based), see doc to use other codecs
6455      sse_encode_transport_address(self, serializer);
6456    }
6457  
6458    @protected
6459    void sse_encode_box_autoadd_transport_address_dto(
6460      TransportAddressDto self,
6461      SseSerializer serializer,
6462    ) {
6463      // Codec=Sse (Serialization based), see doc to use other codecs
6464      sse_encode_transport_address_dto(self, serializer);
6465    }
6466  
6467    @protected
6468    void sse_encode_box_autoadd_transport_type_dto(
6469      TransportTypeDto self,
6470      SseSerializer serializer,
6471    ) {
6472      // Codec=Sse (Serialization based), see doc to use other codecs
6473      sse_encode_transport_type_dto(self, serializer);
6474    }
6475  
6476    @protected
6477    void sse_encode_box_autoadd_u_32(int self, SseSerializer serializer) {
6478      // Codec=Sse (Serialization based), see doc to use other codecs
6479      sse_encode_u_32(self, serializer);
6480    }
6481  
6482    @protected
6483    void sse_encode_cached_iroh_endpoint(
6484      CachedIrohEndpoint self,
6485      SseSerializer serializer,
6486    ) {
6487      // Codec=Sse (Serialization based), see doc to use other codecs
6488      sse_encode_list_prim_u_8_strict(self.contactId, serializer);
6489      sse_encode_String(self.endpointId, serializer);
6490    }
6491  
6492    @protected
6493    void sse_encode_cached_onion_address(
6494      CachedOnionAddress self,
6495      SseSerializer serializer,
6496    ) {
6497      // Codec=Sse (Serialization based), see doc to use other codecs
6498      sse_encode_list_prim_u_8_strict(self.contactId, serializer);
6499      sse_encode_String(self.onionAddress, serializer);
6500    }
6501  
6502    @protected
6503    void sse_encode_contact_info(ContactInfo self, SseSerializer serializer) {
6504      // Codec=Sse (Serialization based), see doc to use other codecs
6505      sse_encode_list_prim_u_8_strict(self.contactId, serializer);
6506      sse_encode_opt_String(self.nickname, serializer);
6507      sse_encode_u_8(self.state, serializer);
6508      sse_encode_String(self.fingerprint, serializer);
6509      sse_encode_i_64(self.createdAt, serializer);
6510      sse_encode_opt_box_autoadd_i_64(self.lastSeen, serializer);
6511      sse_encode_u_32(self.queuedCount, serializer);
6512      sse_encode_u_32(self.unreadCount, serializer);
6513      sse_encode_u_64(self.disappearingDuration, serializer);
6514      sse_encode_bool(self.isMuted, serializer);
6515    }
6516  
6517    @protected
6518    void sse_encode_dht_fetch_result(
6519      DhtFetchResult self,
6520      SseSerializer serializer,
6521    ) {
6522      // Codec=Sse (Serialization based), see doc to use other codecs
6523      sse_encode_list_message_info(self.messages, serializer);
6524      sse_encode_list_list_prim_u_8_strict(
6525        self.contactsWithReactions,
6526        serializer,
6527      );
6528      sse_encode_bool(self.hadGroupManagement, serializer);
6529    }
6530  
6531    @protected
6532    void sse_encode_dht_publish_result(
6533      DhtPublishResult self,
6534      SseSerializer serializer,
6535    ) {
6536      // Codec=Sse (Serialization based), see doc to use other codecs
6537      sse_encode_u_32(self.publishedCount, serializer);
6538      sse_encode_list_list_prim_u_8_strict(self.publishedIds, serializer);
6539    }
6540  
6541    @protected
6542    void sse_encode_dht_state(DhtState self, SseSerializer serializer) {
6543      // Codec=Sse (Serialization based), see doc to use other codecs
6544      switch (self) {
6545        case DhtState_Disconnected():
6546          sse_encode_i_32(0, serializer);
6547        case DhtState_Bootstrapping():
6548          sse_encode_i_32(1, serializer);
6549        case DhtState_Connected(peerCount: final peerCount):
6550          sse_encode_i_32(2, serializer);
6551          sse_encode_usize(peerCount, serializer);
6552        case DhtState_Failed(error: final error):
6553          sse_encode_i_32(3, serializer);
6554          sse_encode_String(error, serializer);
6555      }
6556    }
6557  
6558    @protected
6559    void sse_encode_dht_state_dto(DhtStateDto self, SseSerializer serializer) {
6560      // Codec=Sse (Serialization based), see doc to use other codecs
6561      sse_encode_String(self.state, serializer);
6562      sse_encode_u_32(self.peerCount, serializer);
6563      sse_encode_opt_String(self.error, serializer);
6564    }
6565  
6566    @protected
6567    void sse_encode_document_info(DocumentInfo self, SseSerializer serializer) {
6568      // Codec=Sse (Serialization based), see doc to use other codecs
6569      sse_encode_list_prim_u_8_strict(self.documentId, serializer);
6570      sse_encode_String(self.filename, serializer);
6571      sse_encode_u_64(self.size, serializer);
6572      sse_encode_list_prim_u_8_strict(self.content, serializer);
6573    }
6574  
6575    @protected
6576    void sse_encode_encrypted_payload(
6577      EncryptedPayload self,
6578      SseSerializer serializer,
6579    ) {
6580      // Codec=Sse (Serialization based), see doc to use other codecs
6581      sse_encode_list_prim_u_8_strict(self.messageId, serializer);
6582      sse_encode_list_prim_u_8_strict(self.payload, serializer);
6583    }
6584  
6585    @protected
6586    void sse_encode_exchange_complete(
6587      ExchangeComplete self,
6588      SseSerializer serializer,
6589    ) {
6590      // Codec=Sse (Serialization based), see doc to use other codecs
6591      sse_encode_list_prim_u_8_strict(self.contactId, serializer);
6592      sse_encode_list_list_prim_u_8_strict(self.deliveredIds, serializer);
6593      sse_encode_list_message_info(self.receivedMessages, serializer);
6594    }
6595  
6596    @protected
6597    void sse_encode_exchange_handle(
6598      ExchangeHandle self,
6599      SseSerializer serializer,
6600    ) {
6601      // Codec=Sse (Serialization based), see doc to use other codecs
6602      sse_encode_u_64(self.id, serializer);
6603    }
6604  
6605    @protected
6606    void sse_encode_exchange_result_dto(
6607      ExchangeResultDto self,
6608      SseSerializer serializer,
6609    ) {
6610      // Codec=Sse (Serialization based), see doc to use other codecs
6611      sse_encode_bool(self.complete, serializer);
6612      sse_encode_opt_list_prim_u_8_strict(self.response, serializer);
6613    }
6614  
6615    @protected
6616    void sse_encode_f_64(double self, SseSerializer serializer) {
6617      // Codec=Sse (Serialization based), see doc to use other codecs
6618      serializer.buffer.putFloat64(self);
6619    }
6620  
6621    @protected
6622    void sse_encode_forwarding_info(
6623      ForwardingInfo self,
6624      SseSerializer serializer,
6625    ) {
6626      // Codec=Sse (Serialization based), see doc to use other codecs
6627      sse_encode_u_32(self.messageCount, serializer);
6628      sse_encode_u_64(self.storageUsed, serializer);
6629      sse_encode_u_64(self.storageLimit, serializer);
6630      sse_encode_u_32(self.uniqueRecipients, serializer);
6631      sse_encode_f_64(self.fillPercentage, serializer);
6632    }
6633  
6634    @protected
6635    void sse_encode_gossip_exchange_complete(
6636      GossipExchangeComplete self,
6637      SseSerializer serializer,
6638    ) {
6639      // Codec=Sse (Serialization based), see doc to use other codecs
6640      sse_encode_u_32(self.storedCount, serializer);
6641      sse_encode_u_32(self.messagesForUsCount, serializer);
6642    }
6643  
6644    @protected
6645    void sse_encode_gossip_exchange_handle(
6646      GossipExchangeHandle self,
6647      SseSerializer serializer,
6648    ) {
6649      // Codec=Sse (Serialization based), see doc to use other codecs
6650      sse_encode_u_64(self.id, serializer);
6651    }
6652  
6653    @protected
6654    void sse_encode_gossip_finalize_keep_transport_result(
6655      GossipFinalizeKeepTransportResult self,
6656      SseSerializer serializer,
6657    ) {
6658      // Codec=Sse (Serialization based), see doc to use other codecs
6659      sse_encode_gossip_exchange_complete(self.result, serializer);
6660      sse_encode_u_64(self.transportHandle, serializer);
6661    }
6662  
6663    @protected
6664    void sse_encode_gossip_result(GossipResult self, SseSerializer serializer) {
6665      // Codec=Sse (Serialization based), see doc to use other codecs
6666      sse_encode_u_32(self.storedCount, serializer);
6667      sse_encode_u_32(self.messagesForUs, serializer);
6668    }
6669  
6670    @protected
6671    void sse_encode_group_info(GroupInfo self, SseSerializer serializer) {
6672      // Codec=Sse (Serialization based), see doc to use other codecs
6673      sse_encode_list_prim_u_8_strict(self.groupId, serializer);
6674      sse_encode_String(self.name, serializer);
6675      sse_encode_i_64(self.createdAt, serializer);
6676      sse_encode_u_32(self.memberCount, serializer);
6677      sse_encode_u_32(self.unreadCount, serializer);
6678      sse_encode_u_64(self.disappearingDuration, serializer);
6679      sse_encode_bool(self.isMuted, serializer);
6680      sse_encode_opt_box_autoadd_i_64(self.lastMessageAt, serializer);
6681      sse_encode_bool(self.accepted, serializer);
6682      sse_encode_bool(self.isCreator, serializer);
6683    }
6684  
6685    @protected
6686    void sse_encode_group_member_info_dto(
6687      GroupMemberInfoDto self,
6688      SseSerializer serializer,
6689    ) {
6690      // Codec=Sse (Serialization based), see doc to use other codecs
6691      sse_encode_list_prim_u_8_strict(self.contactId, serializer);
6692      sse_encode_opt_String(self.nickname, serializer);
6693      sse_encode_u_8(self.role, serializer);
6694    }
6695  
6696    @protected
6697    void sse_encode_handshake_handle(
6698      HandshakeHandle self,
6699      SseSerializer serializer,
6700    ) {
6701      // Codec=Sse (Serialization based), see doc to use other codecs
6702      sse_encode_u_64(self.id, serializer);
6703    }
6704  
6705    @protected
6706    void sse_encode_handshake_result(
6707      HandshakeResult self,
6708      SseSerializer serializer,
6709    ) {
6710      // Codec=Sse (Serialization based), see doc to use other codecs
6711      sse_encode_bool(self.complete, serializer);
6712      sse_encode_opt_list_prim_u_8_strict(self.response, serializer);
6713      sse_encode_opt_list_prim_u_8_strict(self.remoteIdentity, serializer);
6714    }
6715  
6716    @protected
6717    void sse_encode_i_32(int self, SseSerializer serializer) {
6718      // Codec=Sse (Serialization based), see doc to use other codecs
6719      serializer.buffer.putInt32(self);
6720    }
6721  
6722    @protected
6723    void sse_encode_i_64(PlatformInt64 self, SseSerializer serializer) {
6724      // Codec=Sse (Serialization based), see doc to use other codecs
6725      serializer.buffer.putPlatformInt64(self);
6726    }
6727  
6728    @protected
6729    void sse_encode_identity_info(IdentityInfo self, SseSerializer serializer) {
6730      // Codec=Sse (Serialization based), see doc to use other codecs
6731      sse_encode_list_prim_u_8_strict(self.identityPublic, serializer);
6732      sse_encode_list_prim_u_8_strict(self.exchangePublic, serializer);
6733      sse_encode_String(self.fingerprint, serializer);
6734      sse_encode_i_64(self.createdAt, serializer);
6735    }
6736  
6737    @protected
6738    void sse_encode_iroh_incoming_message(
6739      IrohIncomingMessage self,
6740      SseSerializer serializer,
6741    ) {
6742      // Codec=Sse (Serialization based), see doc to use other codecs
6743      sse_encode_list_prim_u_8_strict(self.senderNodeId, serializer);
6744      sse_encode_list_prim_u_8_strict(self.payload, serializer);
6745    }
6746  
6747    @protected
6748    void sse_encode_iroh_state_dto(IrohStateDto self, SseSerializer serializer) {
6749      // Codec=Sse (Serialization based), see doc to use other codecs
6750      sse_encode_String(self.state, serializer);
6751      sse_encode_opt_String(self.endpointId, serializer);
6752      sse_encode_opt_String(self.error, serializer);
6753    }
6754  
6755    @protected
6756    void sse_encode_list_String(List<String> self, SseSerializer serializer) {
6757      // Codec=Sse (Serialization based), see doc to use other codecs
6758      sse_encode_i_32(self.length, serializer);
6759      for (final item in self) {
6760        sse_encode_String(item, serializer);
6761      }
6762    }
6763  
6764    @protected
6765    void sse_encode_list_achievement_info(
6766      List<AchievementInfo> self,
6767      SseSerializer serializer,
6768    ) {
6769      // Codec=Sse (Serialization based), see doc to use other codecs
6770      sse_encode_i_32(self.length, serializer);
6771      for (final item in self) {
6772        sse_encode_achievement_info(item, serializer);
6773      }
6774    }
6775  
6776    @protected
6777    void sse_encode_list_cached_iroh_endpoint(
6778      List<CachedIrohEndpoint> self,
6779      SseSerializer serializer,
6780    ) {
6781      // Codec=Sse (Serialization based), see doc to use other codecs
6782      sse_encode_i_32(self.length, serializer);
6783      for (final item in self) {
6784        sse_encode_cached_iroh_endpoint(item, serializer);
6785      }
6786    }
6787  
6788    @protected
6789    void sse_encode_list_cached_onion_address(
6790      List<CachedOnionAddress> self,
6791      SseSerializer serializer,
6792    ) {
6793      // Codec=Sse (Serialization based), see doc to use other codecs
6794      sse_encode_i_32(self.length, serializer);
6795      for (final item in self) {
6796        sse_encode_cached_onion_address(item, serializer);
6797      }
6798    }
6799  
6800    @protected
6801    void sse_encode_list_contact_info(
6802      List<ContactInfo> self,
6803      SseSerializer serializer,
6804    ) {
6805      // Codec=Sse (Serialization based), see doc to use other codecs
6806      sse_encode_i_32(self.length, serializer);
6807      for (final item in self) {
6808        sse_encode_contact_info(item, serializer);
6809      }
6810    }
6811  
6812    @protected
6813    void sse_encode_list_encrypted_payload(
6814      List<EncryptedPayload> self,
6815      SseSerializer serializer,
6816    ) {
6817      // Codec=Sse (Serialization based), see doc to use other codecs
6818      sse_encode_i_32(self.length, serializer);
6819      for (final item in self) {
6820        sse_encode_encrypted_payload(item, serializer);
6821      }
6822    }
6823  
6824    @protected
6825    void sse_encode_list_group_info(
6826      List<GroupInfo> self,
6827      SseSerializer serializer,
6828    ) {
6829      // Codec=Sse (Serialization based), see doc to use other codecs
6830      sse_encode_i_32(self.length, serializer);
6831      for (final item in self) {
6832        sse_encode_group_info(item, serializer);
6833      }
6834    }
6835  
6836    @protected
6837    void sse_encode_list_group_member_info_dto(
6838      List<GroupMemberInfoDto> self,
6839      SseSerializer serializer,
6840    ) {
6841      // Codec=Sse (Serialization based), see doc to use other codecs
6842      sse_encode_i_32(self.length, serializer);
6843      for (final item in self) {
6844        sse_encode_group_member_info_dto(item, serializer);
6845      }
6846    }
6847  
6848    @protected
6849    void sse_encode_list_list_prim_u_8_strict(
6850      List<Uint8List> self,
6851      SseSerializer serializer,
6852    ) {
6853      // Codec=Sse (Serialization based), see doc to use other codecs
6854      sse_encode_i_32(self.length, serializer);
6855      for (final item in self) {
6856        sse_encode_list_prim_u_8_strict(item, serializer);
6857      }
6858    }
6859  
6860    @protected
6861    void sse_encode_list_message_info(
6862      List<MessageInfo> self,
6863      SseSerializer serializer,
6864    ) {
6865      // Codec=Sse (Serialization based), see doc to use other codecs
6866      sse_encode_i_32(self.length, serializer);
6867      for (final item in self) {
6868        sse_encode_message_info(item, serializer);
6869      }
6870    }
6871  
6872    @protected
6873    void sse_encode_list_prim_u_8_loose(
6874      List<int> self,
6875      SseSerializer serializer,
6876    ) {
6877      // Codec=Sse (Serialization based), see doc to use other codecs
6878      sse_encode_i_32(self.length, serializer);
6879      serializer.buffer.putUint8List(
6880        self is Uint8List ? self : Uint8List.fromList(self),
6881      );
6882    }
6883  
6884    @protected
6885    void sse_encode_list_prim_u_8_strict(
6886      Uint8List self,
6887      SseSerializer serializer,
6888    ) {
6889      // Codec=Sse (Serialization based), see doc to use other codecs
6890      sse_encode_i_32(self.length, serializer);
6891      serializer.buffer.putUint8List(self);
6892    }
6893  
6894    @protected
6895    void sse_encode_list_reaction_summary_dto(
6896      List<ReactionSummaryDto> self,
6897      SseSerializer serializer,
6898    ) {
6899      // Codec=Sse (Serialization based), see doc to use other codecs
6900      sse_encode_i_32(self.length, serializer);
6901      for (final item in self) {
6902        sse_encode_reaction_summary_dto(item, serializer);
6903      }
6904    }
6905  
6906    @protected
6907    void sse_encode_list_search_result_info(
6908      List<SearchResultInfo> self,
6909      SseSerializer serializer,
6910    ) {
6911      // Codec=Sse (Serialization based), see doc to use other codecs
6912      sse_encode_i_32(self.length, serializer);
6913      for (final item in self) {
6914        sse_encode_search_result_info(item, serializer);
6915      }
6916    }
6917  
6918    @protected
6919    void sse_encode_list_transport_info_dto(
6920      List<TransportInfoDto> self,
6921      SseSerializer serializer,
6922    ) {
6923      // Codec=Sse (Serialization based), see doc to use other codecs
6924      sse_encode_i_32(self.length, serializer);
6925      for (final item in self) {
6926        sse_encode_transport_info_dto(item, serializer);
6927      }
6928    }
6929  
6930    @protected
6931    void sse_encode_message_info(MessageInfo self, SseSerializer serializer) {
6932      // Codec=Sse (Serialization based), see doc to use other codecs
6933      sse_encode_list_prim_u_8_strict(self.messageId, serializer);
6934      sse_encode_list_prim_u_8_strict(self.contactId, serializer);
6935      sse_encode_u_8(self.contentType, serializer);
6936      sse_encode_list_prim_u_8_strict(self.content, serializer);
6937      sse_encode_opt_String(self.filename, serializer);
6938      sse_encode_bool(self.isOutbound, serializer);
6939      sse_encode_u_8(self.state, serializer);
6940      sse_encode_i_64(self.timestamp, serializer);
6941      sse_encode_opt_box_autoadd_i_64(self.expiresAt, serializer);
6942      sse_encode_opt_String(self.deliveryTransport, serializer);
6943      sse_encode_opt_box_autoadd_i_64(self.deliveredAt, serializer);
6944      sse_encode_opt_String(self.lastError, serializer);
6945      sse_encode_list_reaction_summary_dto(self.reactions, serializer);
6946      sse_encode_u_64(self.disappearingDuration, serializer);
6947      sse_encode_opt_list_prim_u_8_strict(self.senderId, serializer);
6948      sse_encode_opt_list_prim_u_8_strict(self.groupId, serializer);
6949    }
6950  
6951    @protected
6952    void sse_encode_network_transport_preference(
6953      NetworkTransportPreference self,
6954      SseSerializer serializer,
6955    ) {
6956      // Codec=Sse (Serialization based), see doc to use other codecs
6957      sse_encode_i_32(self.index, serializer);
6958    }
6959  
6960    @protected
6961    void sse_encode_opt_String(String? self, SseSerializer serializer) {
6962      // Codec=Sse (Serialization based), see doc to use other codecs
6963  
6964      sse_encode_bool(self != null, serializer);
6965      if (self != null) {
6966        sse_encode_String(self, serializer);
6967      }
6968    }
6969  
6970    @protected
6971    void sse_encode_opt_box_autoadd_i_64(
6972      PlatformInt64? self,
6973      SseSerializer serializer,
6974    ) {
6975      // Codec=Sse (Serialization based), see doc to use other codecs
6976  
6977      sse_encode_bool(self != null, serializer);
6978      if (self != null) {
6979        sse_encode_box_autoadd_i_64(self, serializer);
6980      }
6981    }
6982  
6983    @protected
6984    void sse_encode_opt_box_autoadd_iroh_incoming_message(
6985      IrohIncomingMessage? self,
6986      SseSerializer serializer,
6987    ) {
6988      // Codec=Sse (Serialization based), see doc to use other codecs
6989  
6990      sse_encode_bool(self != null, serializer);
6991      if (self != null) {
6992        sse_encode_box_autoadd_iroh_incoming_message(self, serializer);
6993      }
6994    }
6995  
6996    @protected
6997    void sse_encode_opt_box_autoadd_message_info(
6998      MessageInfo? self,
6999      SseSerializer serializer,
7000    ) {
7001      // Codec=Sse (Serialization based), see doc to use other codecs
7002  
7003      sse_encode_bool(self != null, serializer);
7004      if (self != null) {
7005        sse_encode_box_autoadd_message_info(self, serializer);
7006      }
7007    }
7008  
7009    @protected
7010    void sse_encode_opt_box_autoadd_record_string_u_64(
7011      (String, BigInt)? self,
7012      SseSerializer serializer,
7013    ) {
7014      // Codec=Sse (Serialization based), see doc to use other codecs
7015  
7016      sse_encode_bool(self != null, serializer);
7017      if (self != null) {
7018        sse_encode_box_autoadd_record_string_u_64(self, serializer);
7019      }
7020    }
7021  
7022    @protected
7023    void sse_encode_opt_box_autoadd_record_u_32_u_32(
7024      (int, int)? self,
7025      SseSerializer serializer,
7026    ) {
7027      // Codec=Sse (Serialization based), see doc to use other codecs
7028  
7029      sse_encode_bool(self != null, serializer);
7030      if (self != null) {
7031        sse_encode_box_autoadd_record_u_32_u_32(self, serializer);
7032      }
7033    }
7034  
7035    @protected
7036    void sse_encode_opt_box_autoadd_transport_address_dto(
7037      TransportAddressDto? self,
7038      SseSerializer serializer,
7039    ) {
7040      // Codec=Sse (Serialization based), see doc to use other codecs
7041  
7042      sse_encode_bool(self != null, serializer);
7043      if (self != null) {
7044        sse_encode_box_autoadd_transport_address_dto(self, serializer);
7045      }
7046    }
7047  
7048    @protected
7049    void sse_encode_opt_box_autoadd_transport_type_dto(
7050      TransportTypeDto? self,
7051      SseSerializer serializer,
7052    ) {
7053      // Codec=Sse (Serialization based), see doc to use other codecs
7054  
7055      sse_encode_bool(self != null, serializer);
7056      if (self != null) {
7057        sse_encode_box_autoadd_transport_type_dto(self, serializer);
7058      }
7059    }
7060  
7061    @protected
7062    void sse_encode_opt_box_autoadd_u_32(int? self, SseSerializer serializer) {
7063      // Codec=Sse (Serialization based), see doc to use other codecs
7064  
7065      sse_encode_bool(self != null, serializer);
7066      if (self != null) {
7067        sse_encode_box_autoadd_u_32(self, serializer);
7068      }
7069    }
7070  
7071    @protected
7072    void sse_encode_opt_list_prim_u_8_strict(
7073      Uint8List? self,
7074      SseSerializer serializer,
7075    ) {
7076      // Codec=Sse (Serialization based), see doc to use other codecs
7077  
7078      sse_encode_bool(self != null, serializer);
7079      if (self != null) {
7080        sse_encode_list_prim_u_8_strict(self, serializer);
7081      }
7082    }
7083  
7084    @protected
7085    void sse_encode_pending_contact(
7086      PendingContact self,
7087      SseSerializer serializer,
7088    ) {
7089      // Codec=Sse (Serialization based), see doc to use other codecs
7090      sse_encode_list_prim_u_8_strict(self.contactId, serializer);
7091      sse_encode_list_prim_u_8_strict(self.identityPublic, serializer);
7092      sse_encode_list_prim_u_8_strict(self.exchangePublic, serializer);
7093      sse_encode_String(self.fingerprint, serializer);
7094    }
7095  
7096    @protected
7097    void sse_encode_reaction_summary_dto(
7098      ReactionSummaryDto self,
7099      SseSerializer serializer,
7100    ) {
7101      // Codec=Sse (Serialization based), see doc to use other codecs
7102      sse_encode_String(self.emoji, serializer);
7103      sse_encode_u_32(self.count, serializer);
7104      sse_encode_bool(self.includesSelf, serializer);
7105    }
7106  
7107    @protected
7108    void sse_encode_record_exchange_complete_gossip_exchange_handle(
7109      (ExchangeComplete, GossipExchangeHandle) self,
7110      SseSerializer serializer,
7111    ) {
7112      // Codec=Sse (Serialization based), see doc to use other codecs
7113      sse_encode_exchange_complete(self.$1, serializer);
7114      sse_encode_gossip_exchange_handle(self.$2, serializer);
7115    }
7116  
7117    @protected
7118    void sse_encode_record_string_u_64(
7119      (String, BigInt) self,
7120      SseSerializer serializer,
7121    ) {
7122      // Codec=Sse (Serialization based), see doc to use other codecs
7123      sse_encode_String(self.$1, serializer);
7124      sse_encode_u_64(self.$2, serializer);
7125    }
7126  
7127    @protected
7128    void sse_encode_record_u_32_u_32((int, int) self, SseSerializer serializer) {
7129      // Codec=Sse (Serialization based), see doc to use other codecs
7130      sse_encode_u_32(self.$1, serializer);
7131      sse_encode_u_32(self.$2, serializer);
7132    }
7133  
7134    @protected
7135    void sse_encode_relay_state(RelayState self, SseSerializer serializer) {
7136      // Codec=Sse (Serialization based), see doc to use other codecs
7137      switch (self) {
7138        case RelayState_Disconnected():
7139          sse_encode_i_32(0, serializer);
7140        case RelayState_Connecting():
7141          sse_encode_i_32(1, serializer);
7142        case RelayState_Connected(relayUrl: final relayUrl):
7143          sse_encode_i_32(2, serializer);
7144          sse_encode_String(relayUrl, serializer);
7145        case RelayState_Failed(error: final error):
7146          sse_encode_i_32(3, serializer);
7147          sse_encode_String(error, serializer);
7148      }
7149    }
7150  
7151    @protected
7152    void sse_encode_relay_state_dto(
7153      RelayStateDto self,
7154      SseSerializer serializer,
7155    ) {
7156      // Codec=Sse (Serialization based), see doc to use other codecs
7157      sse_encode_String(self.state, serializer);
7158      sse_encode_opt_String(self.connectedRelay, serializer);
7159      sse_encode_opt_String(self.error, serializer);
7160    }
7161  
7162    @protected
7163    void sse_encode_reputation_info(
7164      ReputationInfo self,
7165      SseSerializer serializer,
7166    ) {
7167      // Codec=Sse (Serialization based), see doc to use other codecs
7168      sse_encode_u_64(self.messagesForwarded, serializer);
7169      sse_encode_u_64(self.messagesDelivered, serializer);
7170      sse_encode_u_32(self.recipientsHelped, serializer);
7171      sse_encode_u_64(self.totalXp, serializer);
7172      sse_encode_u_8(self.currentLevel, serializer);
7173      sse_encode_String(self.levelTitle, serializer);
7174      sse_encode_f_64(self.levelProgress, serializer);
7175      sse_encode_u_64(self.xpForNextLevel, serializer);
7176      sse_encode_u_32(self.currentStreak, serializer);
7177    }
7178  
7179    @protected
7180    void sse_encode_search_result_info(
7181      SearchResultInfo self,
7182      SseSerializer serializer,
7183    ) {
7184      // Codec=Sse (Serialization based), see doc to use other codecs
7185      sse_encode_list_prim_u_8_strict(self.messageId, serializer);
7186      sse_encode_list_prim_u_8_strict(self.contactId, serializer);
7187      sse_encode_bool(self.isOutbound, serializer);
7188      sse_encode_u_8(self.contentType, serializer);
7189      sse_encode_list_prim_u_8_strict(self.content, serializer);
7190      sse_encode_opt_String(self.filename, serializer);
7191      sse_encode_i_64(self.timestamp, serializer);
7192    }
7193  
7194    @protected
7195    void sse_encode_transport_address(
7196      TransportAddress self,
7197      SseSerializer serializer,
7198    ) {
7199      // Codec=Sse (Serialization based), see doc to use other codecs
7200      sse_encode_transport_type(self.transportType, serializer);
7201      sse_encode_list_prim_u_8_strict(self.address, serializer);
7202    }
7203  
7204    @protected
7205    void sse_encode_transport_address_dto(
7206      TransportAddressDto self,
7207      SseSerializer serializer,
7208    ) {
7209      // Codec=Sse (Serialization based), see doc to use other codecs
7210      sse_encode_transport_type_dto(self.transportType, serializer);
7211      sse_encode_list_prim_u_8_strict(self.address, serializer);
7212    }
7213  
7214    @protected
7215    void sse_encode_transport_info_dto(
7216      TransportInfoDto self,
7217      SseSerializer serializer,
7218    ) {
7219      // Codec=Sse (Serialization based), see doc to use other codecs
7220      sse_encode_transport_type_dto(self.transportType, serializer);
7221      sse_encode_String(self.name, serializer);
7222      sse_encode_bool(self.available, serializer);
7223      sse_encode_u_8(self.priority, serializer);
7224    }
7225  
7226    @protected
7227    void sse_encode_transport_stats_info(
7228      TransportStatsInfo self,
7229      SseSerializer serializer,
7230    ) {
7231      // Codec=Sse (Serialization based), see doc to use other codecs
7232      sse_encode_u_32(self.bleCount, serializer);
7233      sse_encode_u_32(self.dhtCount, serializer);
7234      sse_encode_u_32(self.relayCount, serializer);
7235      sse_encode_u_32(self.irohCount, serializer);
7236    }
7237  
7238    @protected
7239    void sse_encode_transport_type(TransportType self, SseSerializer serializer) {
7240      // Codec=Sse (Serialization based), see doc to use other codecs
7241      sse_encode_i_32(self.index, serializer);
7242    }
7243  
7244    @protected
7245    void sse_encode_transport_type_dto(
7246      TransportTypeDto self,
7247      SseSerializer serializer,
7248    ) {
7249      // Codec=Sse (Serialization based), see doc to use other codecs
7250      sse_encode_i_32(self.index, serializer);
7251    }
7252  
7253    @protected
7254    void sse_encode_u_32(int self, SseSerializer serializer) {
7255      // Codec=Sse (Serialization based), see doc to use other codecs
7256      serializer.buffer.putUint32(self);
7257    }
7258  
7259    @protected
7260    void sse_encode_u_64(BigInt self, SseSerializer serializer) {
7261      // Codec=Sse (Serialization based), see doc to use other codecs
7262      serializer.buffer.putBigUint64(self);
7263    }
7264  
7265    @protected
7266    void sse_encode_u_8(int self, SseSerializer serializer) {
7267      // Codec=Sse (Serialization based), see doc to use other codecs
7268      serializer.buffer.putUint8(self);
7269    }
7270  
7271    @protected
7272    void sse_encode_unit(void self, SseSerializer serializer) {
7273      // Codec=Sse (Serialization based), see doc to use other codecs
7274    }
7275  
7276    @protected
7277    void sse_encode_usize(BigInt self, SseSerializer serializer) {
7278      // Codec=Sse (Serialization based), see doc to use other codecs
7279      serializer.buffer.putBigUint64(self);
7280    }
7281  }