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

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

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

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

  RustLib._();

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

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

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

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

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

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

  @override
  ExternalLibraryLoaderConfig get defaultExternalLibraryLoaderConfig =>
      kDefaultExternalLibraryLoaderConfig;

  @override
  String get codegenVersion => '2.11.1';

  @override
  int get rustContentHash => -75020133;

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

abstract class RustLibApi extends BaseApi {
  Future<void> crateApiAddWorkspace({
    required String name,
    required String path,
  });

  Future<TaskListDto> crateApiCreateList({required String name});

  Future<TaskDto> crateApiCreateTask({
    required String listId,
    required String title,
    required String description,
  });

  Future<void> crateApiDeleteList({required String listId});

  Future<void> crateApiDeleteTask({
    required String listId,
    required String taskId,
  });

  Future<AppConfigDto> crateApiGetConfig();

  Future<bool> crateApiGetGroupByDueDate({required String listId});

  Future<List<TaskListDto>> crateApiGetLists();

  Future<String> crateApiGreet({required String name});

  Future<void> crateApiInitWorkspace({required String path});

  Future<List<TaskDto>> crateApiListTasks({required String listId});

  Future<void> crateApiMoveTask({
    required String fromListId,
    required String toListId,
    required String taskId,
  });

  Future<void> crateApiRemoveWorkspace({required String name});

  Future<void> crateApiRenameList({
    required String listId,
    required String newName,
  });

  Future<void> crateApiReorderTask({
    required String listId,
    required String taskId,
    required int newPosition,
  });

  Future<void> crateApiSetCurrentWorkspace({required String name});

  Future<void> crateApiSetGroupByDueDate({
    required String listId,
    required bool enabled,
  });

  Future<TaskDto> crateApiToggleTask({
    required String listId,
    required String taskId,
  });

  Future<void> crateApiUpdateTask({
    required String listId,
    required TaskDto task,
  });

