// This file is automatically generated, so please do not edit it.
// Generated by `flutter_rust_bridge`@ 2.3.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/image.dart';
import 'api/rhttp/client.dart';
import 'api/rhttp/error.dart';
import 'api/rhttp/http.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 'lib.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.3.0';

  @override
  int get rustContentHash => 107666026;

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

abstract class RustLibApi extends BaseApi {
  Uint8List crateApiImageProcessCropImage({required List<int> image});

  Future<ClientSettings> crateApiRhttpClientClientSettingsDefault();

  Future<void> crateApiRhttpHttpCancelRequest(
      {required CancellationToken token});

  Future<void> crateApiRhttpHttpCancelRunningRequests(
      {required RequestClient client});

  Stream<Uint8List> crateApiRhttpHttpMakeHttpRequestReceiveStream(
      {RequestClient? client,
      ClientSettings? settings,
      required HttpMethod method,
      required String url,
      List<(String, String)>? query,
      HttpHeaders? headers,
      Uint8List? body,
      required FutureOr<void> Function(HttpResponse) onResponse,
      required FutureOr<void> Function(RhttpError) onError,
      required FutureOr<void> Function(CancellationToken) onCancelToken,
      required bool cancelable});

  Future<RequestClient> crateApiRhttpHttpRegisterClient(
      {required ClientSettings settings});

