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

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

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

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

  RustLib._();

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

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

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

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

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

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

  @override
  ExternalLibraryLoaderConfig get defaultExternalLibraryLoaderConfig =>
      kDefaultExternalLibraryLoaderConfig;

  @override
  String get codegenVersion => '2.9.0';

  @override
  int get rustContentHash => -79634774;

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

abstract class RustLibApi extends BaseApi {
  Future<PlatformInt64> crateApiCreateTag({required String name});

  Future<void> crateApiDeleteTimeEntry({required PlatformInt64 id});

  Future<ReportData> crateApiGenerateReport({
    PlatformInt64? tagIdFilter,
    required PlatformInt64 startDateUnixTs,
    required PlatformInt64 endDateUnixTs,
  });

  Future<TimeEntry?> crateApiGetLastUnfinishedTracking();

  Future<List<Tag>> crateApiGetTags();

  Future<void> crateApiInitApp({required String dbDirectoryPath});

  Future<PlatformInt64> crateApiStartTracking({
    PlatformInt64? tagId,
    required PlatformInt64 startTimeUnixTs,
  });

  Future<void> crateApiStopTracking({
    required PlatformInt64 entryId,
    required PlatformInt64 endTimeUnixTs,
  });

  Future<void> crateApiUpdateTimeEntry({
    required PlatformInt64 entryId,
    PlatformInt64? newTagId,
    required PlatformInt64 newStartTimeUnixTs,
    PlatformInt64? newEndTimeUnixTs,
  });
}

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

  @override
  Future<PlatformInt64> crateApiCreateTag({required String name}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(name, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 1,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_i_64,
          decodeErrorData: sse_decode_AnyhowException,
        ),
        constMeta: kCrateApiCreateTagConstMeta,
        argValues: [name],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCreateTagConstMeta =>
      const TaskConstMeta(debugName: "create_tag", argNames: ["name"]);

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

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

  @override
  Future<ReportData> crateApiGenerateReport({
    PlatformInt64? tagIdFilter,
    required PlatformInt64 startDateUnixTs,
    required PlatformInt64 endDateUnixTs,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_opt_box_autoadd_i_64(tagIdFilter, serializer);
          sse_encode_i_64(startDateUnixTs, serializer);
          sse_encode_i_64(endDateUnixTs, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 3,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_report_data,
          decodeErrorData: sse_decode_AnyhowException,
        ),
        constMeta: kCrateApiGenerateReportConstMeta,
        argValues: [tagIdFilter, startDateUnixTs, endDateUnixTs],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiGenerateReportConstMeta => const TaskConstMeta(
    debugName: "generate_report",
    argNames: ["tagIdFilter", "startDateUnixTs", "endDateUnixTs"],
  );

  @override
  Future<TimeEntry?> crateApiGetLastUnfinishedTracking() {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 4,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_opt_box_autoadd_time_entry,
          decodeErrorData: sse_decode_AnyhowException,
        ),
        constMeta: kCrateApiGetLastUnfinishedTrackingConstMeta,
        argValues: [],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiGetLastUnfinishedTrackingConstMeta =>
      const TaskConstMeta(
        debugName: "get_last_unfinished_tracking",
        argNames: [],
      );

  @override
  Future<List<Tag>> crateApiGetTags() {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 5,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_list_tag,
          decodeErrorData: sse_decode_AnyhowException,
        ),
        constMeta: kCrateApiGetTagsConstMeta,
        argValues: [],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiGetTagsConstMeta =>
      const TaskConstMeta(debugName: "get_tags", argNames: []);

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

  TaskConstMeta get kCrateApiInitAppConstMeta =>
      const TaskConstMeta(debugName: "init_app", argNames: ["dbDirectoryPath"]);

  @override
  Future<PlatformInt64> crateApiStartTracking({
    PlatformInt64? tagId,
    required PlatformInt64 startTimeUnixTs,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_opt_box_autoadd_i_64(tagId, serializer);
          sse_encode_i_64(startTimeUnixTs, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 7,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_i_64,
          decodeErrorData: sse_decode_AnyhowException,
        ),
        constMeta: kCrateApiStartTrackingConstMeta,
        argValues: [tagId, startTimeUnixTs],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiStartTrackingConstMeta => const TaskConstMeta(
    debugName: "start_tracking",
    argNames: ["tagId", "startTimeUnixTs"],
  );

  @override
  Future<void> crateApiStopTracking({
    required PlatformInt64 entryId,
    required PlatformInt64 endTimeUnixTs,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_i_64(entryId, serializer);
          sse_encode_i_64(endTimeUnixTs, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 8,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: sse_decode_AnyhowException,
        ),
        constMeta: kCrateApiStopTrackingConstMeta,
        argValues: [entryId, endTimeUnixTs],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiStopTrackingConstMeta => const TaskConstMeta(
    debugName: "stop_tracking",
    argNames: ["entryId", "endTimeUnixTs"],
  );

  @override
  Future<void> crateApiUpdateTimeEntry({
    required PlatformInt64 entryId,
    PlatformInt64? newTagId,
    required PlatformInt64 newStartTimeUnixTs,
    PlatformInt64? newEndTimeUnixTs,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_i_64(entryId, serializer);
          sse_encode_opt_box_autoadd_i_64(newTagId, serializer);
          sse_encode_i_64(newStartTimeUnixTs, serializer);
          sse_encode_opt_box_autoadd_i_64(newEndTimeUnixTs, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 9,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: sse_decode_AnyhowException,
        ),
        constMeta: kCrateApiUpdateTimeEntryConstMeta,
        argValues: [entryId, newTagId, newStartTimeUnixTs, newEndTimeUnixTs],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiUpdateTimeEntryConstMeta => const TaskConstMeta(
    debugName: "update_time_entry",
    argNames: ["entryId", "newTagId", "newStartTimeUnixTs", "newEndTimeUnixTs"],
  );

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

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

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

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

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

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

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

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

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

  @protected
  PlatformInt64? dco_decode_opt_box_autoadd_i_64(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw == null ? null : dco_decode_box_autoadd_i_64(raw);
  }

  @protected
  TimeEntry? dco_decode_opt_box_autoadd_time_entry(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw == null ? null : dco_decode_box_autoadd_time_entry(raw);
  }

  @protected
  ReportData dco_decode_report_data(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 2)
      throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
    return ReportData(
      entries: dco_decode_list_time_entry(arr[0]),
      totalDurationSecs: dco_decode_i_64(arr[1]),
    );
  }

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

  @protected
  TimeEntry dco_decode_time_entry(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 6)
      throw Exception('unexpected arr length: expect 6 but see ${arr.length}');
    return TimeEntry(
      id: dco_decode_i_64(arr[0]),
      tagId: dco_decode_opt_box_autoadd_i_64(arr[1]),
      tagName: dco_decode_opt_String(arr[2]),
      startTime: dco_decode_i_64(arr[3]),
      endTime: dco_decode_opt_box_autoadd_i_64(arr[4]),
      durationSecs: dco_decode_opt_box_autoadd_i_64(arr[5]),
    );
  }

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

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

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

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

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

  @protected
  TimeEntry sse_decode_box_autoadd_time_entry(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_time_entry(deserializer));
  }

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

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

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

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

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

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

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

    if (sse_decode_bool(deserializer)) {
      return (sse_decode_String(deserializer));
    } else {
      return null;
    }
  }

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

    if (sse_decode_bool(deserializer)) {
      return (sse_decode_box_autoadd_i_64(deserializer));
    } else {
      return null;
    }
  }

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

    if (sse_decode_bool(deserializer)) {
      return (sse_decode_box_autoadd_time_entry(deserializer));
    } else {
      return null;
    }
  }

  @protected
  ReportData sse_decode_report_data(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_entries = sse_decode_list_time_entry(deserializer);
    var var_totalDurationSecs = sse_decode_i_64(deserializer);
    return ReportData(
      entries: var_entries,
      totalDurationSecs: var_totalDurationSecs,
    );
  }

  @protected
  Tag sse_decode_tag(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_id = sse_decode_i_64(deserializer);
    var var_name = sse_decode_String(deserializer);
    return Tag(id: var_id, name: var_name);
  }

  @protected
  TimeEntry sse_decode_time_entry(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_id = sse_decode_i_64(deserializer);
    var var_tagId = sse_decode_opt_box_autoadd_i_64(deserializer);
    var var_tagName = sse_decode_opt_String(deserializer);
    var var_startTime = sse_decode_i_64(deserializer);
    var var_endTime = sse_decode_opt_box_autoadd_i_64(deserializer);
    var var_durationSecs = sse_decode_opt_box_autoadd_i_64(deserializer);
    return TimeEntry(
      id: var_id,
      tagId: var_tagId,
      tagName: var_tagName,
      startTime: var_startTime,
      endTime: var_endTime,
      durationSecs: var_durationSecs,
    );
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

    sse_encode_bool(self != null, serializer);
    if (self != null) {
      sse_encode_String(self, serializer);
    }
  }

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

    sse_encode_bool(self != null, serializer);
    if (self != null) {
      sse_encode_box_autoadd_i_64(self, serializer);
    }
  }

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

    sse_encode_bool(self != null, serializer);
    if (self != null) {
      sse_encode_box_autoadd_time_entry(self, serializer);
    }
  }

  @protected
  void sse_encode_report_data(ReportData self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_list_time_entry(self.entries, serializer);
    sse_encode_i_64(self.totalDurationSecs, serializer);
  }

  @protected
  void sse_encode_tag(Tag self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_64(self.id, serializer);
    sse_encode_String(self.name, serializer);
  }

  @protected
  void sse_encode_time_entry(TimeEntry self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_64(self.id, serializer);
    sse_encode_opt_box_autoadd_i_64(self.tagId, serializer);
    sse_encode_opt_String(self.tagName, serializer);
    sse_encode_i_64(self.startTime, serializer);
    sse_encode_opt_box_autoadd_i_64(self.endTime, serializer);
    sse_encode_opt_box_autoadd_i_64(self.durationSecs, serializer);
  }

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

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

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

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