  Future<Stream<void>> crateApiWatchWorkspaceChanges({required String path});
}

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

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

  TaskConstMeta get kCrateApiAddWorkspaceConstMeta => const TaskConstMeta(
    debugName: "add_workspace",
    argNames: ["name", "path"],
  );

  @override
  Future<TaskListDto> crateApiCreateList({required String name}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(name, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 2,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_task_list_dto,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiCreateListConstMeta,
        argValues: [name],
        apiImpl: this,
      ),
    );
  }

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

  @override
  Future<TaskDto> crateApiCreateTask({
    required String listId,
    required String title,
    required String description,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(listId, serializer);
          sse_encode_String(title, serializer);
          sse_encode_String(description, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 3,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_task_dto,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiCreateTaskConstMeta,
        argValues: [listId, title, description],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiCreateTaskConstMeta => const TaskConstMeta(
    debugName: "create_task",
    argNames: ["listId", "title", "description"],
  );

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

  TaskConstMeta get kCrateApiDeleteListConstMeta =>
      const TaskConstMeta(debugName: "delete_list", argNames: ["listId"]);

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

  TaskConstMeta get kCrateApiDeleteTaskConstMeta => const TaskConstMeta(
    debugName: "delete_task",
    argNames: ["listId", "taskId"],
  );

  @override
  Future<AppConfigDto> crateApiGetConfig() {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 6,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_app_config_dto,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiGetConfigConstMeta,
        argValues: [],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiGetConfigConstMeta =>
      const TaskConstMeta(debugName: "get_config", argNames: []);

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

  TaskConstMeta get kCrateApiGetGroupByDueDateConstMeta => const TaskConstMeta(
    debugName: "get_group_by_due_date",
    argNames: ["listId"],
  );

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

  TaskConstMeta get kCrateApiGetListsConstMeta =>
      const TaskConstMeta(debugName: "get_lists", argNames: []);

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

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

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

  TaskConstMeta get kCrateApiInitWorkspaceConstMeta =>
      const TaskConstMeta(debugName: "init_workspace", argNames: ["path"]);

  @override
  Future<List<TaskDto>> crateApiListTasks({required String listId}) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(listId, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 11,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_list_task_dto,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiListTasksConstMeta,
        argValues: [listId],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiListTasksConstMeta =>
      const TaskConstMeta(debugName: "list_tasks", argNames: ["listId"]);

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

  TaskConstMeta get kCrateApiMoveTaskConstMeta => const TaskConstMeta(
    debugName: "move_task",
    argNames: ["fromListId", "toListId", "taskId"],
  );

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

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

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

  TaskConstMeta get kCrateApiRenameListConstMeta => const TaskConstMeta(
    debugName: "rename_list",
    argNames: ["listId", "newName"],
  );

  @override
  Future<void> crateApiReorderTask({
    required String listId,
    required String taskId,
    required int newPosition,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(listId, serializer);
          sse_encode_String(taskId, serializer);
          sse_encode_u_32(newPosition, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 15,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiReorderTaskConstMeta,
        argValues: [listId, taskId, newPosition],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiReorderTaskConstMeta => const TaskConstMeta(
    debugName: "reorder_task",
    argNames: ["listId", "taskId", "newPosition"],
  );

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

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

  @override
  Future<void> crateApiSetGroupByDueDate({
    required String listId,
    required bool enabled,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(listId, serializer);
          sse_encode_bool(enabled, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 17,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiSetGroupByDueDateConstMeta,
        argValues: [listId, enabled],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiSetGroupByDueDateConstMeta => const TaskConstMeta(
    debugName: "set_group_by_due_date",
    argNames: ["listId", "enabled"],
  );

  @override
  Future<TaskDto> crateApiToggleTask({
    required String listId,
    required String taskId,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(listId, serializer);
          sse_encode_String(taskId, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 18,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_task_dto,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiToggleTaskConstMeta,
        argValues: [listId, taskId],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiToggleTaskConstMeta => const TaskConstMeta(
    debugName: "toggle_task",
    argNames: ["listId", "taskId"],
  );

  @override
  Future<void> crateApiUpdateTask({
    required String listId,
    required TaskDto task,
  }) {
    return handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(listId, serializer);
          sse_encode_box_autoadd_task_dto(task, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 19,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: sse_decode_String,
        ),
        constMeta: kCrateApiUpdateTaskConstMeta,
        argValues: [listId, task],
        apiImpl: this,
      ),
    );
  }

  TaskConstMeta get kCrateApiUpdateTaskConstMeta => const TaskConstMeta(
    debugName: "update_task",
    argNames: ["listId", "task"],
  );

  @override
  Future<Stream<void>> crateApiWatchWorkspaceChanges({
    required String path,
  }) async {
    final sink = RustStreamSink<void>();
    await handler.executeNormal(
      NormalTask(
        callFfi: (port_) {
          final serializer = SseSerializer(generalizedFrbRustBinding);
          sse_encode_String(path, serializer);
          sse_encode_StreamSink_unit_Sse(sink, serializer);
          pdeCallFfi(
            generalizedFrbRustBinding,
            serializer,
            funcId: 20,
            port: port_,
          );
        },
        codec: SseCodec(
          decodeSuccessData: sse_decode_unit,
          decodeErrorData: null,
        ),
        constMeta: kCrateApiWatchWorkspaceChangesConstMeta,
        argValues: [path, sink],
        apiImpl: this,
      ),
    );
    return sink.stream;
  }

  TaskConstMeta get kCrateApiWatchWorkspaceChangesConstMeta =>
      const TaskConstMeta(
        debugName: "watch_workspace_changes",
        argNames: ["path", "sink"],
      );

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

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

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

  @protected
  AppConfigDto dco_decode_app_config_dto(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 AppConfigDto(
      workspaces: dco_decode_list_workspace_entry(arr[0]),
      currentWorkspace: dco_decode_opt_String(arr[1]),
    );
  }

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

  @protected
  TaskDto dco_decode_box_autoadd_task_dto(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_task_dto(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<TaskDto> dco_decode_list_task_dto(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return (raw as List<dynamic>).map(dco_decode_task_dto).toList();
  }

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

  @protected
  List<WorkspaceEntry> dco_decode_list_workspace_entry(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return (raw as List<dynamic>).map(dco_decode_workspace_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
  TaskDto dco_decode_task_dto(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 8)
      throw Exception('unexpected arr length: expect 8 but see ${arr.length}');
    return TaskDto(
      id: dco_decode_String(arr[0]),
      title: dco_decode_String(arr[1]),
      description: dco_decode_String(arr[2]),
      status: dco_decode_String(arr[3]),
      dueDate: dco_decode_opt_String(arr[4]),
      createdAt: dco_decode_String(arr[5]),
      updatedAt: dco_decode_String(arr[6]),
      parentId: dco_decode_opt_String(arr[7]),
    );
  }

  @protected
  TaskListDto dco_decode_task_list_dto(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 5)
      throw Exception('unexpected arr length: expect 5 but see ${arr.length}');
    return TaskListDto(
      id: dco_decode_String(arr[0]),
      title: dco_decode_String(arr[1]),
      createdAt: dco_decode_String(arr[2]),
      updatedAt: dco_decode_String(arr[3]),
      groupByDueDate: dco_decode_bool(arr[4]),
    );
  }

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

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

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

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

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

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

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

  @protected
  AppConfigDto sse_decode_app_config_dto(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_workspaces = sse_decode_list_workspace_entry(deserializer);
    var var_currentWorkspace = sse_decode_opt_String(deserializer);
    return AppConfigDto(
      workspaces: var_workspaces,
      currentWorkspace: var_currentWorkspace,
    );
  }

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

  @protected
  TaskDto sse_decode_box_autoadd_task_dto(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_task_dto(deserializer));
  }

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

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

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

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

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

    var len_ = sse_decode_i_32(deserializer);
    var ans_ = <WorkspaceEntry>[];
    for (var idx_ = 0; idx_ < len_; ++idx_) {
      ans_.add(sse_decode_workspace_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
  TaskDto sse_decode_task_dto(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_id = sse_decode_String(deserializer);
    var var_title = sse_decode_String(deserializer);
    var var_description = sse_decode_String(deserializer);
    var var_status = sse_decode_String(deserializer);
    var var_dueDate = sse_decode_opt_String(deserializer);
    var var_createdAt = sse_decode_String(deserializer);
    var var_updatedAt = sse_decode_String(deserializer);
    var var_parentId = sse_decode_opt_String(deserializer);
    return TaskDto(
      id: var_id,
      title: var_title,
      description: var_description,
      status: var_status,
      dueDate: var_dueDate,
      createdAt: var_createdAt,
      updatedAt: var_updatedAt,
      parentId: var_parentId,
    );
  }

  @protected
  TaskListDto sse_decode_task_list_dto(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_id = sse_decode_String(deserializer);
    var var_title = sse_decode_String(deserializer);
    var var_createdAt = sse_decode_String(deserializer);
    var var_updatedAt = sse_decode_String(deserializer);
    var var_groupByDueDate = sse_decode_bool(deserializer);
    return TaskListDto(
      id: var_id,
      title: var_title,
      createdAt: var_createdAt,
      updatedAt: var_updatedAt,
      groupByDueDate: var_groupByDueDate,
    );
  }

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

  @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
  WorkspaceEntry sse_decode_workspace_entry(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_name = sse_decode_String(deserializer);
    var var_path = sse_decode_String(deserializer);
    var var_webdavUrl = sse_decode_opt_String(deserializer);
    var var_lastSync = sse_decode_opt_String(deserializer);
    return WorkspaceEntry(
      name: var_name,
      path: var_path,
      webdavUrl: var_webdavUrl,
      lastSync: var_lastSync,
    );
  }

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

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

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

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

  @protected
  void sse_encode_app_config_dto(AppConfigDto self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_list_workspace_entry(self.workspaces, serializer);
    sse_encode_opt_String(self.currentWorkspace, serializer);
  }

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

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

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

  @protected
  void sse_encode_list_task_dto(List<TaskDto> 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_task_dto(item, serializer);
    }
  }

  @protected
  void sse_encode_list_task_list_dto(
    List<TaskListDto> 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_task_list_dto(item, serializer);
    }
  }

  @protected
  void sse_encode_list_workspace_entry(
    List<WorkspaceEntry> 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_workspace_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_task_dto(TaskDto self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(self.id, serializer);
    sse_encode_String(self.title, serializer);
    sse_encode_String(self.description, serializer);
    sse_encode_String(self.status, serializer);
    sse_encode_opt_String(self.dueDate, serializer);
    sse_encode_String(self.createdAt, serializer);
    sse_encode_String(self.updatedAt, serializer);
    sse_encode_opt_String(self.parentId, serializer);
  }

  @protected
  void sse_encode_task_list_dto(TaskListDto self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(self.id, serializer);
    sse_encode_String(self.title, serializer);
    sse_encode_String(self.createdAt, serializer);
    sse_encode_String(self.updatedAt, serializer);
    sse_encode_bool(self.groupByDueDate, serializer);
  }

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

  @protected
  void sse_encode_u_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_workspace_entry(
    WorkspaceEntry self,
    SseSerializer serializer,
  ) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(self.name, serializer);
    sse_encode_String(self.path, serializer);
    sse_encode_opt_String(self.webdavUrl, serializer);
    sse_encode_opt_String(self.lastSync, serializer);
  }

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