  RequestClient crateApiRhttpHttpRegisterClientSync(
      {required ClientSettings settings});

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_CancellationToken;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_CancellationToken;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_CancellationTokenPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_RequestClient;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_RequestClient;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_RequestClientPtr;
}

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

  @override
  Uint8List crateApiImageProcessCropImage({required List<int> image}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_list_prim_u_8_loose(image, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1)!;
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_list_prim_u_8_strict,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiImageProcessCropImageConstMeta,
      argValues: [image],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiImageProcessCropImageConstMeta =>
      const TaskConstMeta(
        debugName: "process_crop_image",
        argNames: ["image"],
      );

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

  TaskConstMeta get kCrateApiRhttpClientClientSettingsDefaultConstMeta =>
      const TaskConstMeta(
        debugName: "client_settings_default",
        argNames: [],
      );

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

  TaskConstMeta get kCrateApiRhttpHttpCancelRequestConstMeta =>
      const TaskConstMeta(
        debugName: "cancel_request",
        argNames: ["token"],
      );

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

  TaskConstMeta get kCrateApiRhttpHttpCancelRunningRequestsConstMeta =>
      const TaskConstMeta(
        debugName: "cancel_running_requests",
        argNames: ["client"],
      );

  @override
  Stream<Uint8List> crateApiRhttpHttpMakeHttpRequestReceiveStream(
      {RequestClient? client,
      ClientSettings? settings,
      required HttpMethod method,
      required String url,
      List<(String, String)>? query,
      HttpHeaders? headers,
      Uint8List? body,
      required FutureOr<void> Function(HttpResponse) onResponse,
      required FutureOr<void> Function(RhttpError) onError,
      required FutureOr<void> Function(CancellationToken) onCancelToken,
      required bool cancelable}) {
    final streamSink = RustStreamSink<Uint8List>();
    unawaited(handler.executeNormal(NormalTask(
      callFfi: (port_) {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_opt_AutoExplicit_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
            client, serializer);
        sse_encode_opt_box_autoadd_client_settings(settings, serializer);
        sse_encode_http_method(method, serializer);
        sse_encode_String(url, serializer);
        sse_encode_opt_list_record_string_string(query, serializer);
        sse_encode_opt_box_autoadd_http_headers(headers, serializer);
        sse_encode_opt_list_prim_u_8_strict(body, serializer);
        sse_encode_StreamSink_list_prim_u_8_strict_Sse(streamSink, serializer);
        sse_encode_DartFn_Inputs_http_response_Output_unit_AnyhowException(
            onResponse, serializer);
        sse_encode_DartFn_Inputs_rhttp_error_Output_unit_AnyhowException(
            onError, serializer);
        sse_encode_DartFn_Inputs_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken_Output_unit_AnyhowException(
            onCancelToken, serializer);
        sse_encode_bool(cancelable, serializer);
        pdeCallFfi(generalizedFrbRustBinding, serializer,
            funcId: 5, port: port_);
      },
      codec: SseCodec(
        decodeSuccessData: sse_decode_unit,
        decodeErrorData: sse_decode_rhttp_error,
      ),
      constMeta: kCrateApiRhttpHttpMakeHttpRequestReceiveStreamConstMeta,
      argValues: [
        client,
        settings,
        method,
        url,
        query,
        headers,
        body,
        streamSink,
        onResponse,
        onError,
        onCancelToken,
        cancelable
      ],
      apiImpl: this,
    )));
    return streamSink.stream;
  }

  TaskConstMeta get kCrateApiRhttpHttpMakeHttpRequestReceiveStreamConstMeta =>
      const TaskConstMeta(
        debugName: "make_http_request_receive_stream",
        argNames: [
          "client",
          "settings",
          "method",
          "url",
          "query",
          "headers",
          "body",
          "streamSink",
          "onResponse",
          "onError",
          "onCancelToken",
          "cancelable"
        ],
      );

  @override
  Future<RequestClient> crateApiRhttpHttpRegisterClient(
      {required ClientSettings settings}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_box_autoadd_client_settings(settings, serializer);
        pdeCallFfi(generalizedFrbRustBinding, serializer,
            funcId: 6, port: port_);
      },
      codec: SseCodec(
        decodeSuccessData:
            sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient,
        decodeErrorData: sse_decode_rhttp_error,
      ),
      constMeta: kCrateApiRhttpHttpRegisterClientConstMeta,
      argValues: [settings],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiRhttpHttpRegisterClientConstMeta =>
      const TaskConstMeta(
        debugName: "register_client",
        argNames: ["settings"],
      );

  @override
  RequestClient crateApiRhttpHttpRegisterClientSync(
      {required ClientSettings settings}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        final serializer = SseSerializer(generalizedFrbRustBinding);
        sse_encode_box_autoadd_client_settings(settings, serializer);
        return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 7)!;
      },
      codec: SseCodec(
        decodeSuccessData:
            sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient,
        decodeErrorData: sse_decode_rhttp_error,
      ),
      constMeta: kCrateApiRhttpHttpRegisterClientSyncConstMeta,
      argValues: [settings],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiRhttpHttpRegisterClientSyncConstMeta =>
      const TaskConstMeta(
        debugName: "register_client_sync",
        argNames: ["settings"],
      );

  Future<void> Function(int, dynamic)
      encode_DartFn_Inputs_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken_Output_unit_AnyhowException(
          FutureOr<void> Function(CancellationToken) raw) {
    return (callId, rawArg0) async {
      final arg0 =
          dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
              rawArg0);

      Box<void>? rawOutput;
      Box<AnyhowException>? rawError;
      try {
        rawOutput = Box(await raw(arg0));
      } catch (e, s) {
        rawError = Box(AnyhowException("$e\n\n$s"));
      }

      final serializer = SseSerializer(generalizedFrbRustBinding);
      assert((rawOutput != null) ^ (rawError != null));
      if (rawOutput != null) {
        serializer.buffer.putUint8(0);
        sse_encode_unit(rawOutput.value, serializer);
      } else {
        serializer.buffer.putUint8(1);
        sse_encode_AnyhowException(rawError!.value, serializer);
      }
      final output = serializer.intoRaw();

      generalizedFrbRustBinding.dartFnDeliverOutput(
          callId: callId,
          ptr: output.ptr,
          rustVecLen: output.rustVecLen,
          dataLen: output.dataLen);
    };
  }

  Future<void> Function(int, dynamic)
      encode_DartFn_Inputs_http_response_Output_unit_AnyhowException(
          FutureOr<void> Function(HttpResponse) raw) {
    return (callId, rawArg0) async {
      final arg0 = dco_decode_http_response(rawArg0);

      Box<void>? rawOutput;
      Box<AnyhowException>? rawError;
      try {
        rawOutput = Box(await raw(arg0));
      } catch (e, s) {
        rawError = Box(AnyhowException("$e\n\n$s"));
      }

      final serializer = SseSerializer(generalizedFrbRustBinding);
      assert((rawOutput != null) ^ (rawError != null));
      if (rawOutput != null) {
        serializer.buffer.putUint8(0);
        sse_encode_unit(rawOutput.value, serializer);
      } else {
        serializer.buffer.putUint8(1);
        sse_encode_AnyhowException(rawError!.value, serializer);
      }
      final output = serializer.intoRaw();

      generalizedFrbRustBinding.dartFnDeliverOutput(
          callId: callId,
          ptr: output.ptr,
          rustVecLen: output.rustVecLen,
          dataLen: output.dataLen);
    };
  }

  Future<void> Function(int, dynamic)
      encode_DartFn_Inputs_rhttp_error_Output_unit_AnyhowException(
          FutureOr<void> Function(RhttpError) raw) {
    return (callId, rawArg0) async {
      final arg0 = dco_decode_rhttp_error(rawArg0);

      Box<void>? rawOutput;
      Box<AnyhowException>? rawError;
      try {
        rawOutput = Box(await raw(arg0));
      } catch (e, s) {
        rawError = Box(AnyhowException("$e\n\n$s"));
      }

      final serializer = SseSerializer(generalizedFrbRustBinding);
      assert((rawOutput != null) ^ (rawError != null));
      if (rawOutput != null) {
        serializer.buffer.putUint8(0);
        sse_encode_unit(rawOutput.value, serializer);
      } else {
        serializer.buffer.putUint8(1);
        sse_encode_AnyhowException(rawError!.value, serializer);
      }
      final output = serializer.intoRaw();

      generalizedFrbRustBinding.dartFnDeliverOutput(
          callId: callId,
          ptr: output.ptr,
          rustVecLen: output.rustVecLen,
          dataLen: output.dataLen);
    };
  }

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_CancellationToken => wire
          .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_CancellationToken => wire
          .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_RequestClient => wire
          .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_RequestClient => wire
          .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient;

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

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

  @protected
  CancellationToken
      dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return CancellationTokenImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  RequestClient
      dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return RequestClientImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  CancellationToken
      dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return CancellationTokenImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  RequestClient
      dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return RequestClientImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  Duration dco_decode_Chrono_Duration(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dcoDecodeDuration(dco_decode_i_64(raw).toInt());
  }

  @protected
  FutureOr<void> Function(CancellationToken)
      dco_decode_DartFn_Inputs_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken_Output_unit_AnyhowException(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    throw UnimplementedError('');
  }

  @protected
  FutureOr<void> Function(HttpResponse)
      dco_decode_DartFn_Inputs_http_response_Output_unit_AnyhowException(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    throw UnimplementedError('');
  }

  @protected
  FutureOr<void> Function(RhttpError)
      dco_decode_DartFn_Inputs_rhttp_error_Output_unit_AnyhowException(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    throw UnimplementedError('');
  }

  @protected
  Object dco_decode_DartOpaque(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return decodeDartOpaque(raw, generalizedFrbRustBinding);
  }

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

  @protected
  CancellationToken
      dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return CancellationTokenImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  RequestClient
      dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return RequestClientImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

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

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

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

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

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

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

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

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

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

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

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

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

  @protected
  ClientCertificate dco_decode_client_certificate(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 ClientCertificate(
      certificate: dco_decode_list_prim_u_8_strict(arr[0]),
      privateKey: dco_decode_list_prim_u_8_strict(arr[1]),
    );
  }

  @protected
  ClientSettings dco_decode_client_settings(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 ClientSettings(
      timeout: dco_decode_opt_box_autoadd_Chrono_Duration(arr[0]),
      connectTimeout: dco_decode_opt_box_autoadd_Chrono_Duration(arr[1]),
      throwOnStatusCode: dco_decode_bool(arr[2]),
      proxySettings: dco_decode_opt_box_autoadd_proxy_settings(arr[3]),
      redirectSettings: dco_decode_opt_box_autoadd_redirect_settings(arr[4]),
      tlsSettings: dco_decode_opt_box_autoadd_tls_settings(arr[5]),
    );
  }

  @protected
  HttpHeaders dco_decode_http_headers(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    switch (raw[0]) {
      case 0:
        return HttpHeaders_Map(
          dco_decode_Map_String_String(raw[1]),
        );
      case 1:
        return HttpHeaders_List(
          dco_decode_list_record_string_string(raw[1]),
        );
      default:
        throw Exception("unreachable");
    }
  }

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

  @protected
  HttpResponse dco_decode_http_response(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 HttpResponse(
      headers: dco_decode_list_record_string_string(arr[0]),
      version: dco_decode_http_version(arr[1]),
      statusCode: dco_decode_u_16(arr[2]),
      body: dco_decode_http_response_body(arr[3]),
    );
  }

  @protected
  HttpResponseBody dco_decode_http_response_body(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    switch (raw[0]) {
      case 0:
        return HttpResponseBody_Text(
          dco_decode_String(raw[1]),
        );
      case 1:
        return HttpResponseBody_Bytes(
          dco_decode_list_prim_u_8_strict(raw[1]),
        );
      case 2:
        return HttpResponseBody_Stream();
      default:
        throw Exception("unreachable");
    }
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  @protected
  List<(String, String)>? dco_decode_opt_list_record_string_string(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw == null ? null : dco_decode_list_record_string_string(raw);
  }

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

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

  @protected
  RedirectSettings dco_decode_redirect_settings(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    switch (raw[0]) {
      case 0:
        return RedirectSettings_NoRedirect();
      case 1:
        return RedirectSettings_LimitedRedirects(
          dco_decode_i_32(raw[1]),
        );
      default:
        throw Exception("unreachable");
    }
  }

  @protected
  RhttpError dco_decode_rhttp_error(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    switch (raw[0]) {
      case 0:
        return RhttpError_RhttpCancelError();
      case 1:
        return RhttpError_RhttpTimeoutError();
      case 2:
        return RhttpError_RhttpRedirectError();
      case 3:
        return RhttpError_RhttpStatusCodeError(
          dco_decode_u_16(raw[1]),
          dco_decode_list_record_string_string(raw[2]),
          dco_decode_box_autoadd_http_response_body(raw[3]),
        );
      case 4:
        return RhttpError_RhttpInvalidCertificateError(
          dco_decode_String(raw[1]),
        );
      case 5:
        return RhttpError_RhttpConnectionError(
          dco_decode_String(raw[1]),
        );
      case 6:
        return RhttpError_RhttpUnknownError(
          dco_decode_String(raw[1]),
        );
      default:
        throw Exception("unreachable");
    }
  }

  @protected
  TlsSettings dco_decode_tls_settings(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 TlsSettings(
      trustRootCertificates: dco_decode_bool(arr[0]),
      trustedRootCertificates: dco_decode_list_list_prim_u_8_strict(arr[1]),
      verifyCertificates: dco_decode_bool(arr[2]),
      clientCertificate: dco_decode_opt_box_autoadd_client_certificate(arr[3]),
      minTlsVersion: dco_decode_opt_box_autoadd_tls_version(arr[4]),
      maxTlsVersion: dco_decode_opt_box_autoadd_tls_version(arr[5]),
    );
  }

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

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

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

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

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

  @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
  RequestClient
      sse_decode_AutoExplicit_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner =
        sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
            deserializer);
    return inner;
  }

  @protected
  CancellationToken
      sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return CancellationTokenImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  RequestClient
      sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return RequestClientImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  CancellationToken
      sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return CancellationTokenImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  RequestClient
      sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return RequestClientImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  Duration sse_decode_Chrono_Duration(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_i_64(deserializer);
    return Duration(microseconds: inner.toInt());
  }

  @protected
  Object sse_decode_DartOpaque(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_usize(deserializer);
    return decodeDartOpaque(inner, generalizedFrbRustBinding);
  }

  @protected
  Map<String, String> sse_decode_Map_String_String(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_list_record_string_string(deserializer);
    return Map.fromEntries(inner.map((e) => MapEntry(e.$1, e.$2)));
  }

  @protected
  CancellationToken
      sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return CancellationTokenImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  RequestClient
      sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return RequestClientImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

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

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

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

  @protected
  Duration sse_decode_box_autoadd_Chrono_Duration(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_Chrono_Duration(deserializer));
  }

  @protected
  ClientCertificate sse_decode_box_autoadd_client_certificate(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_client_certificate(deserializer));
  }

  @protected
  ClientSettings sse_decode_box_autoadd_client_settings(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_client_settings(deserializer));
  }

  @protected
  HttpHeaders sse_decode_box_autoadd_http_headers(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_http_headers(deserializer));
  }

  @protected
  HttpResponseBody sse_decode_box_autoadd_http_response_body(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_http_response_body(deserializer));
  }

  @protected
  ProxySettings sse_decode_box_autoadd_proxy_settings(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_proxy_settings(deserializer));
  }

  @protected
  RedirectSettings sse_decode_box_autoadd_redirect_settings(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_redirect_settings(deserializer));
  }

  @protected
  TlsSettings sse_decode_box_autoadd_tls_settings(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_tls_settings(deserializer));
  }

  @protected
  TlsVersion sse_decode_box_autoadd_tls_version(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_tls_version(deserializer));
  }

  @protected
  ClientCertificate sse_decode_client_certificate(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_certificate = sse_decode_list_prim_u_8_strict(deserializer);
    var var_privateKey = sse_decode_list_prim_u_8_strict(deserializer);
    return ClientCertificate(
        certificate: var_certificate, privateKey: var_privateKey);
  }

  @protected
  ClientSettings sse_decode_client_settings(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_timeout = sse_decode_opt_box_autoadd_Chrono_Duration(deserializer);
    var var_connectTimeout =
        sse_decode_opt_box_autoadd_Chrono_Duration(deserializer);
    var var_throwOnStatusCode = sse_decode_bool(deserializer);
    var var_proxySettings =
        sse_decode_opt_box_autoadd_proxy_settings(deserializer);
    var var_redirectSettings =
        sse_decode_opt_box_autoadd_redirect_settings(deserializer);
    var var_tlsSettings = sse_decode_opt_box_autoadd_tls_settings(deserializer);
    return ClientSettings(
        timeout: var_timeout,
        connectTimeout: var_connectTimeout,
        throwOnStatusCode: var_throwOnStatusCode,
        proxySettings: var_proxySettings,
        redirectSettings: var_redirectSettings,
        tlsSettings: var_tlsSettings);
  }

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

    var tag_ = sse_decode_i_32(deserializer);
    switch (tag_) {
      case 0:
        var var_field0 = sse_decode_Map_String_String(deserializer);
        return HttpHeaders_Map(var_field0);
      case 1:
        var var_field0 = sse_decode_list_record_string_string(deserializer);
        return HttpHeaders_List(var_field0);
      default:
        throw UnimplementedError('');
    }
  }

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

  @protected
  HttpResponse sse_decode_http_response(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_headers = sse_decode_list_record_string_string(deserializer);
    var var_version = sse_decode_http_version(deserializer);
    var var_statusCode = sse_decode_u_16(deserializer);
    var var_body = sse_decode_http_response_body(deserializer);
    return HttpResponse(
        headers: var_headers,
        version: var_version,
        statusCode: var_statusCode,
        body: var_body);
  }

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

    var tag_ = sse_decode_i_32(deserializer);
    switch (tag_) {
      case 0:
        var var_field0 = sse_decode_String(deserializer);
        return HttpResponseBody_Text(var_field0);
      case 1:
        var var_field0 = sse_decode_list_prim_u_8_strict(deserializer);
        return HttpResponseBody_Bytes(var_field0);
      case 2:
        return HttpResponseBody_Stream();
      default:
        throw UnimplementedError('');
    }
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    var tag_ = sse_decode_i_32(deserializer);
    switch (tag_) {
      case 0:
        return RedirectSettings_NoRedirect();
      case 1:
        var var_field0 = sse_decode_i_32(deserializer);
        return RedirectSettings_LimitedRedirects(var_field0);
      default:
        throw UnimplementedError('');
    }
  }

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

    var tag_ = sse_decode_i_32(deserializer);
    switch (tag_) {
      case 0:
        return RhttpError_RhttpCancelError();
      case 1:
        return RhttpError_RhttpTimeoutError();
      case 2:
        return RhttpError_RhttpRedirectError();
      case 3:
        var var_field0 = sse_decode_u_16(deserializer);
        var var_field1 = sse_decode_list_record_string_string(deserializer);
        var var_field2 =
            sse_decode_box_autoadd_http_response_body(deserializer);
        return RhttpError_RhttpStatusCodeError(
            var_field0, var_field1, var_field2);
      case 4:
        var var_field0 = sse_decode_String(deserializer);
        return RhttpError_RhttpInvalidCertificateError(var_field0);
      case 5:
        var var_field0 = sse_decode_String(deserializer);
        return RhttpError_RhttpConnectionError(var_field0);
      case 6:
        var var_field0 = sse_decode_String(deserializer);
        return RhttpError_RhttpUnknownError(var_field0);
      default:
        throw UnimplementedError('');
    }
  }

  @protected
  TlsSettings sse_decode_tls_settings(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_trustRootCertificates = sse_decode_bool(deserializer);
    var var_trustedRootCertificates =
        sse_decode_list_list_prim_u_8_strict(deserializer);
    var var_verifyCertificates = sse_decode_bool(deserializer);
    var var_clientCertificate =
        sse_decode_opt_box_autoadd_client_certificate(deserializer);
    var var_minTlsVersion =
        sse_decode_opt_box_autoadd_tls_version(deserializer);
    var var_maxTlsVersion =
        sse_decode_opt_box_autoadd_tls_version(deserializer);
    return TlsSettings(
        trustRootCertificates: var_trustRootCertificates,
        trustedRootCertificates: var_trustedRootCertificates,
        verifyCertificates: var_verifyCertificates,
        clientCertificate: var_clientCertificate,
        minTlsVersion: var_minTlsVersion,
        maxTlsVersion: var_maxTlsVersion);
  }

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

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

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

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

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

  @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_AutoExplicit_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
          RequestClient self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
        self, serializer);
  }

  @protected
  void
      sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
          CancellationToken self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as CancellationTokenImpl).frbInternalSseEncode(move: true),
        serializer);
  }

  @protected
  void
      sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
          RequestClient self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as RequestClientImpl).frbInternalSseEncode(move: true),
        serializer);
  }

  @protected
  void
      sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
          CancellationToken self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as CancellationTokenImpl).frbInternalSseEncode(move: false),
        serializer);
  }

  @protected
  void
      sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
          RequestClient self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as RequestClientImpl).frbInternalSseEncode(move: false),
        serializer);
  }

  @protected
  void sse_encode_Chrono_Duration(Duration self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_64(PlatformInt64Util.from(self.inMicroseconds), serializer);
  }

  @protected
  void
      sse_encode_DartFn_Inputs_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken_Output_unit_AnyhowException(
          FutureOr<void> Function(CancellationToken) self,
          SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_DartOpaque(
        encode_DartFn_Inputs_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken_Output_unit_AnyhowException(
            self),
        serializer);
  }

  @protected
  void sse_encode_DartFn_Inputs_http_response_Output_unit_AnyhowException(
      FutureOr<void> Function(HttpResponse) self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_DartOpaque(
        encode_DartFn_Inputs_http_response_Output_unit_AnyhowException(self),
        serializer);
  }

  @protected
  void sse_encode_DartFn_Inputs_rhttp_error_Output_unit_AnyhowException(
      FutureOr<void> Function(RhttpError) self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_DartOpaque(
        encode_DartFn_Inputs_rhttp_error_Output_unit_AnyhowException(self),
        serializer);
  }

  @protected
  void sse_encode_DartOpaque(Object self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        BigInt.from(PlatformPointerUtil.ptrToInt(encodeDartOpaque(
                self, portManager.dartHandlerPort, generalizedFrbRustBinding)))
            .toUnsigned(64),
        serializer);
  }

  @protected
  void sse_encode_Map_String_String(
      Map<String, String> self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_list_record_string_string(
        self.entries.map((e) => (e.key, e.value)).toList(), serializer);
  }

  @protected
  void
      sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCancellationToken(
          CancellationToken self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as CancellationTokenImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void
      sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRequestClient(
          RequestClient self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as RequestClientImpl).frbInternalSseEncode(move: null),
        serializer);
  }

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

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

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

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

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

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

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

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

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

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

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

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

  @protected
  void sse_encode_client_certificate(
      ClientCertificate self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_list_prim_u_8_strict(self.certificate, serializer);
    sse_encode_list_prim_u_8_strict(self.privateKey, serializer);
  }

  @protected
  void sse_encode_client_settings(
      ClientSettings self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_opt_box_autoadd_Chrono_Duration(self.timeout, serializer);
    sse_encode_opt_box_autoadd_Chrono_Duration(self.connectTimeout, serializer);
    sse_encode_bool(self.throwOnStatusCode, serializer);
    sse_encode_opt_box_autoadd_proxy_settings(self.proxySettings, serializer);
    sse_encode_opt_box_autoadd_redirect_settings(
        self.redirectSettings, serializer);
    sse_encode_opt_box_autoadd_tls_settings(self.tlsSettings, serializer);
  }

  @protected
  void sse_encode_http_headers(HttpHeaders self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    switch (self) {
      case HttpHeaders_Map(field0: final field0):
        sse_encode_i_32(0, serializer);
        sse_encode_Map_String_String(field0, serializer);
      case HttpHeaders_List(field0: final field0):
        sse_encode_i_32(1, serializer);
        sse_encode_list_record_string_string(field0, serializer);
      default:
        throw UnimplementedError('');
    }
  }

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

  @protected
  void sse_encode_http_response(HttpResponse self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_list_record_string_string(self.headers, serializer);
    sse_encode_http_version(self.version, serializer);
    sse_encode_u_16(self.statusCode, serializer);
    sse_encode_http_response_body(self.body, serializer);
  }

  @protected
  void sse_encode_http_response_body(
      HttpResponseBody self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    switch (self) {
      case HttpResponseBody_Text(field0: final field0):
        sse_encode_i_32(0, serializer);
        sse_encode_String(field0, serializer);
      case HttpResponseBody_Bytes(field0: final field0):
        sse_encode_i_32(1, serializer);
        sse_encode_list_prim_u_8_strict(field0, serializer);
      case HttpResponseBody_Stream():
        sse_encode_i_32(2, serializer);
      default:
        throw UnimplementedError('');
    }
  }

  @protected
  void sse_encode_http_version(HttpVersion self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.index, 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);
  }

  @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_list_prim_u_8_strict(
      List<Uint8List> 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_list_prim_u_8_strict(item, serializer);
    }
  }

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

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

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

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

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

  @protected
  void sse_encode_opt_box_autoadd_Chrono_Duration(
      Duration? 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_Chrono_Duration(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_client_certificate(
      ClientCertificate? 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_client_certificate(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_client_settings(
      ClientSettings? 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_client_settings(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_http_headers(
      HttpHeaders? 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_http_headers(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_proxy_settings(
      ProxySettings? 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_proxy_settings(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_redirect_settings(
      RedirectSettings? 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_redirect_settings(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_tls_settings(
      TlsSettings? 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_tls_settings(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_tls_version(
      TlsVersion? 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_tls_version(self, serializer);
    }
  }

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

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

  @protected
  void sse_encode_opt_list_record_string_string(
      List<(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_list_record_string_string(self, serializer);
    }
  }

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

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

  @protected
  void sse_encode_redirect_settings(
      RedirectSettings self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    switch (self) {
      case RedirectSettings_NoRedirect():
        sse_encode_i_32(0, serializer);
      case RedirectSettings_LimitedRedirects(field0: final field0):
        sse_encode_i_32(1, serializer);
        sse_encode_i_32(field0, serializer);
      default:
        throw UnimplementedError('');
    }
  }

  @protected
  void sse_encode_rhttp_error(RhttpError self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    switch (self) {
      case RhttpError_RhttpCancelError():
        sse_encode_i_32(0, serializer);
      case RhttpError_RhttpTimeoutError():
        sse_encode_i_32(1, serializer);
      case RhttpError_RhttpRedirectError():
        sse_encode_i_32(2, serializer);
      case RhttpError_RhttpStatusCodeError(
          field0: final field0,
          field1: final field1,
          field2: final field2
        ):
        sse_encode_i_32(3, serializer);
        sse_encode_u_16(field0, serializer);
        sse_encode_list_record_string_string(field1, serializer);
        sse_encode_box_autoadd_http_response_body(field2, serializer);
      case RhttpError_RhttpInvalidCertificateError(field0: final field0):
        sse_encode_i_32(4, serializer);
        sse_encode_String(field0, serializer);
      case RhttpError_RhttpConnectionError(field0: final field0):
        sse_encode_i_32(5, serializer);
        sse_encode_String(field0, serializer);
      case RhttpError_RhttpUnknownError(field0: final field0):
        sse_encode_i_32(6, serializer);
        sse_encode_String(field0, serializer);
      default:
        throw UnimplementedError('');
    }
  }

  @protected
  void sse_encode_tls_settings(TlsSettings self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_bool(self.trustRootCertificates, serializer);
    sse_encode_list_list_prim_u_8_strict(
        self.trustedRootCertificates, serializer);
    sse_encode_bool(self.verifyCertificates, serializer);
    sse_encode_opt_box_autoadd_client_certificate(
        self.clientCertificate, serializer);
    sse_encode_opt_box_autoadd_tls_version(self.minTlsVersion, serializer);
    sse_encode_opt_box_autoadd_tls_version(self.maxTlsVersion, serializer);
  }

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

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

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

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

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

@sealed
class CancellationTokenImpl extends RustOpaque implements CancellationToken {
  // Not to be used by end users
  CancellationTokenImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  CancellationTokenImpl.frbInternalSseDecode(
      BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        RustLib.instance.api.rust_arc_increment_strong_count_CancellationToken,
    rustArcDecrementStrongCount:
        RustLib.instance.api.rust_arc_decrement_strong_count_CancellationToken,
    rustArcDecrementStrongCountPtr: RustLib
        .instance.api.rust_arc_decrement_strong_count_CancellationTokenPtr,
  );
}

@sealed
class RequestClientImpl extends RustOpaque implements RequestClient {
  // Not to be used by end users
  RequestClientImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  RequestClientImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        RustLib.instance.api.rust_arc_increment_strong_count_RequestClient,
    rustArcDecrementStrongCount:
        RustLib.instance.api.rust_arc_decrement_strong_count_RequestClient,
    rustArcDecrementStrongCountPtr:
        RustLib.instance.api.rust_arc_decrement_strong_count_RequestClientPtr,
  );
}