From 2023b1581c6ad9e3109e7126324271b2c3d8fabf Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Wed, 15 May 2024 20:22:48 +0800 Subject: [PATCH 01/94] chore: dart_minimal demo --- frb_example/dart_minimal/rust/src/api/minimal.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/frb_example/dart_minimal/rust/src/api/minimal.rs b/frb_example/dart_minimal/rust/src/api/minimal.rs index 517e29973f..b2cb5dd225 100644 --- a/frb_example/dart_minimal/rust/src/api/minimal.rs +++ b/frb_example/dart_minimal/rust/src/api/minimal.rs @@ -1,4 +1,4 @@ -use flutter_rust_bridge::frb; +use flutter_rust_bridge::{frb, DartFnFuture}; #[frb(init)] pub fn init_app() { @@ -8,3 +8,7 @@ pub fn init_app() { pub fn minimal_adder(a: i32, b: i32) -> i32 { a + b } + +pub async fn rust_function(dart_callback: impl Fn(String) -> DartFnFuture>) { + unimplemented!() +} From 083c881150a7b9397f0317101d00fb88645a65c1 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Wed, 15 May 2024 20:23:04 +0800 Subject: [PATCH 02/94] chore: codegen --- .../lib/src/rust/api/minimal.dart | 24 ++ .../lib/src/rust/frb_generated.dart | 240 +++++++++++++++++- .../lib/src/rust/frb_generated.io.dart | 123 +++++++++ .../lib/src/rust/frb_generated.web.dart | 111 ++++++++ .../dart_minimal/rust/src/frb_generated.io.rs | 15 ++ .../dart_minimal/rust/src/frb_generated.rs | 187 +++++++++++++- .../rust/src/frb_generated.web.rs | 15 ++ 7 files changed, 713 insertions(+), 2 deletions(-) diff --git a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart index a87414ee9d..0f2eb84ebe 100644 --- a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart +++ b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart @@ -8,3 +8,27 @@ import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; Future minimalAdder({required int a, required int b, dynamic hint}) => RustLib.instance.api.minimalAdder(a: a, b: b, hint: hint); + +Future rustFunction( + {required FutureOr Function(String) dartCallback, + dynamic hint}) => + RustLib.instance.api.rustFunction(dartCallback: dartCallback, hint: hint); + +// Rust type: RustOpaqueMoi>> +@sealed +class ResultStringU32 extends RustOpaque { + ResultStringU32.dcoDecode(List wire) + : super.dcoDecode(wire, _kStaticData); + + ResultStringU32.sseDecode(int ptr, int externalSizeOnNative) + : super.sseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: + RustLib.instance.api.rust_arc_increment_strong_count_ResultStringU32, + rustArcDecrementStrongCount: + RustLib.instance.api.rust_arc_decrement_strong_count_ResultStringU32, + rustArcDecrementStrongCountPtr: + RustLib.instance.api.rust_arc_decrement_strong_count_ResultStringU32Ptr, + ); +} diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index 630b36c6b9..c0ba167a6d 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -56,7 +56,7 @@ class RustLib extends BaseEntrypoint { String get codegenVersion => '2.0.0-dev.33'; @override - int get rustContentHash => -2119384465; + int get rustContentHash => -957330701; static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig( @@ -70,6 +70,19 @@ abstract class RustLibApi extends BaseApi { Future initApp({dynamic hint}); Future minimalAdder({required int a, required int b, dynamic hint}); + + Future rustFunction( + {required FutureOr Function(String) dartCallback, + dynamic hint}); + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_ResultStringU32; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_ResultStringU32; + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ResultStringU32Ptr; } class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @@ -130,46 +143,271 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["a", "b"], ); + @override + Future rustFunction( + {required FutureOr Function(String) dartCallback, + dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dartCallback, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 3, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: kRustFunctionConstMeta, + argValues: [dartCallback], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta get kRustFunctionConstMeta => const TaskConstMeta( + debugName: "rust_function", + argNames: ["dartCallback"], + ); + + Future Function(int, dynamic) + encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + FutureOr Function(String) raw) { + return (callId, rawArg0) async { + final arg0 = dco_decode_String(rawArg0); + + final rawOutput = await raw(arg0); + + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + rawOutput, 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_ResultStringU32 => wire + .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_ResultStringU32 => wire + .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32; + + @protected + ResultStringU32 + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return ResultStringU32.dcoDecode(raw as List); + } + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + 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 + ResultStringU32 + dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return ResultStringU32.dcoDecode(raw as List); + } + + @protected + String dco_decode_String(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as String; + } + @protected int dco_decode_i_32(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs return raw as 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 + 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 + int dco_decode_usize(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dcoDecodeI64OrU64(raw); + } + + @protected + ResultStringU32 + sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return ResultStringU32.sseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @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 + ResultStringU32 + sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return ResultStringU32.sseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @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 int sse_decode_i_32(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs return deserializer.buffer.getInt32(); } + @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 + int sse_decode_u_8(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return deserializer.buffer.getUint8(); + } + @protected void sse_decode_unit(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs } + @protected + int sse_decode_usize(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return deserializer.buffer.getUint64(); + } + @protected bool sse_decode_bool(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs return deserializer.buffer.getUint8() != 0; } + @protected + void + sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ResultStringU32 self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize(self.sseEncode(move: true), serializer); + } + + @protected + void + sse_encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + FutureOr Function(String) self, + SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_DartOpaque( + encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + self), + serializer); + } + + @protected + void sse_encode_DartOpaque(Object self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + PlatformPointerUtil.ptrToInt(encodeDartOpaque( + self, portManager.dartHandlerPort, generalizedFrbRustBinding)), + serializer); + } + + @protected + void + sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ResultStringU32 self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize(self.sseEncode(move: null), 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_i_32(int self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs serializer.buffer.putInt32(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_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(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + serializer.buffer.putUint64(self); + } + @protected void sse_encode_bool(bool self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart index 2848e6be9c..a9b014fa4e 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart @@ -18,27 +18,118 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { required super.portManager, }); + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ResultStringU32Ptr => wire + ._rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32Ptr; + + @protected + ResultStringU32 + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic raw); + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic raw); + + @protected + Object dco_decode_DartOpaque(dynamic raw); + + @protected + ResultStringU32 + dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic raw); + + @protected + String dco_decode_String(dynamic raw); + @protected int dco_decode_i_32(dynamic raw); + @protected + Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); + + @protected + int dco_decode_u_8(dynamic raw); + @protected void dco_decode_unit(dynamic raw); + @protected + int dco_decode_usize(dynamic raw); + + @protected + ResultStringU32 + sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + SseDeserializer deserializer); + + @protected + Object sse_decode_DartOpaque(SseDeserializer deserializer); + + @protected + ResultStringU32 + sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + SseDeserializer deserializer); + + @protected + String sse_decode_String(SseDeserializer deserializer); + @protected int sse_decode_i_32(SseDeserializer deserializer); + @protected + Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); + + @protected + int sse_decode_u_8(SseDeserializer deserializer); + @protected void sse_decode_unit(SseDeserializer deserializer); + @protected + int sse_decode_usize(SseDeserializer deserializer); + @protected bool sse_decode_bool(SseDeserializer deserializer); + @protected + void + sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ResultStringU32 self, SseSerializer serializer); + + @protected + void + sse_encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + FutureOr Function(String) self, + SseSerializer serializer); + + @protected + void sse_encode_DartOpaque(Object self, SseSerializer serializer); + + @protected + void + sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ResultStringU32 self, SseSerializer serializer); + + @protected + void sse_encode_String(String self, SseSerializer serializer); + @protected void sse_encode_i_32(int self, SseSerializer serializer); + @protected + void sse_encode_list_prim_u_8_strict( + Uint8List self, SseSerializer serializer); + + @protected + void sse_encode_u_8(int self, SseSerializer serializer); + @protected void sse_encode_unit(void self, SseSerializer serializer); + @protected + void sse_encode_usize(int self, SseSerializer serializer); + @protected void sse_encode_bool(bool self, SseSerializer serializer); } @@ -56,4 +147,36 @@ class RustLibWire implements BaseWire { /// The symbols are looked up in [dynamicLibrary]. RustLibWire(ffi.DynamicLibrary dynamicLibrary) : _lookup = dynamicLibrary.lookup; + + void + rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32Ptr = + _lookup)>>( + 'frbgen_frb_example_dart_minimal_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32'); + late final _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32 = + _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32Ptr + .asFunction)>(); + + void + rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32Ptr = + _lookup)>>( + 'frbgen_frb_example_dart_minimal_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32'); + late final _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32 = + _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32Ptr + .asFunction)>(); } diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart index 013ee88194..b6faa14d50 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart @@ -17,27 +17,118 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { required super.portManager, }); + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ResultStringU32Ptr => wire + .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32; + + @protected + ResultStringU32 + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic raw); + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic raw); + + @protected + Object dco_decode_DartOpaque(dynamic raw); + + @protected + ResultStringU32 + dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic raw); + + @protected + String dco_decode_String(dynamic raw); + @protected int dco_decode_i_32(dynamic raw); + @protected + Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); + + @protected + int dco_decode_u_8(dynamic raw); + @protected void dco_decode_unit(dynamic raw); + @protected + int dco_decode_usize(dynamic raw); + + @protected + ResultStringU32 + sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + SseDeserializer deserializer); + + @protected + Object sse_decode_DartOpaque(SseDeserializer deserializer); + + @protected + ResultStringU32 + sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + SseDeserializer deserializer); + + @protected + String sse_decode_String(SseDeserializer deserializer); + @protected int sse_decode_i_32(SseDeserializer deserializer); + @protected + Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); + + @protected + int sse_decode_u_8(SseDeserializer deserializer); + @protected void sse_decode_unit(SseDeserializer deserializer); + @protected + int sse_decode_usize(SseDeserializer deserializer); + @protected bool sse_decode_bool(SseDeserializer deserializer); + @protected + void + sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ResultStringU32 self, SseSerializer serializer); + + @protected + void + sse_encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + FutureOr Function(String) self, + SseSerializer serializer); + + @protected + void sse_encode_DartOpaque(Object self, SseSerializer serializer); + + @protected + void + sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ResultStringU32 self, SseSerializer serializer); + + @protected + void sse_encode_String(String self, SseSerializer serializer); + @protected void sse_encode_i_32(int self, SseSerializer serializer); + @protected + void sse_encode_list_prim_u_8_strict( + Uint8List self, SseSerializer serializer); + + @protected + void sse_encode_u_8(int self, SseSerializer serializer); + @protected void sse_encode_unit(void self, SseSerializer serializer); + @protected + void sse_encode_usize(int self, SseSerializer serializer); + @protected void sse_encode_bool(bool self, SseSerializer serializer); } @@ -46,6 +137,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { class RustLibWire implements BaseWire { RustLibWire.fromExternalLibrary(ExternalLibrary lib); + + void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic ptr) => + wasmModule + .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ptr); + + void rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic ptr) => + wasmModule + .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ptr); } @JS('wasm_bindgen') @@ -59,4 +162,12 @@ class RustLibWasmModule implements WasmModule { @override external RustLibWasmModule bind(dynamic thisArg, String moduleName); + + external void + rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic ptr); + + external void + rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dynamic ptr); } diff --git a/frb_example/dart_minimal/rust/src/frb_generated.io.rs b/frb_example/dart_minimal/rust/src/frb_generated.io.rs index ad2ae55f78..3d3009d74e 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.io.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.io.rs @@ -4,6 +4,7 @@ // Section: imports use super::*; +use crate::api::minimal::*; use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt}; use flutter_rust_bridge::for_generated::transform_result_dco; use flutter_rust_bridge::{Handler, IntoIntoDart}; @@ -11,3 +12,17 @@ use flutter_rust_bridge::{Handler, IntoIntoDart}; // Section: boilerplate flutter_rust_bridge::frb_generated_boilerplate_io!(); + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_dart_minimal_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ptr: *const std::ffi::c_void, +) { + MoiArc::>>::increment_strong_count(ptr as _); +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_dart_minimal_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ptr: *const std::ffi::c_void, +) { + MoiArc::>>::decrement_strong_count(ptr as _); +} diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index 64290349a0..2c58526126 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -19,6 +19,7 @@ // Section: imports +use crate::api::minimal::*; use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt}; use flutter_rust_bridge::for_generated::transform_result_dco; use flutter_rust_bridge::{Handler, IntoIntoDart}; @@ -31,7 +32,7 @@ flutter_rust_bridge::frb_generated_boilerplate!( default_rust_auto_opaque = RustAutoOpaqueMoi, ); pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.33"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -2119384465; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -957330701; // Section: executor @@ -103,9 +104,89 @@ fn wire_minimal_adder_impl( }, ) } +fn wire_rust_function_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_function", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { + let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_dart_callback = decode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + transform_result_sse((move || async move { + Result::<_,()>::Ok(crate::api::minimal::rust_function(api_dart_callback).await) + })().await) + } }) +} + +// Section: related_funcs + +fn decode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + dart_opaque: flutter_rust_bridge::DartOpaque, +) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture> { + use flutter_rust_bridge::IntoDart; + + async fn body( + dart_opaque: flutter_rust_bridge::DartOpaque, + arg0: String, + ) -> Result { + let args = vec![arg0.into_into_dart().into_dart()]; + let message = FLUTTER_RUST_BRIDGE_HANDLER + .dart_fn_invoke(dart_opaque, args) + .await; + >::sse_decode_single(message) + } + + move |arg0: String| { + flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body( + dart_opaque.clone(), + arg0, + )) + } +} +flutter_rust_bridge::frb_generated_moi_arc_impl_value!( + flutter_rust_bridge::for_generated::RustAutoOpaqueInner> +); // Section: dart2rust +impl SseDecode for Result { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = >, + >>::sse_decode(deserializer); + return inner.rust_auto_opaque_decode_owned(); + } +} + +impl SseDecode for flutter_rust_bridge::DartOpaque { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return unsafe { flutter_rust_bridge::for_generated::sse_decode_dart_opaque(inner) }; + } +} + +impl SseDecode + for RustOpaqueMoi>> +{ + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return decode_rust_opaque_moi(inner); + } +} + +impl SseDecode for String { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = >::sse_decode(deserializer); + return String::from_utf8(inner).unwrap(); + } +} + impl SseDecode for i32 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -113,11 +194,37 @@ impl SseDecode for i32 { } } +impl SseDecode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut len_ = ::sse_decode(deserializer); + let mut ans_ = vec![]; + for idx_ in 0..len_ { + ans_.push(::sse_decode(deserializer)); + } + return ans_; + } +} + +impl SseDecode for u8 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_u8().unwrap() + } +} + impl SseDecode for () { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {} } +impl SseDecode for usize { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_u64::().unwrap() as _ + } +} + impl SseDecode for bool { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -136,6 +243,7 @@ fn pde_ffi_dispatcher_primary_impl( match func_id { 1 => wire_init_app_impl(port, ptr, rust_vec_len, data_len), 2 => wire_minimal_adder_impl(port, ptr, rust_vec_len, data_len), + 3 => wire_rust_function_impl(port, ptr, rust_vec_len, data_len), _ => unreachable!(), } } @@ -154,6 +262,56 @@ fn pde_ffi_dispatcher_sync_impl( // Section: rust2dart +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for FrbWrapper> { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0) + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for FrbWrapper> +{ +} + +impl flutter_rust_bridge::IntoIntoDart>> for Result { + fn into_into_dart(self) -> FrbWrapper> { + self.into() + } +} + +impl SseEncode for Result { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer); + } +} + +impl SseEncode for flutter_rust_bridge::DartOpaque { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.encode(), serializer); + } +} + +impl SseEncode + for RustOpaqueMoi>> +{ + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + let (ptr, size) = self.sse_encode_raw(); + ::sse_encode(ptr, serializer); + ::sse_encode(size, serializer); + } +} + +impl SseEncode for String { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >::sse_encode(self.into_bytes(), serializer); + } +} + impl SseEncode for i32 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -161,11 +319,38 @@ impl SseEncode for i32 { } } +impl SseEncode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.len() as _, serializer); + for item in self { + ::sse_encode(item, serializer); + } + } +} + +impl SseEncode for u8 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer.cursor.write_u8(self).unwrap(); + } +} + impl SseEncode for () { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {} } +impl SseEncode for usize { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer + .cursor + .write_u64::(self as _) + .unwrap(); + } +} + impl SseEncode for bool { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { diff --git a/frb_example/dart_minimal/rust/src/frb_generated.web.rs b/frb_example/dart_minimal/rust/src/frb_generated.web.rs index f58ccd446f..bfeae07410 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.web.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.web.rs @@ -4,6 +4,7 @@ // Section: imports use super::*; +use crate::api::minimal::*; use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt}; use flutter_rust_bridge::for_generated::transform_result_dco; use flutter_rust_bridge::for_generated::wasm_bindgen; @@ -13,3 +14,17 @@ use flutter_rust_bridge::{Handler, IntoIntoDart}; // Section: boilerplate flutter_rust_bridge::frb_generated_boilerplate_web!(); + +#[wasm_bindgen] +pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ptr: *const std::ffi::c_void, +) { + MoiArc::>>::increment_strong_count(ptr as _); +} + +#[wasm_bindgen] +pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( + ptr: *const std::ffi::c_void, +) { + MoiArc::>>::decrement_strong_count(ptr as _); +} From cddbe3c8badd1d5180864233e9cb9064378dcc85 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Wed, 15 May 2024 20:37:02 +0800 Subject: [PATCH 03/94] refactor: mv --- .../codegen/parser/function_parser/output.rs | 49 +++---------------- .../library/codegen/parser/type_parser/mod.rs | 1 + .../codegen/parser/type_parser/result.rs | 47 ++++++++++++++++++ 3 files changed, 56 insertions(+), 41 deletions(-) create mode 100644 frb_codegen/src/library/codegen/parser/type_parser/result.rs diff --git a/frb_codegen/src/library/codegen/parser/function_parser/output.rs b/frb_codegen/src/library/codegen/parser/function_parser/output.rs index 4ed21e8ea5..3ab65ebcbf 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/output.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/output.rs @@ -3,6 +3,7 @@ use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::IrType; use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; use crate::codegen::parser::function_parser::{FunctionParser, FunctionPartialInfo}; +use crate::codegen::parser::type_parser::result::parse_fn_output_type_result; use crate::codegen::parser::type_parser::unencodable::splay_segments; use crate::codegen::parser::type_parser::TypeParserParsingContext; use syn::*; @@ -32,11 +33,16 @@ impl<'a, 'b> FunctionParser<'a, 'b> { if let IrType::RustAutoOpaque(inner) = ir { match splay_segments(&inner.raw.segments).last() { Some(("Result", args)) => { - return parse_fn_output_type_result( + let info = parse_fn_output_type_result( &(args.iter()) .map(|arg| self.type_parser.parse_type(arg, context)) .collect::>>()?, - ); + )?; + return Ok(FunctionPartialInfo { + ok_output: Some(info.ok_output), + error_output: info.error_output, + ..Default::default() + }); } _ => {} } @@ -49,45 +55,6 @@ impl<'a, 'b> FunctionParser<'a, 'b> { } } -fn parse_fn_output_type_result(args: &[IrType]) -> anyhow::Result { - let ok_output = args.first().unwrap(); - - let is_anyhow = args.len() == 1 - || args.iter().any(|x| { - if let IrType::RustAutoOpaque(inner) = x { - return inner.raw.string == "anyhow :: Error"; - } - false - }); - - let error_output = if is_anyhow { - Some(IrType::Delegate(IrTypeDelegate::AnyhowException)) - } else { - args.last().cloned() - }; - - let error_output = error_output.map(set_is_exception_flag); - - Ok(FunctionPartialInfo { - ok_output: Some(ok_output.clone()), - error_output, - ..Default::default() - }) -} - -fn set_is_exception_flag(mut ty: IrType) -> IrType { - match &mut ty { - StructRef(ref mut inner) => { - inner.is_exception = true; - } - EnumRef(ref mut inner) => { - inner.is_exception = true; - } - _ => {} - } - ty -} - // Convert primitive Unit type -> None fn remove_primitive_unit(info: FunctionPartialInfo) -> FunctionPartialInfo { let ok_output = if info.ok_output == Some(IrType::Primitive(IrTypePrimitive::Unit)) { diff --git a/frb_codegen/src/library/codegen/parser/type_parser/mod.rs b/frb_codegen/src/library/codegen/parser/type_parser/mod.rs index 0dbd4f6960..15b84a36ca 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/mod.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/mod.rs @@ -28,6 +28,7 @@ pub(crate) mod optional; pub(crate) mod path; pub(crate) mod path_data; pub(crate) mod primitive; +pub(crate) mod result; pub(crate) mod rust_auto_opaque; mod rust_opaque; pub(crate) mod structure; diff --git a/frb_codegen/src/library/codegen/parser/type_parser/result.rs b/frb_codegen/src/library/codegen/parser/type_parser/result.rs new file mode 100644 index 0000000000..fbe8d7f311 --- /dev/null +++ b/frb_codegen/src/library/codegen/parser/type_parser/result.rs @@ -0,0 +1,47 @@ +use crate::codegen::ir::ty::delegate::IrTypeDelegate; +use crate::codegen::ir::ty::IrType; +use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; + +pub(crate) fn parse_fn_output_type_result(args: &[IrType]) -> anyhow::Result { + let ok_output = args.first().unwrap(); + + let is_anyhow = args.len() == 1 + || args.iter().any(|x| { + if let IrType::RustAutoOpaque(inner) = x { + return inner.raw.string == "anyhow :: Error"; + } + false + }); + + let error_output = if is_anyhow { + Some(IrType::Delegate(IrTypeDelegate::AnyhowException)) + } else { + args.last().cloned() + }; + + let error_output = error_output.map(set_is_exception_flag); + + Ok(ResultTypeInfo { + ok_output: Some(ok_output.clone()), + error_output, + ..Default::default() + }) +} + +pub(crate) struct ResultTypeInfo { + ok_output: IrType, + error_output: Option, +} + +fn set_is_exception_flag(mut ty: IrType) -> IrType { + match &mut ty { + StructRef(ref mut inner) => { + inner.is_exception = true; + } + EnumRef(ref mut inner) => { + inner.is_exception = true; + } + _ => {} + } + ty +} From 00c86a87977e9355bafeb1cf55952dcc47bac65e Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Wed, 15 May 2024 20:40:16 +0800 Subject: [PATCH 04/94] feat: more --- .../codegen/parser/function_parser/output.rs | 27 ++++------------ .../codegen/parser/type_parser/result.rs | 31 +++++++++++++++++-- 2 files changed, 34 insertions(+), 24 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/function_parser/output.rs b/frb_codegen/src/library/codegen/parser/function_parser/output.rs index 3ab65ebcbf..a1cee5ea01 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/output.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/output.rs @@ -3,7 +3,9 @@ use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::IrType; use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; use crate::codegen::parser::function_parser::{FunctionParser, FunctionPartialInfo}; -use crate::codegen::parser::type_parser::result::parse_fn_output_type_result; +use crate::codegen::parser::type_parser::result::{ + parse_fn_output_type_result, parse_type_maybe_result, +}; use crate::codegen::parser::type_parser::unencodable::splay_segments; use crate::codegen::parser::type_parser::TypeParserParsingContext; use syn::*; @@ -29,27 +31,10 @@ impl<'a, 'b> FunctionParser<'a, 'b> { context: &TypeParserParsingContext, ) -> anyhow::Result { let ir = self.type_parser.parse_type(ty, context)?; - - if let IrType::RustAutoOpaque(inner) = ir { - match splay_segments(&inner.raw.segments).last() { - Some(("Result", args)) => { - let info = parse_fn_output_type_result( - &(args.iter()) - .map(|arg| self.type_parser.parse_type(arg, context)) - .collect::>>()?, - )?; - return Ok(FunctionPartialInfo { - ok_output: Some(info.ok_output), - error_output: info.error_output, - ..Default::default() - }); - } - _ => {} - } - } - + let info = parse_type_maybe_result(&ir, self.type_parser)?; Ok(FunctionPartialInfo { - ok_output: Some(self.type_parser.parse_type(ty, context)?), + ok_output: Some(info.ok_output), + error_output: info.error_output, ..Default::default() }) } diff --git a/frb_codegen/src/library/codegen/parser/type_parser/result.rs b/frb_codegen/src/library/codegen/parser/type_parser/result.rs index fbe8d7f311..d926f343a2 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/result.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/result.rs @@ -1,8 +1,33 @@ use crate::codegen::ir::ty::delegate::IrTypeDelegate; use crate::codegen::ir::ty::IrType; use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; +use crate::codegen::parser::type_parser::unencodable::splay_segments; +use crate::codegen::parser::type_parser::TypeParser; -pub(crate) fn parse_fn_output_type_result(args: &[IrType]) -> anyhow::Result { +pub(crate) fn parse_type_maybe_result( + ir: &IrType, + type_parser: &mut TypeParser, +) -> anyhow::Result { + if let IrType::RustAutoOpaque(inner) = ir { + match splay_segments(&inner.raw.segments).last() { + Some(("Result", args)) => { + return parse_type_result( + &(args.iter()) + .map(|arg| type_parser.parse_type(arg, context)) + .collect::>>()?, + ); + } + _ => {} + } + } + + Ok(ResultTypeInfo { + ok_output: Some(type_parser.parse_type(ty, context)?), + error_output: TODO, + }) +} + +fn parse_type_result(args: &[IrType]) -> anyhow::Result { let ok_output = args.first().unwrap(); let is_anyhow = args.len() == 1 @@ -29,8 +54,8 @@ pub(crate) fn parse_fn_output_type_result(args: &[IrType]) -> anyhow::Result, + pub ok_output: IrType, + pub error_output: Option, } fn set_is_exception_flag(mut ty: IrType) -> IrType { From 45ca1c932e3d37d0bda32ecebab4fd8b147675ff Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Wed, 15 May 2024 20:41:24 +0800 Subject: [PATCH 05/94] feat: more --- .../src/library/codegen/parser/type_parser/dart_fn.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 145573c32d..afe9923ba9 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -1,5 +1,6 @@ use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; use crate::codegen::ir::ty::IrType; +use crate::codegen::parser::type_parser::result::parse_type_maybe_result; use crate::codegen::parser::type_parser::TypeParserWithContext; use crate::if_then_some; use anyhow::{bail, Context}; @@ -67,7 +68,9 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .find(|arg| matches!(arg, GenericArgument::Type(_))) .unwrap() { - return self.parse_type(inner_ty); + let ir = self.parse_type(inner_ty)?; + let info = parse_type_maybe_result(ir, self.inner)?; + return TODO; // This will stop the whole generator and tell the users, so we do not care about testing it // frb-coverage:ignore-start From 91acb08d17b9fe64227f044f169333ae72fba6c8 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Wed, 15 May 2024 20:42:46 +0800 Subject: [PATCH 06/94] feat: more --- .../src/library/codegen/ir/ty/dart_fn.rs | 3 ++- .../codegen/parser/type_parser/dart_fn.rs | 18 ++++++++++++------ 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs index 42b9bb2d1f..b679b3941f 100644 --- a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs @@ -5,7 +5,8 @@ use itertools::Itertools; crate::ir! { pub struct IrTypeDartFn { pub inputs: Vec, - pub output: Box, + pub ok_output: Box, + pub error_output: Option, } } diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index afe9923ba9..f99eeca49e 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -1,6 +1,6 @@ use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; use crate::codegen::ir::ty::IrType; -use crate::codegen::parser::type_parser::result::parse_type_maybe_result; +use crate::codegen::parser::type_parser::result::{parse_type_maybe_result, ResultTypeInfo}; use crate::codegen::parser::type_parser::TypeParserWithContext; use crate::if_then_some; use anyhow::{bail, Context}; @@ -39,9 +39,16 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .map(|x| self.parse_type(x)) .collect::>>()?; - let output = Box::new(self.parse_dart_fn_output(&arguments.output)?); + let ResultTypeInfo { + ok_output, + error_output, + } = Box::new(self.parse_dart_fn_output(&arguments.output)?); - return Ok(IrType::DartFn(IrTypeDartFn { inputs, output })); + return Ok(IrType::DartFn(IrTypeDartFn { + inputs, + ok_output, + error_output, + })); // This will stop the whole generator and tell the users, so we do not care about testing it // frb-coverage:ignore-start @@ -53,7 +60,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { // the function signature is not covered while the whole body is covered - looks like a bug in coverage tool // frb-coverage:ignore-start - fn parse_dart_fn_output(&mut self, return_type: &ReturnType) -> anyhow::Result { + fn parse_dart_fn_output(&mut self, return_type: &ReturnType) -> anyhow::Result { // frb-coverage:ignore-end if let ReturnType::Type(_, ret_ty) = return_type { if let Type::Path(TypePath { ref path, .. }) = **ret_ty { @@ -69,8 +76,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .unwrap() { let ir = self.parse_type(inner_ty)?; - let info = parse_type_maybe_result(ir, self.inner)?; - return TODO; + return parse_type_maybe_result(ir, self.inner); // This will stop the whole generator and tell the users, so we do not care about testing it // frb-coverage:ignore-start From 5a2c85ea680067dcd4a1e99510854991d2da540a Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Wed, 15 May 2024 20:43:28 +0800 Subject: [PATCH 07/94] fix: err --- frb_codegen/src/library/codegen/ir/ty/dart_fn.rs | 2 +- .../src/library/codegen/parser/function_parser/output.rs | 6 ++---- .../src/library/codegen/parser/type_parser/dart_fn.rs | 2 +- .../src/library/codegen/parser/type_parser/result.rs | 8 ++++---- 4 files changed, 8 insertions(+), 10 deletions(-) diff --git a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs index b679b3941f..ff50b94263 100644 --- a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs @@ -6,7 +6,7 @@ crate::ir! { pub struct IrTypeDartFn { pub inputs: Vec, pub ok_output: Box, - pub error_output: Option, + pub error_output: Option>, } } diff --git a/frb_codegen/src/library/codegen/parser/function_parser/output.rs b/frb_codegen/src/library/codegen/parser/function_parser/output.rs index a1cee5ea01..75d4e8277e 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/output.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/output.rs @@ -3,9 +3,7 @@ use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::IrType; use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; use crate::codegen::parser::function_parser::{FunctionParser, FunctionPartialInfo}; -use crate::codegen::parser::type_parser::result::{ - parse_fn_output_type_result, parse_type_maybe_result, -}; +use crate::codegen::parser::type_parser::result::parse_type_maybe_result; use crate::codegen::parser::type_parser::unencodable::splay_segments; use crate::codegen::parser::type_parser::TypeParserParsingContext; use syn::*; @@ -31,7 +29,7 @@ impl<'a, 'b> FunctionParser<'a, 'b> { context: &TypeParserParsingContext, ) -> anyhow::Result { let ir = self.type_parser.parse_type(ty, context)?; - let info = parse_type_maybe_result(&ir, self.type_parser)?; + let info = parse_type_maybe_result(&ir, self.type_parser, context)?; Ok(FunctionPartialInfo { ok_output: Some(info.ok_output), error_output: info.error_output, diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index f99eeca49e..be964c0117 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -76,7 +76,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .unwrap() { let ir = self.parse_type(inner_ty)?; - return parse_type_maybe_result(ir, self.inner); + return parse_type_maybe_result(ir, self.inner, self.context); // This will stop the whole generator and tell the users, so we do not care about testing it // frb-coverage:ignore-start diff --git a/frb_codegen/src/library/codegen/parser/type_parser/result.rs b/frb_codegen/src/library/codegen/parser/type_parser/result.rs index d926f343a2..3117b41c09 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/result.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/result.rs @@ -2,11 +2,12 @@ use crate::codegen::ir::ty::delegate::IrTypeDelegate; use crate::codegen::ir::ty::IrType; use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; use crate::codegen::parser::type_parser::unencodable::splay_segments; -use crate::codegen::parser::type_parser::TypeParser; +use crate::codegen::parser::type_parser::{TypeParser, TypeParserParsingContext}; pub(crate) fn parse_type_maybe_result( ir: &IrType, type_parser: &mut TypeParser, + context: &TypeParserParsingContext, ) -> anyhow::Result { if let IrType::RustAutoOpaque(inner) = ir { match splay_segments(&inner.raw.segments).last() { @@ -22,8 +23,8 @@ pub(crate) fn parse_type_maybe_result( } Ok(ResultTypeInfo { - ok_output: Some(type_parser.parse_type(ty, context)?), - error_output: TODO, + ok_output: type_parser.parse_type(ty, context)?, + error_output: None, }) } @@ -49,7 +50,6 @@ fn parse_type_result(args: &[IrType]) -> anyhow::Result { Ok(ResultTypeInfo { ok_output: Some(ok_output.clone()), error_output, - ..Default::default() }) } From 717f1cc00dec4f93e514154e8bb1680883bb16ea Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Wed, 15 May 2024 20:45:08 +0800 Subject: [PATCH 08/94] fix: more --- .../src/library/codegen/parser/type_parser/dart_fn.rs | 8 ++++---- .../src/library/codegen/parser/type_parser/result.rs | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index be964c0117..065e13e97d 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -42,12 +42,12 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { let ResultTypeInfo { ok_output, error_output, - } = Box::new(self.parse_dart_fn_output(&arguments.output)?); + } = self.parse_dart_fn_output(&arguments.output)?; return Ok(IrType::DartFn(IrTypeDartFn { inputs, - ok_output, - error_output, + ok_output: Box::new(ok_output), + error_output: error_output.map(Box::new), })); // This will stop the whole generator and tell the users, so we do not care about testing it @@ -76,7 +76,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .unwrap() { let ir = self.parse_type(inner_ty)?; - return parse_type_maybe_result(ir, self.inner, self.context); + return parse_type_maybe_result(&ir, self.inner, self.context); // This will stop the whole generator and tell the users, so we do not care about testing it // frb-coverage:ignore-start diff --git a/frb_codegen/src/library/codegen/parser/type_parser/result.rs b/frb_codegen/src/library/codegen/parser/type_parser/result.rs index 3117b41c09..0f7aa16bd3 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/result.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/result.rs @@ -23,7 +23,7 @@ pub(crate) fn parse_type_maybe_result( } Ok(ResultTypeInfo { - ok_output: type_parser.parse_type(ty, context)?, + ok_output: ir.clone(), error_output: None, }) } @@ -48,7 +48,7 @@ fn parse_type_result(args: &[IrType]) -> anyhow::Result { let error_output = error_output.map(set_is_exception_flag); Ok(ResultTypeInfo { - ok_output: Some(ok_output.clone()), + ok_output: ok_output.clone(), error_output, }) } From 86572d8bcdcc2a7a49d076a03b8b5561407571a3 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Wed, 15 May 2024 20:46:26 +0800 Subject: [PATCH 09/94] feat: rename --- .../library/codegen/generator/api_dart/spec_generator/info.rs | 2 +- .../generator/wire/dart/spec_generator/misc/ty/dart_fn.rs | 2 +- .../generator/wire/rust/spec_generator/misc/ty/dart_fn.rs | 2 +- frb_codegen/src/library/codegen/ir/ty/dart_fn.rs | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/info.rs b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/info.rs index 32ecb67523..f67eb98c36 100644 --- a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/info.rs +++ b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/info.rs @@ -30,7 +30,7 @@ impl<'a> ApiDartGeneratorInfoTrait for DartFnApiDartGenerator<'a> { fn dart_api_type(&self) -> String { format!( "FutureOr<{}> Function({})", - ApiDartGenerator::new(self.ir.output.clone(), self.context).dart_api_type(), + ApiDartGenerator::new(self.ir.ok_output.clone(), self.context).dart_api_type(), (self.ir.inputs.iter()) .map(|x| ApiDartGenerator::new(x.clone(), self.context).dart_api_type()) .join(", "), diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index fd0e496bf3..4bb31a083d 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -25,7 +25,7 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { let dart_api_type = ApiDartGenerator::new(self.ir.clone(), self.context.as_api_dart_context()) .dart_api_type(); - let return_type_safe_ident = self.ir.output.safe_ident(); + let return_type_safe_ident = self.ir.ok_output.safe_ident(); let api_impl_body = format!( " diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index f8342af47c..f4f6643da4 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -22,7 +22,7 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { .map(|i| format!("arg{i}.into_into_dart().into_dart(),")) .join(""); - let return_type = self.ir.output.rust_api_type(); + let return_type = self.ir.ok_output.rust_api_type(); Acc::new_common( format!( diff --git a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs index ff50b94263..2caef58885 100644 --- a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs @@ -21,14 +21,14 @@ impl IrTypeTrait for IrTypeDartFn { for x in &self.inputs { x.visit_types(f, ir_context); } - self.output.visit_types(f, ir_context); + self.ok_output.visit_types(f, ir_context); } fn safe_ident(&self) -> String { format!( "DartFn_Inputs_{}_Output_{}", self.inputs.iter().map(|x| x.safe_ident()).join("_"), - self.output.safe_ident() + self.ok_output.safe_ident() ) } From 4602f83aff8413b87bf6b04987e795b8dc2e419a Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:30:54 +0800 Subject: [PATCH 10/94] chore: codegen --- .../lib/src/rust/api/minimal.dart | 28 +--- .../lib/src/rust/frb_generated.dart | 133 ++++-------------- .../lib/src/rust/frb_generated.io.dart | 77 +--------- .../lib/src/rust/frb_generated.web.dart | 65 +-------- .../dart_minimal/rust/src/frb_generated.io.rs | 15 -- .../dart_minimal/rust/src/frb_generated.rs | 127 ++++++----------- .../rust/src/frb_generated.web.rs | 15 -- 7 files changed, 87 insertions(+), 373 deletions(-) diff --git a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart index 0f2eb84ebe..9cb3f3fdaf 100644 --- a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart +++ b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart @@ -1,5 +1,5 @@ // This file is automatically generated, so please do not edit it. -// Generated by `flutter_rust_bridge`@ 2.0.0-dev.33. +// Generated by `flutter_rust_bridge`@ 2.0.0-dev.34. // ignore_for_file: invalid_use_of_internal_member, unused_import, unnecessary_import @@ -7,28 +7,10 @@ import '../frb_generated.dart'; import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; Future minimalAdder({required int a, required int b, dynamic hint}) => - RustLib.instance.api.minimalAdder(a: a, b: b, hint: hint); + RustLib.instance.api.crateApiMinimalMinimalAdder(a: a, b: b, hint: hint); Future rustFunction( - {required FutureOr Function(String) dartCallback, + {required FutureOr Function(String) dartCallback, dynamic hint}) => - RustLib.instance.api.rustFunction(dartCallback: dartCallback, hint: hint); - -// Rust type: RustOpaqueMoi>> -@sealed -class ResultStringU32 extends RustOpaque { - ResultStringU32.dcoDecode(List wire) - : super.dcoDecode(wire, _kStaticData); - - ResultStringU32.sseDecode(int ptr, int externalSizeOnNative) - : super.sseDecode(ptr, externalSizeOnNative, _kStaticData); - - static final _kStaticData = RustArcStaticData( - rustArcIncrementStrongCount: - RustLib.instance.api.rust_arc_increment_strong_count_ResultStringU32, - rustArcDecrementStrongCount: - RustLib.instance.api.rust_arc_decrement_strong_count_ResultStringU32, - rustArcDecrementStrongCountPtr: - RustLib.instance.api.rust_arc_decrement_strong_count_ResultStringU32Ptr, - ); -} + RustLib.instance.api + .crateApiMinimalRustFunction(dartCallback: dartCallback, hint: hint); diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index c0ba167a6d..986372c8a8 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -1,5 +1,5 @@ // This file is automatically generated, so please do not edit it. -// Generated by `flutter_rust_bridge`@ 2.0.0-dev.33. +// Generated by `flutter_rust_bridge`@ 2.0.0-dev.34. // 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 @@ -45,7 +45,7 @@ class RustLib extends BaseEntrypoint { @override Future executeRustInitializers() async { - await api.initApp(); + await api.crateApiMinimalInitApp(); } @override @@ -53,7 +53,7 @@ class RustLib extends BaseEntrypoint { kDefaultExternalLibraryLoaderConfig; @override - String get codegenVersion => '2.0.0-dev.33'; + String get codegenVersion => '2.0.0-dev.34'; @override int get rustContentHash => -957330701; @@ -67,22 +67,13 @@ class RustLib extends BaseEntrypoint { } abstract class RustLibApi extends BaseApi { - Future initApp({dynamic hint}); + Future crateApiMinimalInitApp({dynamic hint}); - Future minimalAdder({required int a, required int b, dynamic hint}); + Future crateApiMinimalMinimalAdder( + {required int a, required int b, dynamic hint}); - Future rustFunction( - {required FutureOr Function(String) dartCallback, - dynamic hint}); - - RustArcIncrementStrongCountFnType - get rust_arc_increment_strong_count_ResultStringU32; - - RustArcDecrementStrongCountFnType - get rust_arc_decrement_strong_count_ResultStringU32; - - CrossPlatformFinalizerArg - get rust_arc_decrement_strong_count_ResultStringU32Ptr; + Future crateApiMinimalRustFunction( + {required FutureOr Function(String) dartCallback, dynamic hint}); } class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @@ -94,7 +85,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { }); @override - Future initApp({dynamic hint}) { + Future crateApiMinimalInitApp({dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); @@ -105,20 +96,21 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { decodeSuccessData: sse_decode_unit, decodeErrorData: null, ), - constMeta: kInitAppConstMeta, + constMeta: kCrateApiMinimalInitAppConstMeta, argValues: [], apiImpl: this, hint: hint, )); } - TaskConstMeta get kInitAppConstMeta => const TaskConstMeta( + TaskConstMeta get kCrateApiMinimalInitAppConstMeta => const TaskConstMeta( debugName: "init_app", argNames: [], ); @override - Future minimalAdder({required int a, required int b, dynamic hint}) { + Future crateApiMinimalMinimalAdder( + {required int a, required int b, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); @@ -131,27 +123,26 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { decodeSuccessData: sse_decode_i_32, decodeErrorData: null, ), - constMeta: kMinimalAdderConstMeta, + constMeta: kCrateApiMinimalMinimalAdderConstMeta, argValues: [a, b], apiImpl: this, hint: hint, )); } - TaskConstMeta get kMinimalAdderConstMeta => const TaskConstMeta( + TaskConstMeta get kCrateApiMinimalMinimalAdderConstMeta => + const TaskConstMeta( debugName: "minimal_adder", argNames: ["a", "b"], ); @override - Future rustFunction( - {required FutureOr Function(String) dartCallback, - dynamic hint}) { + Future crateApiMinimalRustFunction( + {required FutureOr Function(String) dartCallback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dartCallback, serializer); + sse_encode_DartFn_Inputs_String_Output_String(dartCallback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 3, port: port_); }, @@ -159,29 +150,28 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { decodeSuccessData: sse_decode_unit, decodeErrorData: null, ), - constMeta: kRustFunctionConstMeta, + constMeta: kCrateApiMinimalRustFunctionConstMeta, argValues: [dartCallback], apiImpl: this, hint: hint, )); } - TaskConstMeta get kRustFunctionConstMeta => const TaskConstMeta( + TaskConstMeta get kCrateApiMinimalRustFunctionConstMeta => + const TaskConstMeta( debugName: "rust_function", argNames: ["dartCallback"], ); - Future Function(int, dynamic) - encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - FutureOr Function(String) raw) { + Future Function(int, dynamic) encode_DartFn_Inputs_String_Output_String( + FutureOr Function(String) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_String(rawArg0); final rawOutput = await raw(arg0); final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - rawOutput, serializer); + sse_encode_String(rawOutput, serializer); final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -192,26 +182,9 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { }; } - RustArcIncrementStrongCountFnType - get rust_arc_increment_strong_count_ResultStringU32 => wire - .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32; - - RustArcDecrementStrongCountFnType - get rust_arc_decrement_strong_count_ResultStringU32 => wire - .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32; - @protected - ResultStringU32 - dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic raw) { - // Codec=Dco (DartCObject based), see doc to use other codecs - return ResultStringU32.dcoDecode(raw as List); - } - - @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic raw) { + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @@ -222,14 +195,6 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return decodeDartOpaque(raw, generalizedFrbRustBinding); } - @protected - ResultStringU32 - dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic raw) { - // Codec=Dco (DartCObject based), see doc to use other codecs - return ResultStringU32.dcoDecode(raw as List); - } - @protected String dco_decode_String(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs @@ -266,15 +231,6 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return dcoDecodeI64OrU64(raw); } - @protected - ResultStringU32 - sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - SseDeserializer deserializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - return ResultStringU32.sseDecode( - sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); - } - @protected Object sse_decode_DartOpaque(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -282,15 +238,6 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return decodeDartOpaque(inner, generalizedFrbRustBinding); } - @protected - ResultStringU32 - sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - SseDeserializer deserializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - return ResultStringU32.sseDecode( - sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); - } - @protected String sse_decode_String(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -335,23 +282,11 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void - sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ResultStringU32 self, SseSerializer serializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - sse_encode_usize(self.sseEncode(move: true), serializer); - } - - @protected - void - sse_encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - FutureOr Function(String) self, - SseSerializer serializer) { + void sse_encode_DartFn_Inputs_String_Output_String( + FutureOr Function(String) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - self), - serializer); + encode_DartFn_Inputs_String_Output_String(self), serializer); } @protected @@ -363,14 +298,6 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { serializer); } - @protected - void - sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ResultStringU32 self, SseSerializer serializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - sse_encode_usize(self.sseEncode(move: null), serializer); - } - @protected void sse_encode_String(String self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart index 2dd343bb3b..10abc65201 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart @@ -18,28 +18,13 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { required super.portManager, }); - CrossPlatformFinalizerArg - get rust_arc_decrement_strong_count_ResultStringU32Ptr => wire - ._rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32Ptr; - - @protected - ResultStringU32 - dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic raw); - @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic raw); + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String(dynamic raw); @protected Object dco_decode_DartOpaque(dynamic raw); - @protected - ResultStringU32 - dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic raw); - @protected String dco_decode_String(dynamic raw); @@ -58,19 +43,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected int dco_decode_usize(dynamic raw); - @protected - ResultStringU32 - sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - SseDeserializer deserializer); - @protected Object sse_decode_DartOpaque(SseDeserializer deserializer); - @protected - ResultStringU32 - sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - SseDeserializer deserializer); - @protected String sse_decode_String(SseDeserializer deserializer); @@ -93,24 +68,12 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { bool sse_decode_bool(SseDeserializer deserializer); @protected - void - sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ResultStringU32 self, SseSerializer serializer); - - @protected - void - sse_encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - FutureOr Function(String) self, - SseSerializer serializer); + void sse_encode_DartFn_Inputs_String_Output_String( + FutureOr Function(String) self, SseSerializer serializer); @protected void sse_encode_DartOpaque(Object self, SseSerializer serializer); - @protected - void - sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ResultStringU32 self, SseSerializer serializer); - @protected void sse_encode_String(String self, SseSerializer serializer); @@ -147,36 +110,4 @@ class RustLibWire implements BaseWire { /// The symbols are looked up in [dynamicLibrary]. RustLibWire(ffi.DynamicLibrary dynamicLibrary) : _lookup = dynamicLibrary.lookup; - - void - rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ffi.Pointer ptr, - ) { - return _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ptr, - ); - } - - late final _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32Ptr = - _lookup)>>( - 'frbgen_frb_example_dart_minimal_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32'); - late final _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32 = - _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32Ptr - .asFunction)>(); - - void - rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ffi.Pointer ptr, - ) { - return _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ptr, - ); - } - - late final _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32Ptr = - _lookup)>>( - 'frbgen_frb_example_dart_minimal_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32'); - late final _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32 = - _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32Ptr - .asFunction)>(); } diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart index d5f9c25af0..fe8406189d 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart @@ -17,28 +17,13 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { required super.portManager, }); - CrossPlatformFinalizerArg - get rust_arc_decrement_strong_count_ResultStringU32Ptr => wire - .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32; - - @protected - ResultStringU32 - dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic raw); - @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic raw); + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String(dynamic raw); @protected Object dco_decode_DartOpaque(dynamic raw); - @protected - ResultStringU32 - dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic raw); - @protected String dco_decode_String(dynamic raw); @@ -57,19 +42,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected int dco_decode_usize(dynamic raw); - @protected - ResultStringU32 - sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - SseDeserializer deserializer); - @protected Object sse_decode_DartOpaque(SseDeserializer deserializer); - @protected - ResultStringU32 - sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - SseDeserializer deserializer); - @protected String sse_decode_String(SseDeserializer deserializer); @@ -92,24 +67,12 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { bool sse_decode_bool(SseDeserializer deserializer); @protected - void - sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ResultStringU32 self, SseSerializer serializer); - - @protected - void - sse_encode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - FutureOr Function(String) self, - SseSerializer serializer); + void sse_encode_DartFn_Inputs_String_Output_String( + FutureOr Function(String) self, SseSerializer serializer); @protected void sse_encode_DartOpaque(Object self, SseSerializer serializer); - @protected - void - sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ResultStringU32 self, SseSerializer serializer); - @protected void sse_encode_String(String self, SseSerializer serializer); @@ -137,18 +100,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { class RustLibWire implements BaseWire { RustLibWire.fromExternalLibrary(ExternalLibrary lib); - - void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic ptr) => - wasmModule - .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ptr); - - void rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic ptr) => - wasmModule - .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ptr); } @JS('wasm_bindgen') @@ -162,12 +113,4 @@ class RustLibWasmModule implements WasmModule { @override external RustLibWasmModule bind(dynamic thisArg, String moduleName); - - external void - rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic ptr); - - external void - rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - dynamic ptr); } diff --git a/frb_example/dart_minimal/rust/src/frb_generated.io.rs b/frb_example/dart_minimal/rust/src/frb_generated.io.rs index f00ea8d128..64e01a06a7 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.io.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.io.rs @@ -4,7 +4,6 @@ // Section: imports use super::*; -use crate::api::minimal::*; use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt}; use flutter_rust_bridge::for_generated::transform_result_dco; use flutter_rust_bridge::{Handler, IntoIntoDart}; @@ -12,17 +11,3 @@ use flutter_rust_bridge::{Handler, IntoIntoDart}; // Section: boilerplate flutter_rust_bridge::frb_generated_boilerplate_io!(); - -#[no_mangle] -pub extern "C" fn frbgen_frb_example_dart_minimal_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ptr: *const std::ffi::c_void, -) { - MoiArc::>>::increment_strong_count(ptr as _); -} - -#[no_mangle] -pub extern "C" fn frbgen_frb_example_dart_minimal_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ptr: *const std::ffi::c_void, -) { - MoiArc::>>::decrement_strong_count(ptr as _); -} diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index 2c58526126..ed077bac83 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -1,5 +1,5 @@ // This file is automatically generated, so please do not edit it. -// Generated by `flutter_rust_bridge`@ 2.0.0-dev.33. +// Generated by `flutter_rust_bridge`@ 2.0.0-dev.34. #![allow( non_camel_case_types, @@ -19,7 +19,6 @@ // Section: imports -use crate::api::minimal::*; use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt}; use flutter_rust_bridge::for_generated::transform_result_dco; use flutter_rust_bridge::{Handler, IntoIntoDart}; @@ -31,7 +30,7 @@ flutter_rust_bridge::frb_generated_boilerplate!( default_rust_opaque = RustOpaqueMoi, default_rust_auto_opaque = RustAutoOpaqueMoi, ); -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.33"; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.34"; pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -957330701; // Section: executor @@ -40,7 +39,7 @@ flutter_rust_bridge::frb_generated_default_handler!(); // Section: wire_funcs -fn wire_init_app_impl( +fn wire__crate__api__minimal__init_app_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, @@ -71,7 +70,7 @@ fn wire_init_app_impl( }, ) } -fn wire_minimal_adder_impl( +fn wire__crate__api__minimal__minimal_adder_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, @@ -104,38 +103,59 @@ fn wire_minimal_adder_impl( }, ) } -fn wire_rust_function_impl( +fn wire__crate__api__minimal__rust_function_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, data_len_: i32, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_function", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { - let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; - let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_dart_callback = decode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { - transform_result_sse((move || async move { - Result::<_,()>::Ok(crate::api::minimal::rust_function(api_dart_callback).await) - })().await) - } }) + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "rust_function", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_dart_callback = decode_DartFn_Inputs_String_Output_String( + ::sse_decode(&mut deserializer), + ); + deserializer.end(); + move |context| async move { + transform_result_sse( + (move || async move { + Result::<_, ()>::Ok( + crate::api::minimal::rust_function(api_dart_callback).await, + ) + })() + .await, + ) + } + }, + ) } // Section: related_funcs -fn decode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( +fn decode_DartFn_Inputs_String_Output_String( dart_opaque: flutter_rust_bridge::DartOpaque, -) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture> { +) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture { use flutter_rust_bridge::IntoDart; - async fn body( - dart_opaque: flutter_rust_bridge::DartOpaque, - arg0: String, - ) -> Result { + async fn body(dart_opaque: flutter_rust_bridge::DartOpaque, arg0: String) -> String { let args = vec![arg0.into_into_dart().into_dart()]; let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - >::sse_decode_single(message) + ::sse_decode_single(message) } move |arg0: String| { @@ -145,22 +165,9 @@ fn decode_DartFn_Inputs_String_Output_Auto_Owned_RustOpaque_flutter_rust_bridgef )) } } -flutter_rust_bridge::frb_generated_moi_arc_impl_value!( - flutter_rust_bridge::for_generated::RustAutoOpaqueInner> -); // Section: dart2rust -impl SseDecode for Result { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - let mut inner = >, - >>::sse_decode(deserializer); - return inner.rust_auto_opaque_decode_owned(); - } -} - impl SseDecode for flutter_rust_bridge::DartOpaque { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -169,16 +176,6 @@ impl SseDecode for flutter_rust_bridge::DartOpaque { } } -impl SseDecode - for RustOpaqueMoi>> -{ - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - let mut inner = ::sse_decode(deserializer); - return decode_rust_opaque_moi(inner); - } -} - impl SseDecode for String { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -241,9 +238,9 @@ fn pde_ffi_dispatcher_primary_impl( ) { // Codec=Pde (Serialization + dispatch), see doc to use other codecs match func_id { - 1 => wire_init_app_impl(port, ptr, rust_vec_len, data_len), - 2 => wire_minimal_adder_impl(port, ptr, rust_vec_len, data_len), - 3 => wire_rust_function_impl(port, ptr, rust_vec_len, data_len), + 1 => wire__crate__api__minimal__init_app_impl(port, ptr, rust_vec_len, data_len), + 2 => wire__crate__api__minimal__minimal_adder_impl(port, ptr, rust_vec_len, data_len), + 3 => wire__crate__api__minimal__rust_function_impl(port, ptr, rust_vec_len, data_len), _ => unreachable!(), } } @@ -262,31 +259,6 @@ fn pde_ffi_dispatcher_sync_impl( // Section: rust2dart -// Codec=Dco (DartCObject based), see doc to use other codecs -impl flutter_rust_bridge::IntoDart for FrbWrapper> { - fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { - flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0) - .into_dart() - } -} -impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive - for FrbWrapper> -{ -} - -impl flutter_rust_bridge::IntoIntoDart>> for Result { - fn into_into_dart(self) -> FrbWrapper> { - self.into() - } -} - -impl SseEncode for Result { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - >>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer); - } -} - impl SseEncode for flutter_rust_bridge::DartOpaque { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -294,17 +266,6 @@ impl SseEncode for flutter_rust_bridge::DartOpaque { } } -impl SseEncode - for RustOpaqueMoi>> -{ - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - let (ptr, size) = self.sse_encode_raw(); - ::sse_encode(ptr, serializer); - ::sse_encode(size, serializer); - } -} - impl SseEncode for String { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { diff --git a/frb_example/dart_minimal/rust/src/frb_generated.web.rs b/frb_example/dart_minimal/rust/src/frb_generated.web.rs index 7b30ec2b0c..0933bd5b42 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.web.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.web.rs @@ -4,7 +4,6 @@ // Section: imports use super::*; -use crate::api::minimal::*; use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt}; use flutter_rust_bridge::for_generated::transform_result_dco; use flutter_rust_bridge::for_generated::wasm_bindgen; @@ -14,17 +13,3 @@ use flutter_rust_bridge::{Handler, IntoIntoDart}; // Section: boilerplate flutter_rust_bridge::frb_generated_boilerplate_web!(); - -#[wasm_bindgen] -pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ptr: *const std::ffi::c_void, -) { - MoiArc::>>::increment_strong_count(ptr as _); -} - -#[wasm_bindgen] -pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerResultStringu32( - ptr: *const std::ffi::c_void, -) { - MoiArc::>>::decrement_strong_count(ptr as _); -} From 2ddf2a3abfc39a13cd0a19693b265ae06c89ef9d Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:38:33 +0800 Subject: [PATCH 11/94] refactor: mv --- frb_codegen/src/library/codegen/ir/func.rs | 8 ++------ frb_codegen/src/library/codegen/ir/mod.rs | 1 + frb_codegen/src/library/codegen/ir/result.rs | 9 +++++++++ .../src/library/codegen/parser/function_parser/mod.rs | 5 +++-- .../src/library/codegen/parser/function_parser/output.rs | 2 -- 5 files changed, 15 insertions(+), 10 deletions(-) create mode 100644 frb_codegen/src/library/codegen/ir/result.rs diff --git a/frb_codegen/src/library/codegen/ir/func.rs b/frb_codegen/src/library/codegen/ir/func.rs index 3137a6a29c..ae48eb8ab1 100644 --- a/frb_codegen/src/library/codegen/ir/func.rs +++ b/frb_codegen/src/library/codegen/ir/func.rs @@ -2,6 +2,7 @@ use crate::codegen::generator::codec::structs::CodecModePack; use crate::codegen::ir::comment::IrComment; use crate::codegen::ir::field::IrField; use crate::codegen::ir::namespace::NamespacedName; +use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::delegate::{IrTypeDelegate, IrTypeDelegatePrimitiveEnum}; use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::{IrContext, IrType, IrTypeTrait}; @@ -14,7 +15,7 @@ pub struct IrFunc { pub name: NamespacedName, pub id: i32, pub inputs: Vec, - pub output: IrFuncOutput, + pub output: IrMaybeResult, pub owner: IrFuncOwnerInfo, pub mode: IrFuncMode, pub stream_dart_await: bool, @@ -34,11 +35,6 @@ pub struct IrFuncInput { pub inner: IrField, } -pub struct IrFuncOutput { - pub normal: IrType, - pub error: Option, -} - #[derive(Copy)] pub enum IrFuncMode { Normal, diff --git a/frb_codegen/src/library/codegen/ir/mod.rs b/frb_codegen/src/library/codegen/ir/mod.rs index 40bb38b845..c1c6d1cf1d 100644 --- a/frb_codegen/src/library/codegen/ir/mod.rs +++ b/frb_codegen/src/library/codegen/ir/mod.rs @@ -7,5 +7,6 @@ pub(crate) mod ident; pub(crate) mod import; pub(crate) mod namespace; pub(crate) mod pack; +pub(crate) mod result; pub(crate) mod ty; mod utils; diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs new file mode 100644 index 0000000000..290c309185 --- /dev/null +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -0,0 +1,9 @@ +use crate::codegen::ir::ty::IrType; + +crate::ir! { +/// A `Result` or a direct type `T` +pub(crate) struct IrMaybeResult { + pub(crate) normal: IrType, + pub(crate) error: Option, +} +} diff --git a/frb_codegen/src/library/codegen/parser/function_parser/mod.rs b/frb_codegen/src/library/codegen/parser/function_parser/mod.rs index 94c5d2458b..58d86457c1 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/mod.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/mod.rs @@ -1,9 +1,10 @@ use crate::codegen::generator::codec::structs::{CodecMode, CodecModePack}; use crate::codegen::ir::func::{ - IrFunc, IrFuncInput, IrFuncMode, IrFuncOutput, IrFuncOwnerInfo, IrFuncOwnerInfoMethod, + IrFunc, IrFuncInput, IrFuncMode, IrFuncOwnerInfo, IrFuncOwnerInfoMethod, IrFuncOwnerInfoMethodMode, }; use crate::codegen::ir::namespace::{Namespace, NamespacedName}; +use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::rust_opaque::RustOpaqueCodecMode; use crate::codegen::ir::ty::IrType; @@ -114,7 +115,7 @@ impl<'a, 'b> FunctionParser<'a, 'b> { name: NamespacedName::new(namespace, func_name), id: func_id, inputs: info.inputs, - output: IrFuncOutput { + output: IrMaybeResult { normal: info.ok_output.unwrap_or(Primitive(IrTypePrimitive::Unit)), error: info.error_output, }, diff --git a/frb_codegen/src/library/codegen/parser/function_parser/output.rs b/frb_codegen/src/library/codegen/parser/function_parser/output.rs index 75d4e8277e..f3d2f08fba 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/output.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/output.rs @@ -1,10 +1,8 @@ use crate::codegen::ir::ty::delegate::IrTypeDelegate; use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::IrType; -use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; use crate::codegen::parser::function_parser::{FunctionParser, FunctionPartialInfo}; use crate::codegen::parser::type_parser::result::parse_type_maybe_result; -use crate::codegen::parser::type_parser::unencodable::splay_segments; use crate::codegen::parser::type_parser::TypeParserParsingContext; use syn::*; From e8f72e66db317271f5c6122cf67b19c9e8980658 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:40:28 +0800 Subject: [PATCH 12/94] feat: IrTypeDartFn.output --- frb_codegen/src/library/codegen/ir/ty/dart_fn.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs index 2caef58885..46d213dc08 100644 --- a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs @@ -1,3 +1,4 @@ +use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::dart_opaque::IrTypeDartOpaque; use crate::codegen::ir::ty::{IrContext, IrType, IrTypeTrait}; use itertools::Itertools; @@ -5,8 +6,7 @@ use itertools::Itertools; crate::ir! { pub struct IrTypeDartFn { pub inputs: Vec, - pub ok_output: Box, - pub error_output: Option>, + pub output: Box, } } From 1b7bd408bbdd5b56b355d73a971f2fd91abe5c27 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:41:56 +0800 Subject: [PATCH 13/94] feat: visit types --- frb_codegen/src/library/codegen/ir/result.rs | 15 ++++++++++++++- frb_codegen/src/library/codegen/ir/ty/dart_fn.rs | 2 +- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index 290c309185..21cd2425a2 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -1,4 +1,4 @@ -use crate::codegen::ir::ty::IrType; +use crate::codegen::ir::ty::{IrContext, IrType}; crate::ir! { /// A `Result` or a direct type `T` @@ -7,3 +7,16 @@ pub(crate) struct IrMaybeResult { pub(crate) error: Option, } } + +impl IrMaybeResult { + pub(crate) fn visit_types bool>( + &self, + f: &mut F, + ir_context: &impl IrContext, + ) { + self.normal.visit_types(f, ir_context); + if let Some(error) = &self.error { + error.visit_types(f, ir_context); + } + } +} diff --git a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs index 46d213dc08..e7aaaf1fa3 100644 --- a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs @@ -21,7 +21,7 @@ impl IrTypeTrait for IrTypeDartFn { for x in &self.inputs { x.visit_types(f, ir_context); } - self.ok_output.visit_types(f, ir_context); + self.output.visit_types(f, ir_context); } fn safe_ident(&self) -> String { From 9546b1eeb6243d936420c4850612280a66cb9cf1 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:43:02 +0800 Subject: [PATCH 14/94] feat: more --- .../src/library/codegen/parser/type_parser/dart_fn.rs | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 065e13e97d..6f66a299b1 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -1,3 +1,4 @@ +use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; use crate::codegen::ir::ty::IrType; use crate::codegen::parser::type_parser::result::{parse_type_maybe_result, ResultTypeInfo}; @@ -46,8 +47,10 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { return Ok(IrType::DartFn(IrTypeDartFn { inputs, - ok_output: Box::new(ok_output), - error_output: error_output.map(Box::new), + output: Box::new(IrMaybeResult { + normal: ok_output, + error: error_output, + }), })); // This will stop the whole generator and tell the users, so we do not care about testing it From d5a08744ab9c497ed0b1da53a6b4b56322ddeea3 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:43:31 +0800 Subject: [PATCH 15/94] refactor: rm ResultTypeInfo --- .../codegen/parser/function_parser/output.rs | 4 +-- .../codegen/parser/type_parser/dart_fn.rs | 14 +++------- .../codegen/parser/type_parser/result.rs | 28 ++++++++----------- 3 files changed, 18 insertions(+), 28 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/function_parser/output.rs b/frb_codegen/src/library/codegen/parser/function_parser/output.rs index f3d2f08fba..92305b0ff9 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/output.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/output.rs @@ -29,8 +29,8 @@ impl<'a, 'b> FunctionParser<'a, 'b> { let ir = self.type_parser.parse_type(ty, context)?; let info = parse_type_maybe_result(&ir, self.type_parser, context)?; Ok(FunctionPartialInfo { - ok_output: Some(info.ok_output), - error_output: info.error_output, + ok_output: Some(info.normal), + error_output: info.error, ..Default::default() }) } diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 6f66a299b1..c97569bb99 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -1,7 +1,7 @@ use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; use crate::codegen::ir::ty::IrType; -use crate::codegen::parser::type_parser::result::{parse_type_maybe_result, ResultTypeInfo}; +use crate::codegen::parser::type_parser::result::parse_type_maybe_result; use crate::codegen::parser::type_parser::TypeParserWithContext; use crate::if_then_some; use anyhow::{bail, Context}; @@ -40,17 +40,11 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .map(|x| self.parse_type(x)) .collect::>>()?; - let ResultTypeInfo { - ok_output, - error_output, - } = self.parse_dart_fn_output(&arguments.output)?; + let output = self.parse_dart_fn_output(&arguments.output)?; return Ok(IrType::DartFn(IrTypeDartFn { inputs, - output: Box::new(IrMaybeResult { - normal: ok_output, - error: error_output, - }), + output: Box::new(output), })); // This will stop the whole generator and tell the users, so we do not care about testing it @@ -63,7 +57,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { // the function signature is not covered while the whole body is covered - looks like a bug in coverage tool // frb-coverage:ignore-start - fn parse_dart_fn_output(&mut self, return_type: &ReturnType) -> anyhow::Result { + fn parse_dart_fn_output(&mut self, return_type: &ReturnType) -> anyhow::Result { // frb-coverage:ignore-end if let ReturnType::Type(_, ret_ty) = return_type { if let Type::Path(TypePath { ref path, .. }) = **ret_ty { diff --git a/frb_codegen/src/library/codegen/parser/type_parser/result.rs b/frb_codegen/src/library/codegen/parser/type_parser/result.rs index 0f7aa16bd3..37559514e4 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/result.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/result.rs @@ -1,3 +1,4 @@ +use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::delegate::IrTypeDelegate; use crate::codegen::ir::ty::IrType; use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; @@ -8,7 +9,7 @@ pub(crate) fn parse_type_maybe_result( ir: &IrType, type_parser: &mut TypeParser, context: &TypeParserParsingContext, -) -> anyhow::Result { +) -> anyhow::Result { if let IrType::RustAutoOpaque(inner) = ir { match splay_segments(&inner.raw.segments).last() { Some(("Result", args)) => { @@ -22,14 +23,14 @@ pub(crate) fn parse_type_maybe_result( } } - Ok(ResultTypeInfo { - ok_output: ir.clone(), - error_output: None, + Ok(IrMaybeResult { + normal: ir.clone(), + error: None, }) } -fn parse_type_result(args: &[IrType]) -> anyhow::Result { - let ok_output = args.first().unwrap(); +fn parse_type_result(args: &[IrType]) -> anyhow::Result { + let normal = args.first().unwrap(); let is_anyhow = args.len() == 1 || args.iter().any(|x| { @@ -39,25 +40,20 @@ fn parse_type_result(args: &[IrType]) -> anyhow::Result { false }); - let error_output = if is_anyhow { + let error = if is_anyhow { Some(IrType::Delegate(IrTypeDelegate::AnyhowException)) } else { args.last().cloned() }; - let error_output = error_output.map(set_is_exception_flag); + let error = error.map(set_is_exception_flag); - Ok(ResultTypeInfo { - ok_output: ok_output.clone(), - error_output, + Ok(IrMaybeResult { + normal: normal.clone(), + error, }) } -pub(crate) struct ResultTypeInfo { - pub ok_output: IrType, - pub error_output: Option, -} - fn set_is_exception_flag(mut ty: IrType) -> IrType { match &mut ty { StructRef(ref mut inner) => { From b18e17e4aad7960a05427ca571b045e025d77244 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:45:49 +0800 Subject: [PATCH 16/94] feat: safe ident --- frb_codegen/src/library/codegen/ir/result.rs | 8 ++++++++ frb_codegen/src/library/codegen/ir/ty/dart_fn.rs | 2 +- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index 21cd2425a2..0419aaca0a 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -19,4 +19,12 @@ impl IrMaybeResult { error.visit_types(f, ir_context); } } + + pub(crate) fn safe_ident(&self) -> String { + format!( + "{}_{}", + self.normal.safe_ident(), + self.error.map(|x| x.safe_ident()).unwrap_or("None") + ) + } } diff --git a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs index e7aaaf1fa3..1029ea21c6 100644 --- a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs @@ -28,7 +28,7 @@ impl IrTypeTrait for IrTypeDartFn { format!( "DartFn_Inputs_{}_Output_{}", self.inputs.iter().map(|x| x.safe_ident()).join("_"), - self.ok_output.safe_ident() + self.output.safe_ident() ) } From 9906b3f483d92f848cacd69f0a52632f38febabe Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:46:19 +0800 Subject: [PATCH 17/94] feat: more --- frb_codegen/src/library/codegen/ir/result.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index 0419aaca0a..a318ab5ab0 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -21,10 +21,10 @@ impl IrMaybeResult { } pub(crate) fn safe_ident(&self) -> String { - format!( - "{}_{}", - self.normal.safe_ident(), - self.error.map(|x| x.safe_ident()).unwrap_or("None") - ) + self.synthesized_type().safe_ident() + } + + pub(crate) fn synthesized_type(&self) -> IrType { + todo!() } } From 2df1b9e97adc16e3cb03aa9307f40435841dce44 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:48:04 +0800 Subject: [PATCH 18/94] feat: more --- .../codegen/generator/api_dart/spec_generator/info.rs | 2 +- .../generator/wire/dart/spec_generator/misc/ty/dart_fn.rs | 2 +- .../generator/wire/rust/spec_generator/misc/ty/dart_fn.rs | 2 +- frb_codegen/src/library/codegen/ir/result.rs | 6 ++++++ 4 files changed, 9 insertions(+), 3 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/info.rs b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/info.rs index f67eb98c36..a60969f3b5 100644 --- a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/info.rs +++ b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/info.rs @@ -30,7 +30,7 @@ impl<'a> ApiDartGeneratorInfoTrait for DartFnApiDartGenerator<'a> { fn dart_api_type(&self) -> String { format!( "FutureOr<{}> Function({})", - ApiDartGenerator::new(self.ir.ok_output.clone(), self.context).dart_api_type(), + ApiDartGenerator::new(self.ir.output.normal.clone(), self.context).dart_api_type(), (self.ir.inputs.iter()) .map(|x| ApiDartGenerator::new(x.clone(), self.context).dart_api_type()) .join(", "), diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index 4bb31a083d..e6b814c2f3 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -25,7 +25,7 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { let dart_api_type = ApiDartGenerator::new(self.ir.clone(), self.context.as_api_dart_context()) .dart_api_type(); - let return_type_safe_ident = self.ir.ok_output.safe_ident(); + let return_type_safe_ident = self.ir.output.synthesized_type().safe_ident(); let api_impl_body = format!( " diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index f4f6643da4..f8342af47c 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -22,7 +22,7 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { .map(|i| format!("arg{i}.into_into_dart().into_dart(),")) .join(""); - let return_type = self.ir.ok_output.rust_api_type(); + let return_type = self.ir.output.rust_api_type(); Acc::new_common( format!( diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index a318ab5ab0..78984afec1 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -1,4 +1,5 @@ use crate::codegen::ir::ty::{IrContext, IrType}; +use crate::library::codegen::ir::ty::IrTypeTrait; crate::ir! { /// A `Result` or a direct type `T` @@ -27,4 +28,9 @@ impl IrMaybeResult { pub(crate) fn synthesized_type(&self) -> IrType { todo!() } + + // TODO maybe move + pub(crate) fn rust_api_type(&self) -> String { + todo!() + } } From ce3399ace99d019e2c2e953de19797ff44f1344c Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:49:39 +0800 Subject: [PATCH 19/94] chore: rename --- .../generator/wire/dart/spec_generator/misc/ty/dart_fn.rs | 2 +- frb_codegen/src/library/codegen/ir/result.rs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index e6b814c2f3..01471d572e 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -25,7 +25,7 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { let dart_api_type = ApiDartGenerator::new(self.ir.clone(), self.context.as_api_dart_context()) .dart_api_type(); - let return_type_safe_ident = self.ir.output.synthesized_type().safe_ident(); + let return_type_safe_ident = self.ir.output.inner_type().safe_ident(); let api_impl_body = format!( " diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index 78984afec1..0fb11f45c1 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -22,10 +22,10 @@ impl IrMaybeResult { } pub(crate) fn safe_ident(&self) -> String { - self.synthesized_type().safe_ident() + self.inner_type().safe_ident() } - pub(crate) fn synthesized_type(&self) -> IrType { + pub(crate) fn inner_type(&self) -> IrType { todo!() } From 4bc4a030f8df9c0c391eb89c8cb5f659e3c67c97 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:52:09 +0800 Subject: [PATCH 20/94] chore: mv --- frb_codegen/src/library/codegen/ir/mod.rs | 1 - frb_codegen/src/library/codegen/ir/ty/mod.rs | 1 + frb_codegen/src/library/codegen/ir/{ => ty}/result.rs | 0 3 files changed, 1 insertion(+), 1 deletion(-) rename frb_codegen/src/library/codegen/ir/{ => ty}/result.rs (100%) diff --git a/frb_codegen/src/library/codegen/ir/mod.rs b/frb_codegen/src/library/codegen/ir/mod.rs index c1c6d1cf1d..40bb38b845 100644 --- a/frb_codegen/src/library/codegen/ir/mod.rs +++ b/frb_codegen/src/library/codegen/ir/mod.rs @@ -7,6 +7,5 @@ pub(crate) mod ident; pub(crate) mod import; pub(crate) mod namespace; pub(crate) mod pack; -pub(crate) mod result; pub(crate) mod ty; mod utils; diff --git a/frb_codegen/src/library/codegen/ir/ty/mod.rs b/frb_codegen/src/library/codegen/ir/ty/mod.rs index 751a96efa3..1b267869be 100644 --- a/frb_codegen/src/library/codegen/ir/ty/mod.rs +++ b/frb_codegen/src/library/codegen/ir/ty/mod.rs @@ -9,6 +9,7 @@ pub(crate) mod optional; pub(crate) mod primitive; pub(crate) mod primitive_list; pub(crate) mod record; +pub(crate) mod result; pub(crate) mod rust_auto_opaque; pub(crate) mod rust_opaque; pub(crate) mod structure; diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/ty/result.rs similarity index 100% rename from frb_codegen/src/library/codegen/ir/result.rs rename to frb_codegen/src/library/codegen/ir/ty/result.rs From c37b1a4935e3b9ede3ba3ab60aa06fca1fbd2fc4 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:53:16 +0800 Subject: [PATCH 21/94] Revert "chore: mv" This reverts commit 4bc4a030f8df9c0c391eb89c8cb5f659e3c67c97. --- frb_codegen/src/library/codegen/ir/mod.rs | 1 + frb_codegen/src/library/codegen/ir/{ty => }/result.rs | 0 frb_codegen/src/library/codegen/ir/ty/mod.rs | 1 - 3 files changed, 1 insertion(+), 1 deletion(-) rename frb_codegen/src/library/codegen/ir/{ty => }/result.rs (100%) diff --git a/frb_codegen/src/library/codegen/ir/mod.rs b/frb_codegen/src/library/codegen/ir/mod.rs index 40bb38b845..c1c6d1cf1d 100644 --- a/frb_codegen/src/library/codegen/ir/mod.rs +++ b/frb_codegen/src/library/codegen/ir/mod.rs @@ -7,5 +7,6 @@ pub(crate) mod ident; pub(crate) mod import; pub(crate) mod namespace; pub(crate) mod pack; +pub(crate) mod result; pub(crate) mod ty; mod utils; diff --git a/frb_codegen/src/library/codegen/ir/ty/result.rs b/frb_codegen/src/library/codegen/ir/result.rs similarity index 100% rename from frb_codegen/src/library/codegen/ir/ty/result.rs rename to frb_codegen/src/library/codegen/ir/result.rs diff --git a/frb_codegen/src/library/codegen/ir/ty/mod.rs b/frb_codegen/src/library/codegen/ir/ty/mod.rs index 1b267869be..751a96efa3 100644 --- a/frb_codegen/src/library/codegen/ir/ty/mod.rs +++ b/frb_codegen/src/library/codegen/ir/ty/mod.rs @@ -9,7 +9,6 @@ pub(crate) mod optional; pub(crate) mod primitive; pub(crate) mod primitive_list; pub(crate) mod record; -pub(crate) mod result; pub(crate) mod rust_auto_opaque; pub(crate) mod rust_opaque; pub(crate) mod structure; From 638f2ef096013d3e644fa897ea8fa43ed13f7132 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:54:19 +0800 Subject: [PATCH 22/94] Revert "refactor: rm ResultTypeInfo" This reverts commit d5a08744ab9c497ed0b1da53a6b4b56322ddeea3. --- .../codegen/parser/function_parser/output.rs | 4 +-- .../codegen/parser/type_parser/dart_fn.rs | 14 +++++++--- .../codegen/parser/type_parser/result.rs | 28 +++++++++++-------- 3 files changed, 28 insertions(+), 18 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/function_parser/output.rs b/frb_codegen/src/library/codegen/parser/function_parser/output.rs index 92305b0ff9..f3d2f08fba 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/output.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/output.rs @@ -29,8 +29,8 @@ impl<'a, 'b> FunctionParser<'a, 'b> { let ir = self.type_parser.parse_type(ty, context)?; let info = parse_type_maybe_result(&ir, self.type_parser, context)?; Ok(FunctionPartialInfo { - ok_output: Some(info.normal), - error_output: info.error, + ok_output: Some(info.ok_output), + error_output: info.error_output, ..Default::default() }) } diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index c97569bb99..6f66a299b1 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -1,7 +1,7 @@ use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; use crate::codegen::ir::ty::IrType; -use crate::codegen::parser::type_parser::result::parse_type_maybe_result; +use crate::codegen::parser::type_parser::result::{parse_type_maybe_result, ResultTypeInfo}; use crate::codegen::parser::type_parser::TypeParserWithContext; use crate::if_then_some; use anyhow::{bail, Context}; @@ -40,11 +40,17 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .map(|x| self.parse_type(x)) .collect::>>()?; - let output = self.parse_dart_fn_output(&arguments.output)?; + let ResultTypeInfo { + ok_output, + error_output, + } = self.parse_dart_fn_output(&arguments.output)?; return Ok(IrType::DartFn(IrTypeDartFn { inputs, - output: Box::new(output), + output: Box::new(IrMaybeResult { + normal: ok_output, + error: error_output, + }), })); // This will stop the whole generator and tell the users, so we do not care about testing it @@ -57,7 +63,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { // the function signature is not covered while the whole body is covered - looks like a bug in coverage tool // frb-coverage:ignore-start - fn parse_dart_fn_output(&mut self, return_type: &ReturnType) -> anyhow::Result { + fn parse_dart_fn_output(&mut self, return_type: &ReturnType) -> anyhow::Result { // frb-coverage:ignore-end if let ReturnType::Type(_, ret_ty) = return_type { if let Type::Path(TypePath { ref path, .. }) = **ret_ty { diff --git a/frb_codegen/src/library/codegen/parser/type_parser/result.rs b/frb_codegen/src/library/codegen/parser/type_parser/result.rs index 37559514e4..0f7aa16bd3 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/result.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/result.rs @@ -1,4 +1,3 @@ -use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::delegate::IrTypeDelegate; use crate::codegen::ir::ty::IrType; use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; @@ -9,7 +8,7 @@ pub(crate) fn parse_type_maybe_result( ir: &IrType, type_parser: &mut TypeParser, context: &TypeParserParsingContext, -) -> anyhow::Result { +) -> anyhow::Result { if let IrType::RustAutoOpaque(inner) = ir { match splay_segments(&inner.raw.segments).last() { Some(("Result", args)) => { @@ -23,14 +22,14 @@ pub(crate) fn parse_type_maybe_result( } } - Ok(IrMaybeResult { - normal: ir.clone(), - error: None, + Ok(ResultTypeInfo { + ok_output: ir.clone(), + error_output: None, }) } -fn parse_type_result(args: &[IrType]) -> anyhow::Result { - let normal = args.first().unwrap(); +fn parse_type_result(args: &[IrType]) -> anyhow::Result { + let ok_output = args.first().unwrap(); let is_anyhow = args.len() == 1 || args.iter().any(|x| { @@ -40,20 +39,25 @@ fn parse_type_result(args: &[IrType]) -> anyhow::Result { false }); - let error = if is_anyhow { + let error_output = if is_anyhow { Some(IrType::Delegate(IrTypeDelegate::AnyhowException)) } else { args.last().cloned() }; - let error = error.map(set_is_exception_flag); + let error_output = error_output.map(set_is_exception_flag); - Ok(IrMaybeResult { - normal: normal.clone(), - error, + Ok(ResultTypeInfo { + ok_output: ok_output.clone(), + error_output, }) } +pub(crate) struct ResultTypeInfo { + pub ok_output: IrType, + pub error_output: Option, +} + fn set_is_exception_flag(mut ty: IrType) -> IrType { match &mut ty { StructRef(ref mut inner) => { From 0405d3c689593f9437e8aede305ad88e18897f31 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:54:36 +0800 Subject: [PATCH 23/94] chore: lint --- frb_codegen/src/library/codegen/parser/function_parser/output.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/parser/function_parser/output.rs b/frb_codegen/src/library/codegen/parser/function_parser/output.rs index f3d2f08fba..29558cdd10 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/output.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/output.rs @@ -1,4 +1,3 @@ -use crate::codegen::ir::ty::delegate::IrTypeDelegate; use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::IrType; use crate::codegen::parser::function_parser::{FunctionParser, FunctionPartialInfo}; From cc65aa7b84c01ecdfd5a9a159e04634c3f082fd9 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:55:46 +0800 Subject: [PATCH 24/94] feat: field --- frb_codegen/src/library/codegen/ir/result.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index 0fb11f45c1..ffc6be5c4b 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -6,6 +6,8 @@ crate::ir! { pub(crate) struct IrMaybeResult { pub(crate) normal: IrType, pub(crate) error: Option, + /// Combines `normal` and `error` into a new synthesized type + pub(crate) delegate: IrType, } } @@ -25,10 +27,6 @@ impl IrMaybeResult { self.inner_type().safe_ident() } - pub(crate) fn inner_type(&self) -> IrType { - todo!() - } - // TODO maybe move pub(crate) fn rust_api_type(&self) -> String { todo!() From 00b67f19df8e41709c1017539d8f61b5c8bc9554 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:56:33 +0800 Subject: [PATCH 25/94] feat: more --- .../generator/wire/dart/spec_generator/misc/ty/dart_fn.rs | 2 +- frb_codegen/src/library/codegen/ir/result.rs | 2 +- frb_codegen/src/library/codegen/parser/function_parser/mod.rs | 2 ++ frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs | 1 + 4 files changed, 5 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index 01471d572e..a1de06d996 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -25,7 +25,7 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { let dart_api_type = ApiDartGenerator::new(self.ir.clone(), self.context.as_api_dart_context()) .dart_api_type(); - let return_type_safe_ident = self.ir.output.inner_type().safe_ident(); + let return_type_safe_ident = self.ir.output.delegate.safe_ident(); let api_impl_body = format!( " diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index ffc6be5c4b..7b1196534e 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -24,7 +24,7 @@ impl IrMaybeResult { } pub(crate) fn safe_ident(&self) -> String { - self.inner_type().safe_ident() + self.delegate.safe_ident() } // TODO maybe move diff --git a/frb_codegen/src/library/codegen/parser/function_parser/mod.rs b/frb_codegen/src/library/codegen/parser/function_parser/mod.rs index 58d86457c1..cc8494d519 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/mod.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/mod.rs @@ -118,6 +118,8 @@ impl<'a, 'b> FunctionParser<'a, 'b> { output: IrMaybeResult { normal: info.ok_output.unwrap_or(Primitive(IrTypePrimitive::Unit)), error: info.error_output, + // Not used yet, thus give it a dummy type + delegate: IrType::Primitive(IrTypePrimitive::I32), }, owner, mode, diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 6f66a299b1..1d887f1fed 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -50,6 +50,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { output: Box::new(IrMaybeResult { normal: ok_output, error: error_output, + delegate: TODO, }), })); From 7b8187619f6398200ccd65758d798ee6c8c14c58 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 10:58:23 +0800 Subject: [PATCH 26/94] feat: more --- .../codegen/parser/type_parser/dart_fn.rs | 20 ++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 1d887f1fed..57e039800d 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -40,18 +40,11 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .map(|x| self.parse_type(x)) .collect::>>()?; - let ResultTypeInfo { - ok_output, - error_output, - } = self.parse_dart_fn_output(&arguments.output)?; + let output = self.parse_dart_fn_output(&arguments.output)?; return Ok(IrType::DartFn(IrTypeDartFn { inputs, - output: Box::new(IrMaybeResult { - normal: ok_output, - error: error_output, - delegate: TODO, - }), + output: Box::new(self.create_ir_maybe_result(output)), })); // This will stop the whole generator and tell the users, so we do not care about testing it @@ -93,6 +86,15 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { bail!("DartFn does not support return types except `DartFnFuture` yet") // frb-coverage:ignore-end } + + fn create_ir_maybe_result(&mut self, info: ResultTypeInfo) -> IrMaybeResult{ + let delegate = TODO; + IrMaybeResult { + normal: info.ok_output, + error: info.error_output, + delegate, + } + } } // // Use this unit "test" to see how a type will be parsed into a tree From 85f4a89ec4a1032036b0c9220968439f491b2bb7 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 11:02:18 +0800 Subject: [PATCH 27/94] feat: more --- .../codegen/parser/type_parser/dart_fn.rs | 45 ++++++++++++++++++- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 57e039800d..c506c733ee 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -1,5 +1,9 @@ +use crate::codegen::ir::namespace::NamespacedName; use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; +use crate::codegen::ir::ty::enumeration::{ + IrEnum, IrEnumIdent, IrEnumMode, IrTypeEnumRef, IrVariant, IrVariantKind, +}; use crate::codegen::ir::ty::IrType; use crate::codegen::parser::type_parser::result::{parse_type_maybe_result, ResultTypeInfo}; use crate::codegen::parser::type_parser::TypeParserWithContext; @@ -87,8 +91,45 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { // frb-coverage:ignore-end } - fn create_ir_maybe_result(&mut self, info: ResultTypeInfo) -> IrMaybeResult{ - let delegate = TODO; + fn create_ir_maybe_result(&mut self, info: ResultTypeInfo) -> IrMaybeResult { + let namespace = self.context.initiated_namespace.clone(); + + let safe_ident = format!( + "__delegate_Result__{}_{}", + info.ok_output.safe_ident(), + // TODO when no error type + info.error_output.map(|x| x.safe_ident()).unwrap_or("None"), + ); + + self.inner.enum_parser_info.object_pool.insert( + IrEnumIdent(NamespacedName::new(namespace.clone(), safe_ident.clone())), + IrEnum { + name: NamespacedName::new(namespace.clone(), safe_ident.clone()), + wrapper_name: None, + comments: vec![], + mode: IrEnumMode::Complex, + variants: vec![ + IrVariant { + name: "ok", + wrapper_name: None, + comments: vec![], + kind: IrVariantKind::Struct(TODO), + }, + IrVariant { + name: "err", + wrapper_name: None, + comments: vec![], + kind: IrVariantKind::Struct(TODO), + }, + ], + }, + ); + + let delegate = IrType::EnumRef(IrTypeEnumRef { + ident: IrEnumIdent(NamespacedName::new(namespace, safe_ident)), + is_exception: false, + }); + IrMaybeResult { normal: info.ok_output, error: info.error_output, From 90402f604f23df757e25762aa8cadcffa9facf82 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 11:04:44 +0800 Subject: [PATCH 28/94] feat: more --- .../codegen/parser/type_parser/dart_fn.rs | 21 ++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index c506c733ee..bb1d45ce4f 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -1,3 +1,5 @@ +use crate::codegen::ir::field::IrField; +use crate::codegen::ir::ident::IrIdent; use crate::codegen::ir::namespace::NamespacedName; use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; @@ -113,7 +115,24 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { name: "ok", wrapper_name: None, comments: vec![], - kind: IrVariantKind::Struct(TODO), + kind: IrVariantKind::Struct(IrStruct { + name: TODO, + wrapper_name: None, + is_fields_named: true, + dart_metadata: vec![], + ignore: false, + generate_hash: false, + generate_eq: false, + comments: vec![], + fields: vec![IrField { + ty: TODO, + name: IrIdent::new("value".to_owned()), + is_final: true, + comments: vec![], + default: None, + settings: Default::default(), + }], + }), }, IrVariant { name: "err", From c4fd96aa772f962319a1dfc13da47aa4eb898b21 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 11:06:30 +0800 Subject: [PATCH 29/94] feat: more --- .../codegen/parser/type_parser/dart_fn.rs | 61 +++++++++---------- 1 file changed, 30 insertions(+), 31 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index bb1d45ce4f..b35e880003 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -6,6 +6,7 @@ use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; use crate::codegen::ir::ty::enumeration::{ IrEnum, IrEnumIdent, IrEnumMode, IrTypeEnumRef, IrVariant, IrVariantKind, }; +use crate::codegen::ir::ty::structure::IrStruct; use crate::codegen::ir::ty::IrType; use crate::codegen::parser::type_parser::result::{parse_type_maybe_result, ResultTypeInfo}; use crate::codegen::parser::type_parser::TypeParserWithContext; @@ -99,8 +100,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { let safe_ident = format!( "__delegate_Result__{}_{}", info.ok_output.safe_ident(), - // TODO when no error type - info.error_output.map(|x| x.safe_ident()).unwrap_or("None"), + info.error_output.safe_ident(), ); self.inner.enum_parser_info.object_pool.insert( @@ -111,35 +111,8 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { comments: vec![], mode: IrEnumMode::Complex, variants: vec![ - IrVariant { - name: "ok", - wrapper_name: None, - comments: vec![], - kind: IrVariantKind::Struct(IrStruct { - name: TODO, - wrapper_name: None, - is_fields_named: true, - dart_metadata: vec![], - ignore: false, - generate_hash: false, - generate_eq: false, - comments: vec![], - fields: vec![IrField { - ty: TODO, - name: IrIdent::new("value".to_owned()), - is_final: true, - comments: vec![], - default: None, - settings: Default::default(), - }], - }), - }, - IrVariant { - name: "err", - wrapper_name: None, - comments: vec![], - kind: IrVariantKind::Struct(TODO), - }, + create_enum_variant("ok", info.ok_output.clone()), + create_enum_variant("err", info.error_output.clone()), ], }, ); @@ -157,6 +130,32 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { } } +fn create_enum_variant(name: &str, ty: IrType) -> IrVariant { + IrVariant { + name: IrIdent::new(name.to_owned()), + wrapper_name: None, + comments: vec![], + kind: IrVariantKind::Struct(IrStruct { + name: IrIdent::new(name.to_owned()), + wrapper_name: None, + is_fields_named: true, + dart_metadata: vec![], + ignore: false, + generate_hash: false, + generate_eq: false, + comments: vec![], + fields: vec![IrField { + ty, + name: IrIdent::new("value".to_owned()), + is_final: true, + comments: vec![], + default: None, + settings: Default::default(), + }], + }), + } +} + // // Use this unit "test" to see how a type will be parsed into a tree // #[cfg(test)] // mod tests { From c2843e8a7581df470bded48991607830e4f0511d Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 11:06:53 +0800 Subject: [PATCH 30/94] fix: err --- frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index b35e880003..f1cc8989d2 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -11,6 +11,7 @@ use crate::codegen::ir::ty::IrType; use crate::codegen::parser::type_parser::result::{parse_type_maybe_result, ResultTypeInfo}; use crate::codegen::parser::type_parser::TypeParserWithContext; use crate::if_then_some; +use crate::library::codegen::ir::ty::IrTypeTrait; use anyhow::{bail, Context}; use syn::{ AngleBracketedGenericArguments, GenericArgument, PathArguments, PathSegment, ReturnType, Type, From b797590ded5f7decedc446f122275212718dc75d Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 11:08:28 +0800 Subject: [PATCH 31/94] feat: more --- .../library/codegen/parser/type_parser/dart_fn.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index f1cc8989d2..94e474c5a4 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -1,6 +1,6 @@ use crate::codegen::ir::field::IrField; use crate::codegen::ir::ident::IrIdent; -use crate::codegen::ir::namespace::NamespacedName; +use crate::codegen::ir::namespace::{Namespace, NamespacedName}; use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; use crate::codegen::ir::ty::enumeration::{ @@ -112,8 +112,8 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { comments: vec![], mode: IrEnumMode::Complex, variants: vec![ - create_enum_variant("ok", info.ok_output.clone()), - create_enum_variant("err", info.error_output.clone()), + create_enum_variant(namespace.clone(), "ok", info.ok_output.clone()), + create_enum_variant(namespace.clone(), "err", info.error_output.clone()), ], }, ); @@ -131,13 +131,13 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { } } -fn create_enum_variant(name: &str, ty: IrType) -> IrVariant { +fn create_enum_variant(namespace: Namespace, name: &str, ty: IrType) -> IrVariant { IrVariant { name: IrIdent::new(name.to_owned()), - wrapper_name: None, + wrapper_name: TODO, comments: vec![], kind: IrVariantKind::Struct(IrStruct { - name: IrIdent::new(name.to_owned()), + name: NamespacedName::new(namespace, name.to_owned()), wrapper_name: None, is_fields_named: true, dart_metadata: vec![], From 5aac7d8a4686c380124aabf7cf7c885758d2e77c Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 11:09:24 +0800 Subject: [PATCH 32/94] feat: more --- .../codegen/parser/type_parser/dart_fn.rs | 34 ++++++++++++++----- 1 file changed, 26 insertions(+), 8 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 94e474c5a4..7acbeacf86 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -98,28 +98,41 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { fn create_ir_maybe_result(&mut self, info: ResultTypeInfo) -> IrMaybeResult { let namespace = self.context.initiated_namespace.clone(); - let safe_ident = format!( + let enum_safe_ident = format!( "__delegate_Result__{}_{}", info.ok_output.safe_ident(), info.error_output.safe_ident(), ); self.inner.enum_parser_info.object_pool.insert( - IrEnumIdent(NamespacedName::new(namespace.clone(), safe_ident.clone())), + IrEnumIdent(NamespacedName::new( + namespace.clone(), + enum_safe_ident.clone(), + )), IrEnum { - name: NamespacedName::new(namespace.clone(), safe_ident.clone()), + name: NamespacedName::new(namespace.clone(), enum_safe_ident.clone()), wrapper_name: None, comments: vec![], mode: IrEnumMode::Complex, variants: vec![ - create_enum_variant(namespace.clone(), "ok", info.ok_output.clone()), - create_enum_variant(namespace.clone(), "err", info.error_output.clone()), + create_enum_variant( + namespace.clone(), + &enum_safe_ident, + "ok", + info.ok_output.clone(), + ), + create_enum_variant( + namespace.clone(), + &enum_safe_ident, + "err", + info.error_output.clone(), + ), ], }, ); let delegate = IrType::EnumRef(IrTypeEnumRef { - ident: IrEnumIdent(NamespacedName::new(namespace, safe_ident)), + ident: IrEnumIdent(NamespacedName::new(namespace, enum_safe_ident)), is_exception: false, }); @@ -131,10 +144,15 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { } } -fn create_enum_variant(namespace: Namespace, name: &str, ty: IrType) -> IrVariant { +fn create_enum_variant( + namespace: Namespace, + enum_safe_ident: &str, + name: &str, + ty: IrType, +) -> IrVariant { IrVariant { name: IrIdent::new(name.to_owned()), - wrapper_name: TODO, + wrapper_name: IrIdent::new(format!("{enum_safe_ident}_{name}")), comments: vec![], kind: IrVariantKind::Struct(IrStruct { name: NamespacedName::new(namespace, name.to_owned()), From e01621bb936d61d5207195a41db04564bee0bf11 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 11:10:18 +0800 Subject: [PATCH 33/94] feat: more --- frb_codegen/src/library/codegen/parser/function_parser/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/parser/function_parser/mod.rs b/frb_codegen/src/library/codegen/parser/function_parser/mod.rs index cc8494d519..479057150a 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/mod.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/mod.rs @@ -119,7 +119,7 @@ impl<'a, 'b> FunctionParser<'a, 'b> { normal: info.ok_output.unwrap_or(Primitive(IrTypePrimitive::Unit)), error: info.error_output, // Not used yet, thus give it a dummy type - delegate: IrType::Primitive(IrTypePrimitive::I32), + delegate: IrType::Primitive(IrTypePrimitive::Unit), }, owner, mode, From 649be5cbbbb0a9167588cfcf5891614b656d27bd Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 11:21:35 +0800 Subject: [PATCH 34/94] feat: more --- .../codegen/parser/type_parser/dart_fn.rs | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 7acbeacf86..1f2797a41e 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -49,10 +49,15 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .collect::>>()?; let output = self.parse_dart_fn_output(&arguments.output)?; + let output_delegate = self.create_dart_fn_output_delegate(&output); return Ok(IrType::DartFn(IrTypeDartFn { inputs, - output: Box::new(self.create_ir_maybe_result(output)), + output: Box::new(IrMaybeResult { + normal: output.ok_output, + error: output.error_output, + delegate: output_delegate, + }), })); // This will stop the whole generator and tell the users, so we do not care about testing it @@ -95,7 +100,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { // frb-coverage:ignore-end } - fn create_ir_maybe_result(&mut self, info: ResultTypeInfo) -> IrMaybeResult { + fn create_dart_fn_output_delegate(&mut self, info: &ResultTypeInfo) -> IrType { let namespace = self.context.initiated_namespace.clone(); let enum_safe_ident = format!( @@ -131,16 +136,10 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { }, ); - let delegate = IrType::EnumRef(IrTypeEnumRef { + IrType::EnumRef(IrTypeEnumRef { ident: IrEnumIdent(NamespacedName::new(namespace, enum_safe_ident)), is_exception: false, - }); - - IrMaybeResult { - normal: info.ok_output, - error: info.error_output, - delegate, - } + }) } } From cf982f8a85f1450a6ba8fcc77abc4adc5c41adff Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 11:23:11 +0800 Subject: [PATCH 35/94] feat: more --- .../src/library/codegen/parser/type_parser/dart_fn.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 1f2797a41e..3156f14e0d 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -6,6 +6,7 @@ use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; use crate::codegen::ir::ty::enumeration::{ IrEnum, IrEnumIdent, IrEnumMode, IrTypeEnumRef, IrVariant, IrVariantKind, }; +use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::structure::IrStruct; use crate::codegen::ir::ty::IrType; use crate::codegen::parser::type_parser::result::{parse_type_maybe_result, ResultTypeInfo}; @@ -103,10 +104,13 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { fn create_dart_fn_output_delegate(&mut self, info: &ResultTypeInfo) -> IrType { let namespace = self.context.initiated_namespace.clone(); + let error_output_or_default = + (info.error_output).unwrap_or(IrType::Primitive(IrTypePrimitive::Unit)); + let enum_safe_ident = format!( "__delegate_Result__{}_{}", info.ok_output.safe_ident(), - info.error_output.safe_ident(), + error_output_or_default.safe_ident(), ); self.inner.enum_parser_info.object_pool.insert( @@ -130,7 +134,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { namespace.clone(), &enum_safe_ident, "err", - info.error_output.clone(), + error_output_or_default.clone(), ), ], }, From 953751c01f72868a8736eebd2981194cd336ac3c Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 11:23:28 +0800 Subject: [PATCH 36/94] fix: err --- frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 3156f14e0d..a6e473e5fc 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -105,7 +105,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { let namespace = self.context.initiated_namespace.clone(); let error_output_or_default = - (info.error_output).unwrap_or(IrType::Primitive(IrTypePrimitive::Unit)); + (info.error_output.clone()).unwrap_or(IrType::Primitive(IrTypePrimitive::Unit)); let enum_safe_ident = format!( "__delegate_Result__{}_{}", From 9e6e210324a73266b2b6ce7674c5529140b530a6 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:03:56 +0800 Subject: [PATCH 37/94] feat: more --- frb_codegen/src/library/codegen/ir/result.rs | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index 7b1196534e..29377d4c01 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -27,8 +27,15 @@ impl IrMaybeResult { self.delegate.safe_ident() } - // TODO maybe move pub(crate) fn rust_api_type(&self) -> String { - todo!() + if let Some(error) = &self.error { + format!( + "std::result::Result<{}, {}>", + self.normal.rust_api_type(), + error.rust_api_type() + ) + } else { + self.normal.rust_api_type() + } } } From 4fcc3e5172e518c991f60d92715744c48a5102f4 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:05:58 +0800 Subject: [PATCH 38/94] chore: codegen --- .../lib/src/rust/frb_generated.dart | 36 +++++++++++++++---- .../lib/src/rust/frb_generated.io.dart | 14 ++++++-- .../lib/src/rust/frb_generated.web.dart | 14 ++++++-- .../dart_minimal/rust/src/frb_generated.rs | 27 +++++++++++--- 4 files changed, 75 insertions(+), 16 deletions(-) diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index 986372c8a8..da1f2f40e4 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -142,7 +142,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_String(dartCallback, serializer); + sse_encode_DartFn_Inputs_String_Output_delegate_result_string_u_32( + dartCallback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 3, port: port_); }, @@ -163,15 +164,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["dartCallback"], ); - Future Function(int, dynamic) encode_DartFn_Inputs_String_Output_String( - FutureOr Function(String) raw) { + Future Function(int, dynamic) + encode_DartFn_Inputs_String_Output_delegate_result_string_u_32( + FutureOr Function(String) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_String(rawArg0); final rawOutput = await raw(arg0); final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_String(rawOutput, serializer); + sse_encode_delegate_result_string_u_32(rawOutput, serializer); final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -184,7 +186,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String(dynamic raw) { + dco_decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( + dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @@ -213,6 +216,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return raw as Uint8List; } + @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 @@ -258,6 +267,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return deserializer.buffer.getUint8List(len_); } + @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 @@ -282,11 +297,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void sse_encode_DartFn_Inputs_String_Output_String( + void sse_encode_DartFn_Inputs_String_Output_delegate_result_string_u_32( FutureOr Function(String) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_Output_String(self), serializer); + encode_DartFn_Inputs_String_Output_delegate_result_string_u_32(self), + serializer); } @protected @@ -318,6 +334,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { serializer.buffer.putUint8List(self); } + @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 diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart index 10abc65201..e003096e05 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart @@ -20,7 +20,8 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String(dynamic raw); + dco_decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( + dynamic raw); @protected Object dco_decode_DartOpaque(dynamic raw); @@ -34,6 +35,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); + @protected + int dco_decode_u_32(dynamic raw); + @protected int dco_decode_u_8(dynamic raw); @@ -55,6 +59,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); + @protected + int sse_decode_u_32(SseDeserializer deserializer); + @protected int sse_decode_u_8(SseDeserializer deserializer); @@ -68,7 +75,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { bool sse_decode_bool(SseDeserializer deserializer); @protected - void sse_encode_DartFn_Inputs_String_Output_String( + void sse_encode_DartFn_Inputs_String_Output_delegate_result_string_u_32( FutureOr Function(String) self, SseSerializer serializer); @protected @@ -84,6 +91,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_list_prim_u_8_strict( Uint8List self, SseSerializer serializer); + @protected + void sse_encode_u_32(int self, SseSerializer serializer); + @protected void sse_encode_u_8(int self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart index fe8406189d..2f81107a84 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart @@ -19,7 +19,8 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String(dynamic raw); + dco_decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( + dynamic raw); @protected Object dco_decode_DartOpaque(dynamic raw); @@ -33,6 +34,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); + @protected + int dco_decode_u_32(dynamic raw); + @protected int dco_decode_u_8(dynamic raw); @@ -54,6 +58,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); + @protected + int sse_decode_u_32(SseDeserializer deserializer); + @protected int sse_decode_u_8(SseDeserializer deserializer); @@ -67,7 +74,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { bool sse_decode_bool(SseDeserializer deserializer); @protected - void sse_encode_DartFn_Inputs_String_Output_String( + void sse_encode_DartFn_Inputs_String_Output_delegate_result_string_u_32( FutureOr Function(String) self, SseSerializer serializer); @protected @@ -83,6 +90,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_list_prim_u_8_strict( Uint8List self, SseSerializer serializer); + @protected + void sse_encode_u_32(int self, SseSerializer serializer); + @protected void sse_encode_u_8(int self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index ed077bac83..abe7c23ed1 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -125,7 +125,7 @@ fn wire__crate__api__minimal__rust_function_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_dart_callback = decode_DartFn_Inputs_String_Output_String( + let api_dart_callback = decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( ::sse_decode(&mut deserializer), ); deserializer.end(); @@ -145,17 +145,20 @@ fn wire__crate__api__minimal__rust_function_impl( // Section: related_funcs -fn decode_DartFn_Inputs_String_Output_String( +fn decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( dart_opaque: flutter_rust_bridge::DartOpaque, -) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture { +) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture> { use flutter_rust_bridge::IntoDart; - async fn body(dart_opaque: flutter_rust_bridge::DartOpaque, arg0: String) -> String { + async fn body( + dart_opaque: flutter_rust_bridge::DartOpaque, + arg0: String, + ) -> std::result::Result { let args = vec![arg0.into_into_dart().into_dart()]; let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - ::sse_decode_single(message) + >::sse_decode_single(message) } move |arg0: String| { @@ -203,6 +206,13 @@ impl SseDecode for Vec { } } +impl SseDecode for u32 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_u32::().unwrap() + } +} + impl SseDecode for u8 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -290,6 +300,13 @@ impl SseEncode for Vec { } } +impl SseEncode for u32 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer.cursor.write_u32::(self).unwrap(); + } +} + impl SseEncode for u8 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { From d9dc80c615d9122f35079eab181ac9c72e777434 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:07:35 +0800 Subject: [PATCH 39/94] feat: more --- .../wire/rust/spec_generator/misc/ty/dart_fn.rs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index f8342af47c..420ccd0aac 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -22,19 +22,21 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { .map(|i| format!("arg{i}.into_into_dart().into_dart(),")) .join(""); - let return_type = self.ir.output.rust_api_type(); + let return_type_outer = self.ir.output.rust_api_type(); + let return_type_inner = self.ir.output.delegate.rust_api_type(); Acc::new_common( format!( "fn decode_{safe_ident}( dart_opaque: flutter_rust_bridge::DartOpaque, - ) -> impl Fn({parameter_types}) -> flutter_rust_bridge::DartFnFuture<{return_type}> {{ + ) -> impl Fn({parameter_types}) -> flutter_rust_bridge::DartFnFuture<{return_type_outer}> {{ use flutter_rust_bridge::IntoDart; - async fn body(dart_opaque: flutter_rust_bridge::DartOpaque, {parameter_names_and_types}) -> {return_type} {{ + async fn body(dart_opaque: flutter_rust_bridge::DartOpaque, {parameter_names_and_types}) -> {return_type_outer} {{ let args = vec![{into_dart_expressions}]; let message = {HANDLER_NAME}.dart_fn_invoke(dart_opaque, args).await; - <{return_type}>::sse_decode_single(message) + let decoded = <{return_type_inner}>::sse_decode_single(message); + {TODO} }} move |{parameter_names_and_types}| {{ From a7cd4d507d4fc7489b07a1251153f7bfb7fa501a Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:10:10 +0800 Subject: [PATCH 40/94] feat: more --- .../rust/spec_generator/misc/ty/dart_fn.rs | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index 420ccd0aac..8b200a1ecd 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -2,6 +2,7 @@ use crate::codegen::generator::acc::Acc; use crate::codegen::generator::wire::rust::spec_generator::base::*; use crate::codegen::generator::wire::rust::spec_generator::misc::ty::WireRustGeneratorMiscTrait; use crate::codegen::generator::wire::rust::spec_generator::output_code::WireRustOutputCode; +use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::IrTypeTrait; use crate::library::misc::consts::HANDLER_NAME; use itertools::Itertools; @@ -24,6 +25,7 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { let return_type_outer = self.ir.output.rust_api_type(); let return_type_inner = self.ir.output.delegate.rust_api_type(); + let return_type_inner_to_outer = generate_return_type_inner_to_outer(&self.ir.output); Acc::new_common( format!( @@ -36,7 +38,7 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { let args = vec![{into_dart_expressions}]; let message = {HANDLER_NAME}.dart_fn_invoke(dart_opaque, args).await; let decoded = <{return_type_inner}>::sse_decode_single(message); - {TODO} + {return_type_inner_to_outer} }} move |{parameter_names_and_types}| {{ @@ -59,3 +61,17 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { Some(self.ir.get_delegate().rust_api_type()) } } + +fn generate_return_type_inner_to_outer(ir: &IrMaybeResult) -> String { + let delegate_type = ir.delegate.rust_api_type(); + if let Some(error) = ir.error { + format!( + "match decoded {{ + {delegate_type}::Ok(value) => std::result::Result::Ok(value), + {delegate_type}::Err(value) => std::result::Result::Err(value), + }}" + ) + } else { + format!("decoded") + } +} From 86b02b853dddcdf7703eec39e1b7641ad032c3db Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:12:56 +0800 Subject: [PATCH 41/94] feat: more --- .../rust/spec_generator/misc/ty/dart_fn.rs | 26 ++++++++++++------- 1 file changed, 17 insertions(+), 9 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index 8b200a1ecd..2ec5b8ae3c 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -63,15 +63,23 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { } fn generate_return_type_inner_to_outer(ir: &IrMaybeResult) -> String { - let delegate_type = ir.delegate.rust_api_type(); - if let Some(error) = ir.error { - format!( - "match decoded {{ - {delegate_type}::Ok(value) => std::result::Result::Ok(value), - {delegate_type}::Err(value) => std::result::Result::Err(value), - }}" + let (branch_ok, branch_err) = if let Some(error) = &ir.error { + ( + "std::result::Result::Ok(value)".to_owned(), + "std::result::Result::Err(value)".to_owned(), ) } else { - format!("decoded") - } + ( + "value", + r#"panic!("Dart throws exception but Rust side assume it is not failable")"#, + ) + }; + + let delegate_type = ir.delegate.rust_api_type(); + format!( + "match decoded {{ + {delegate_type}::Ok(value) => {branch_ok}, + {delegate_type}::Err(value) => {branch_err}, + }}" + ) } From 17af0342d75ae3dae3bac58f21251cd29357cecb Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:13:52 +0800 Subject: [PATCH 42/94] feat: more --- .../wire/rust/spec_generator/misc/ty/dart_fn.rs | 4 ++-- frb_example/dart_minimal/rust/src/frb_generated.rs | 11 ++++++++++- 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index 2ec5b8ae3c..94b63adfda 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -65,8 +65,8 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { fn generate_return_type_inner_to_outer(ir: &IrMaybeResult) -> String { let (branch_ok, branch_err) = if let Some(error) = &ir.error { ( - "std::result::Result::Ok(value)".to_owned(), - "std::result::Result::Err(value)".to_owned(), + "std::result::Result::Ok(value)", + "std::result::Result::Err(value)", ) } else { ( diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index abe7c23ed1..90d0938a3c 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -158,7 +158,16 @@ fn decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - >::sse_decode_single(message) + let decoded = + ::sse_decode_single(message); + match decoded { + crate::api::minimal::__delegate_Result__String_u_32::Ok(value) => { + std::result::Result::Ok(value) + } + crate::api::minimal::__delegate_Result__String_u_32::Err(value) => { + std::result::Result::Err(value) + } + } } move |arg0: String| { From fad3ca8fd2139f029b4eafa24ea3423396e67e7a Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:14:52 +0800 Subject: [PATCH 43/94] fix: visit delegate --- frb_codegen/src/library/codegen/ir/result.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index 29377d4c01..6c1e83f9c1 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -21,6 +21,7 @@ impl IrMaybeResult { if let Some(error) = &self.error { error.visit_types(f, ir_context); } + self.delegate.visit_types(f, ir_context); } pub(crate) fn safe_ident(&self) -> String { From d7938cadcba8a6676c0ed38036533e46f54cba36 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:16:03 +0800 Subject: [PATCH 44/94] chore: codegen --- .../lib/src/rust/api/minimal.dart | 15 + .../lib/src/rust/api/minimal.freezed.dart | 369 ++++++++++++++++++ .../lib/src/rust/frb_generated.dart | 50 +++ .../lib/src/rust/frb_generated.io.dart | 12 + .../lib/src/rust/frb_generated.web.dart | 12 + .../dart_minimal/rust/src/frb_generated.rs | 65 +++ 6 files changed, 523 insertions(+) create mode 100644 frb_example/dart_minimal/lib/src/rust/api/minimal.freezed.dart diff --git a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart index 9cb3f3fdaf..a80da1f5a3 100644 --- a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart +++ b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart @@ -5,6 +5,8 @@ import '../frb_generated.dart'; import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; +import 'package:freezed_annotation/freezed_annotation.dart' hide protected; +part 'minimal.freezed.dart'; Future minimalAdder({required int a, required int b, dynamic hint}) => RustLib.instance.api.crateApiMinimalMinimalAdder(a: a, b: b, hint: hint); @@ -14,3 +16,16 @@ Future rustFunction( dynamic hint}) => RustLib.instance.api .crateApiMinimalRustFunction(dartCallback: dartCallback, hint: hint); + +@freezed +sealed class __delegate_Result__String_u_32 + with _$__delegate_Result__String_u_32 { + const __delegate_Result__String_u_32._(); + + const factory __delegate_Result__String_u_32.ok({ + required String value, + }) = __delegate_Result__String_u_32_ok; + const factory __delegate_Result__String_u_32.err({ + required int value, + }) = __delegate_Result__String_u_32_err; +} diff --git a/frb_example/dart_minimal/lib/src/rust/api/minimal.freezed.dart b/frb_example/dart_minimal/lib/src/rust/api/minimal.freezed.dart new file mode 100644 index 0000000000..e26f3ade4f --- /dev/null +++ b/frb_example/dart_minimal/lib/src/rust/api/minimal.freezed.dart @@ -0,0 +1,369 @@ +// coverage:ignore-file +// GENERATED CODE - DO NOT MODIFY BY HAND +// ignore_for_file: type=lint +// ignore_for_file: unused_element, deprecated_member_use, deprecated_member_use_from_same_package, use_function_type_syntax_for_parameters, unnecessary_const, avoid_init_to_null, invalid_override_different_default_values_named, prefer_expression_function_bodies, annotate_overrides, invalid_annotation_target, unnecessary_question_mark + +part of 'minimal.dart'; + +// ************************************************************************** +// FreezedGenerator +// ************************************************************************** + +T _$identity(T value) => value; + +final _privateConstructorUsedError = UnsupportedError( + 'It seems like you constructed your class using `MyClass._()`. This constructor is only meant to be used by freezed and you are not supposed to need it nor use it.\nPlease check the documentation here for more information: https://github.com/rrousselGit/freezed#custom-getters-and-methods'); + +/// @nodoc +mixin _$_delegate_Result__String_u_32 { + Object get value => throw _privateConstructorUsedError; + @optionalTypeArgs + TResult when({ + required TResult Function(String value) ok, + required TResult Function(int value) err, + }) => + throw _privateConstructorUsedError; + @optionalTypeArgs + TResult? whenOrNull({ + TResult? Function(String value)? ok, + TResult? Function(int value)? err, + }) => + throw _privateConstructorUsedError; + @optionalTypeArgs + TResult maybeWhen({ + TResult Function(String value)? ok, + TResult Function(int value)? err, + required TResult orElse(), + }) => + throw _privateConstructorUsedError; + @optionalTypeArgs + TResult map({ + required TResult Function(__delegate_Result__String_u_32_ok value) ok, + required TResult Function(__delegate_Result__String_u_32_err value) err, + }) => + throw _privateConstructorUsedError; + @optionalTypeArgs + TResult? mapOrNull({ + TResult? Function(__delegate_Result__String_u_32_ok value)? ok, + TResult? Function(__delegate_Result__String_u_32_err value)? err, + }) => + throw _privateConstructorUsedError; + @optionalTypeArgs + TResult maybeMap({ + TResult Function(__delegate_Result__String_u_32_ok value)? ok, + TResult Function(__delegate_Result__String_u_32_err value)? err, + required TResult orElse(), + }) => + throw _privateConstructorUsedError; +} + +/// @nodoc +abstract class _$_delegate_Result__String_u_32CopyWith<$Res> { + factory _$_delegate_Result__String_u_32CopyWith( + __delegate_Result__String_u_32 value, + $Res Function(__delegate_Result__String_u_32) then) = + __$_delegate_Result__String_u_32CopyWithImpl<$Res, + __delegate_Result__String_u_32>; +} + +/// @nodoc +class __$_delegate_Result__String_u_32CopyWithImpl<$Res, + $Val extends __delegate_Result__String_u_32> + implements _$_delegate_Result__String_u_32CopyWith<$Res> { + __$_delegate_Result__String_u_32CopyWithImpl(this._value, this._then); + + // ignore: unused_field + final $Val _value; + // ignore: unused_field + final $Res Function($Val) _then; +} + +/// @nodoc +abstract class _$$_delegate_Result__String_u_32_okImplCopyWith<$Res> { + factory _$$_delegate_Result__String_u_32_okImplCopyWith( + _$_delegate_Result__String_u_32_okImpl value, + $Res Function(_$_delegate_Result__String_u_32_okImpl) then) = + __$$_delegate_Result__String_u_32_okImplCopyWithImpl<$Res>; + @useResult + $Res call({String value}); +} + +/// @nodoc +class __$$_delegate_Result__String_u_32_okImplCopyWithImpl<$Res> + extends __$_delegate_Result__String_u_32CopyWithImpl<$Res, + _$_delegate_Result__String_u_32_okImpl> + implements _$$_delegate_Result__String_u_32_okImplCopyWith<$Res> { + __$$_delegate_Result__String_u_32_okImplCopyWithImpl( + _$_delegate_Result__String_u_32_okImpl _value, + $Res Function(_$_delegate_Result__String_u_32_okImpl) _then) + : super(_value, _then); + + @pragma('vm:prefer-inline') + @override + $Res call({ + Object? value = null, + }) { + return _then(_$_delegate_Result__String_u_32_okImpl( + value: null == value + ? _value.value + : value // ignore: cast_nullable_to_non_nullable + as String, + )); + } +} + +/// @nodoc + +class _$_delegate_Result__String_u_32_okImpl + extends __delegate_Result__String_u_32_ok { + const _$_delegate_Result__String_u_32_okImpl({required this.value}) + : super._(); + + @override + final String value; + + @override + String toString() { + return '__delegate_Result__String_u_32.ok(value: $value)'; + } + + @override + bool operator ==(Object other) { + return identical(this, other) || + (other.runtimeType == runtimeType && + other is _$_delegate_Result__String_u_32_okImpl && + (identical(other.value, value) || other.value == value)); + } + + @override + int get hashCode => Object.hash(runtimeType, value); + + @JsonKey(ignore: true) + @override + @pragma('vm:prefer-inline') + _$$_delegate_Result__String_u_32_okImplCopyWith< + _$_delegate_Result__String_u_32_okImpl> + get copyWith => __$$_delegate_Result__String_u_32_okImplCopyWithImpl< + _$_delegate_Result__String_u_32_okImpl>(this, _$identity); + + @override + @optionalTypeArgs + TResult when({ + required TResult Function(String value) ok, + required TResult Function(int value) err, + }) { + return ok(value); + } + + @override + @optionalTypeArgs + TResult? whenOrNull({ + TResult? Function(String value)? ok, + TResult? Function(int value)? err, + }) { + return ok?.call(value); + } + + @override + @optionalTypeArgs + TResult maybeWhen({ + TResult Function(String value)? ok, + TResult Function(int value)? err, + required TResult orElse(), + }) { + if (ok != null) { + return ok(value); + } + return orElse(); + } + + @override + @optionalTypeArgs + TResult map({ + required TResult Function(__delegate_Result__String_u_32_ok value) ok, + required TResult Function(__delegate_Result__String_u_32_err value) err, + }) { + return ok(this); + } + + @override + @optionalTypeArgs + TResult? mapOrNull({ + TResult? Function(__delegate_Result__String_u_32_ok value)? ok, + TResult? Function(__delegate_Result__String_u_32_err value)? err, + }) { + return ok?.call(this); + } + + @override + @optionalTypeArgs + TResult maybeMap({ + TResult Function(__delegate_Result__String_u_32_ok value)? ok, + TResult Function(__delegate_Result__String_u_32_err value)? err, + required TResult orElse(), + }) { + if (ok != null) { + return ok(this); + } + return orElse(); + } +} + +abstract class __delegate_Result__String_u_32_ok + extends __delegate_Result__String_u_32 { + const factory __delegate_Result__String_u_32_ok( + {required final String value}) = _$_delegate_Result__String_u_32_okImpl; + const __delegate_Result__String_u_32_ok._() : super._(); + + @override + String get value; + @JsonKey(ignore: true) + _$$_delegate_Result__String_u_32_okImplCopyWith< + _$_delegate_Result__String_u_32_okImpl> + get copyWith => throw _privateConstructorUsedError; +} + +/// @nodoc +abstract class _$$_delegate_Result__String_u_32_errImplCopyWith<$Res> { + factory _$$_delegate_Result__String_u_32_errImplCopyWith( + _$_delegate_Result__String_u_32_errImpl value, + $Res Function(_$_delegate_Result__String_u_32_errImpl) then) = + __$$_delegate_Result__String_u_32_errImplCopyWithImpl<$Res>; + @useResult + $Res call({int value}); +} + +/// @nodoc +class __$$_delegate_Result__String_u_32_errImplCopyWithImpl<$Res> + extends __$_delegate_Result__String_u_32CopyWithImpl<$Res, + _$_delegate_Result__String_u_32_errImpl> + implements _$$_delegate_Result__String_u_32_errImplCopyWith<$Res> { + __$$_delegate_Result__String_u_32_errImplCopyWithImpl( + _$_delegate_Result__String_u_32_errImpl _value, + $Res Function(_$_delegate_Result__String_u_32_errImpl) _then) + : super(_value, _then); + + @pragma('vm:prefer-inline') + @override + $Res call({ + Object? value = null, + }) { + return _then(_$_delegate_Result__String_u_32_errImpl( + value: null == value + ? _value.value + : value // ignore: cast_nullable_to_non_nullable + as int, + )); + } +} + +/// @nodoc + +class _$_delegate_Result__String_u_32_errImpl + extends __delegate_Result__String_u_32_err { + const _$_delegate_Result__String_u_32_errImpl({required this.value}) + : super._(); + + @override + final int value; + + @override + String toString() { + return '__delegate_Result__String_u_32.err(value: $value)'; + } + + @override + bool operator ==(Object other) { + return identical(this, other) || + (other.runtimeType == runtimeType && + other is _$_delegate_Result__String_u_32_errImpl && + (identical(other.value, value) || other.value == value)); + } + + @override + int get hashCode => Object.hash(runtimeType, value); + + @JsonKey(ignore: true) + @override + @pragma('vm:prefer-inline') + _$$_delegate_Result__String_u_32_errImplCopyWith< + _$_delegate_Result__String_u_32_errImpl> + get copyWith => __$$_delegate_Result__String_u_32_errImplCopyWithImpl< + _$_delegate_Result__String_u_32_errImpl>(this, _$identity); + + @override + @optionalTypeArgs + TResult when({ + required TResult Function(String value) ok, + required TResult Function(int value) err, + }) { + return err(value); + } + + @override + @optionalTypeArgs + TResult? whenOrNull({ + TResult? Function(String value)? ok, + TResult? Function(int value)? err, + }) { + return err?.call(value); + } + + @override + @optionalTypeArgs + TResult maybeWhen({ + TResult Function(String value)? ok, + TResult Function(int value)? err, + required TResult orElse(), + }) { + if (err != null) { + return err(value); + } + return orElse(); + } + + @override + @optionalTypeArgs + TResult map({ + required TResult Function(__delegate_Result__String_u_32_ok value) ok, + required TResult Function(__delegate_Result__String_u_32_err value) err, + }) { + return err(this); + } + + @override + @optionalTypeArgs + TResult? mapOrNull({ + TResult? Function(__delegate_Result__String_u_32_ok value)? ok, + TResult? Function(__delegate_Result__String_u_32_err value)? err, + }) { + return err?.call(this); + } + + @override + @optionalTypeArgs + TResult maybeMap({ + TResult Function(__delegate_Result__String_u_32_ok value)? ok, + TResult Function(__delegate_Result__String_u_32_err value)? err, + required TResult orElse(), + }) { + if (err != null) { + return err(this); + } + return orElse(); + } +} + +abstract class __delegate_Result__String_u_32_err + extends __delegate_Result__String_u_32 { + const factory __delegate_Result__String_u_32_err({required final int value}) = + _$_delegate_Result__String_u_32_errImpl; + const __delegate_Result__String_u_32_err._() : super._(); + + @override + int get value; + @JsonKey(ignore: true) + _$$_delegate_Result__String_u_32_errImplCopyWith< + _$_delegate_Result__String_u_32_errImpl> + get copyWith => throw _privateConstructorUsedError; +} diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index da1f2f40e4..6c21901d07 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -204,6 +204,24 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return raw as String; } + @protected + __delegate_Result__String_u_32 dco_decode_delegate_result_string_u_32( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + switch (raw[0]) { + case 0: + return __delegate_Result__String_u_32_ok( + value: dco_decode_String(raw[1]), + ); + case 1: + return __delegate_Result__String_u_32_err( + value: dco_decode_u_32(raw[1]), + ); + default: + throw Exception("unreachable"); + } + } + @protected int dco_decode_i_32(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs @@ -254,6 +272,24 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return utf8.decoder.convert(inner); } + @protected + __delegate_Result__String_u_32 sse_decode_delegate_result_string_u_32( + 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_value = sse_decode_String(deserializer); + return __delegate_Result__String_u_32_ok(value: var_value); + case 1: + var var_value = sse_decode_u_32(deserializer); + return __delegate_Result__String_u_32_err(value: var_value); + default: + throw UnimplementedError(''); + } + } + @protected int sse_decode_i_32(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -320,6 +356,20 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_prim_u_8_strict(utf8.encoder.convert(self), serializer); } + @protected + void sse_encode_delegate_result_string_u_32( + __delegate_Result__String_u_32 self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + switch (self) { + case __delegate_Result__String_u_32_ok(value: final value): + sse_encode_i_32(0, serializer); + sse_encode_String(value, serializer); + case __delegate_Result__String_u_32_err(value: final value): + sse_encode_i_32(1, serializer); + sse_encode_u_32(value, serializer); + } + } + @protected void sse_encode_i_32(int self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart index e003096e05..01247821a3 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart @@ -29,6 +29,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String dco_decode_String(dynamic raw); + @protected + __delegate_Result__String_u_32 dco_decode_delegate_result_string_u_32( + dynamic raw); + @protected int dco_decode_i_32(dynamic raw); @@ -53,6 +57,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String sse_decode_String(SseDeserializer deserializer); + @protected + __delegate_Result__String_u_32 sse_decode_delegate_result_string_u_32( + SseDeserializer deserializer); + @protected int sse_decode_i_32(SseDeserializer deserializer); @@ -84,6 +92,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_String(String self, SseSerializer serializer); + @protected + void sse_encode_delegate_result_string_u_32( + __delegate_Result__String_u_32 self, SseSerializer serializer); + @protected void sse_encode_i_32(int self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart index 2f81107a84..5d5f804ee6 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart @@ -28,6 +28,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String dco_decode_String(dynamic raw); + @protected + __delegate_Result__String_u_32 dco_decode_delegate_result_string_u_32( + dynamic raw); + @protected int dco_decode_i_32(dynamic raw); @@ -52,6 +56,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String sse_decode_String(SseDeserializer deserializer); + @protected + __delegate_Result__String_u_32 sse_decode_delegate_result_string_u_32( + SseDeserializer deserializer); + @protected int sse_decode_i_32(SseDeserializer deserializer); @@ -83,6 +91,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_String(String self, SseSerializer serializer); + @protected + void sse_encode_delegate_result_string_u_32( + __delegate_Result__String_u_32 self, SseSerializer serializer); + @protected void sse_encode_i_32(int self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index 90d0938a3c..4b20b684ab 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -196,6 +196,30 @@ impl SseDecode for String { } } +impl SseDecode for crate::api::minimal::__delegate_Result__String_u_32 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut tag_ = ::sse_decode(deserializer); + match tag_ { + 0 => { + let mut var_value = ::sse_decode(deserializer); + return crate::api::minimal::__delegate_Result__String_u_32::ok { + value: var_value, + }; + } + 1 => { + let mut var_value = ::sse_decode(deserializer); + return crate::api::minimal::__delegate_Result__String_u_32::err { + value: var_value, + }; + } + _ => { + unimplemented!(""); + } + } + } +} + impl SseDecode for i32 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -278,6 +302,31 @@ fn pde_ffi_dispatcher_sync_impl( // Section: rust2dart +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::minimal::__delegate_Result__String_u_32 { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + match self { + crate::api::minimal::__delegate_Result__String_u_32::ok { value } => { + [0.into_dart(), value.into_into_dart().into_dart()].into_dart() + } + crate::api::minimal::__delegate_Result__String_u_32::err { value } => { + [1.into_dart(), value.into_into_dart().into_dart()].into_dart() + } + } + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::minimal::__delegate_Result__String_u_32 +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::api::minimal::__delegate_Result__String_u_32 +{ + fn into_into_dart(self) -> crate::api::minimal::__delegate_Result__String_u_32 { + self + } +} + impl SseEncode for flutter_rust_bridge::DartOpaque { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -292,6 +341,22 @@ impl SseEncode for String { } } +impl SseEncode for crate::api::minimal::__delegate_Result__String_u_32 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + match self { + crate::api::minimal::__delegate_Result__String_u_32::ok { value } => { + ::sse_encode(0, serializer); + ::sse_encode(value, serializer); + } + crate::api::minimal::__delegate_Result__String_u_32::err { value } => { + ::sse_encode(1, serializer); + ::sse_encode(value, serializer); + } + } + } +} + impl SseEncode for i32 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { From 3d7db6ae2b2f609286d1cc8d1dd906538dbcda27 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:21:23 +0800 Subject: [PATCH 45/94] feat: simp --- frb_codegen/src/library/codegen/ir/result.rs | 10 ++-- .../codegen/parser/type_parser/dart_fn.rs | 47 ------------------- 2 files changed, 5 insertions(+), 52 deletions(-) diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index 6c1e83f9c1..ab9a9f9ee8 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -2,12 +2,9 @@ use crate::codegen::ir::ty::{IrContext, IrType}; use crate::library::codegen::ir::ty::IrTypeTrait; crate::ir! { -/// A `Result` or a direct type `T` pub(crate) struct IrMaybeResult { pub(crate) normal: IrType, pub(crate) error: Option, - /// Combines `normal` and `error` into a new synthesized type - pub(crate) delegate: IrType, } } @@ -21,11 +18,14 @@ impl IrMaybeResult { if let Some(error) = &self.error { error.visit_types(f, ir_context); } - self.delegate.visit_types(f, ir_context); } pub(crate) fn safe_ident(&self) -> String { - self.delegate.safe_ident() + format!( + "{}_{}", + self.normal.safe_ident(), + self.error.map(|x| x.safe_ident()).unwrap_or("None") + ) } pub(crate) fn rust_api_type(&self) -> String { diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index a6e473e5fc..c82317dbfb 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -50,14 +50,12 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .collect::>>()?; let output = self.parse_dart_fn_output(&arguments.output)?; - let output_delegate = self.create_dart_fn_output_delegate(&output); return Ok(IrType::DartFn(IrTypeDartFn { inputs, output: Box::new(IrMaybeResult { normal: output.ok_output, error: output.error_output, - delegate: output_delegate, }), })); @@ -100,51 +98,6 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { bail!("DartFn does not support return types except `DartFnFuture` yet") // frb-coverage:ignore-end } - - fn create_dart_fn_output_delegate(&mut self, info: &ResultTypeInfo) -> IrType { - let namespace = self.context.initiated_namespace.clone(); - - let error_output_or_default = - (info.error_output.clone()).unwrap_or(IrType::Primitive(IrTypePrimitive::Unit)); - - let enum_safe_ident = format!( - "__delegate_Result__{}_{}", - info.ok_output.safe_ident(), - error_output_or_default.safe_ident(), - ); - - self.inner.enum_parser_info.object_pool.insert( - IrEnumIdent(NamespacedName::new( - namespace.clone(), - enum_safe_ident.clone(), - )), - IrEnum { - name: NamespacedName::new(namespace.clone(), enum_safe_ident.clone()), - wrapper_name: None, - comments: vec![], - mode: IrEnumMode::Complex, - variants: vec![ - create_enum_variant( - namespace.clone(), - &enum_safe_ident, - "ok", - info.ok_output.clone(), - ), - create_enum_variant( - namespace.clone(), - &enum_safe_ident, - "err", - error_output_or_default.clone(), - ), - ], - }, - ); - - IrType::EnumRef(IrTypeEnumRef { - ident: IrEnumIdent(NamespacedName::new(namespace, enum_safe_ident)), - is_exception: false, - }) - } } fn create_enum_variant( From 7d8416eb50794e4de07f33807d2978f1ef953e3d Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:22:34 +0800 Subject: [PATCH 46/94] feat: more --- .../generator/wire/dart/spec_generator/misc/ty/dart_fn.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index a1de06d996..e2364f5eaf 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -25,7 +25,8 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { let dart_api_type = ApiDartGenerator::new(self.ir.clone(), self.context.as_api_dart_context()) .dart_api_type(); - let return_type_safe_ident = self.ir.output.delegate.safe_ident(); + let output_normal_safe_ident = self.ir.output.normal.safe_ident(); + let output_error_safe_ident = self.ir.output.error.safe_ident(); let api_impl_body = format!( " @@ -37,7 +38,8 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { final rawOutput = await raw({parameter_names}); final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_{return_type_safe_ident}(rawOutput, serializer); + sse_encode_{output_normal_safe_ident}(rawOutput, serializer); + TODO final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( From a89fc9dbcf82d40c8e3833a37fe9aa09cceb06fe Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:26:34 +0800 Subject: [PATCH 47/94] feat: more --- .../dart/spec_generator/misc/ty/dart_fn.rs | 28 +++++++++++++++++-- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index e2364f5eaf..3beb61376b 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -25,6 +25,17 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { let dart_api_type = ApiDartGenerator::new(self.ir.clone(), self.context.as_api_dart_context()) .dart_api_type(); + + let output_normal_dart_api_type = ApiDartGenerator::new( + self.ir.output.normal.clone(), + self.context.as_api_dart_context(), + ) + .dart_api_type(); + let output_error_dart_api_type = ApiDartGenerator::new( + self.ir.output.error.clone(), + self.context.as_api_dart_context(), + ) + .dart_api_type(); let output_normal_safe_ident = self.ir.output.normal.safe_ident(); let output_error_safe_ident = self.ir.output.error.safe_ident(); @@ -35,11 +46,22 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { return (callId, {raw_parameter_names}) async {{ {decode_block} - final rawOutput = await raw({parameter_names}); + {output_normal_dart_api_type}? rawOutput; + {output_error_dart_api_type}? rawError; + try {{ + rawOutput = await raw({parameter_names}); + }} catch (e) {{ + rawError = e; + }} final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_{output_normal_safe_ident}(rawOutput, serializer); - TODO + if (rawError != null) {{ + TODO_tag; + sse_encode_{output_error_safe_ident}(rawError, serializer); + }} else {{ + TODO_tag; + sse_encode_{output_normal_safe_ident}(rawOutput, serializer); + }} final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( From aff1eee991387379b62d38765cf650a7f8efd6a8 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:27:27 +0800 Subject: [PATCH 48/94] feat: more --- .../wire/dart/spec_generator/misc/ty/dart_fn.rs | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index 3beb61376b..5151c6c610 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -46,21 +46,23 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { return (callId, {raw_parameter_names}) async {{ {decode_block} - {output_normal_dart_api_type}? rawOutput; + Box<{output_normal_dart_api_type}>? rawOutput; {output_error_dart_api_type}? rawError; try {{ - rawOutput = await raw({parameter_names}); + rawOutput = Box(await raw({parameter_names})); }} catch (e) {{ rawError = e; }} final serializer = SseSerializer(generalizedFrbRustBinding); - if (rawError != null) {{ + if (rawOutput != null) {{ + assert(rawError == null); TODO_tag; - sse_encode_{output_error_safe_ident}(rawError, serializer); + sse_encode_{output_normal_safe_ident}(rawOutput.value, serializer); }} else {{ + assert(rawOutput == null); TODO_tag; - sse_encode_{output_normal_safe_ident}(rawOutput, serializer); + sse_encode_{output_error_safe_ident}(rawError, serializer); }} final output = serializer.intoRaw(); From 97b593348c3d26e3f05e73c2b98e368ace338856 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:27:43 +0800 Subject: [PATCH 49/94] feat: more --- .../generator/wire/dart/spec_generator/misc/ty/dart_fn.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index 5151c6c610..c637eb7bff 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -47,11 +47,11 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { {decode_block} Box<{output_normal_dart_api_type}>? rawOutput; - {output_error_dart_api_type}? rawError; + Box<{output_error_dart_api_type}>? rawError; try {{ rawOutput = Box(await raw({parameter_names})); }} catch (e) {{ - rawError = e; + rawError = Box(e); }} final serializer = SseSerializer(generalizedFrbRustBinding); @@ -62,7 +62,7 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { }} else {{ assert(rawOutput == null); TODO_tag; - sse_encode_{output_error_safe_ident}(rawError, serializer); + sse_encode_{output_error_safe_ident}(rawError.value, serializer); }} final output = serializer.intoRaw(); From 088b9ba4d4b603f5111ca8247c37773e3b452ded Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:28:05 +0800 Subject: [PATCH 50/94] feat: more --- .../generator/wire/dart/spec_generator/misc/ty/dart_fn.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index c637eb7bff..f80709292f 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -55,12 +55,11 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { }} final serializer = SseSerializer(generalizedFrbRustBinding); + assert((rawOutput != null) ^ (rawError != null)); if (rawOutput != null) {{ - assert(rawError == null); TODO_tag; sse_encode_{output_normal_safe_ident}(rawOutput.value, serializer); }} else {{ - assert(rawOutput == null); TODO_tag; sse_encode_{output_error_safe_ident}(rawError.value, serializer); }} From a80c702331eb7a2398ad31663a64efde3fbf2f79 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:30:45 +0800 Subject: [PATCH 51/94] feat: more --- .../generator/wire/dart/spec_generator/misc/ty/dart_fn.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index f80709292f..ecaaa43049 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -57,10 +57,10 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { final serializer = SseSerializer(generalizedFrbRustBinding); assert((rawOutput != null) ^ (rawError != null)); if (rawOutput != null) {{ - TODO_tag; + serializer.buffer.putInt32(TODO); sse_encode_{output_normal_safe_ident}(rawOutput.value, serializer); }} else {{ - TODO_tag; + serializer.buffer.putInt32(TODO); sse_encode_{output_error_safe_ident}(rawError.value, serializer); }} final output = serializer.intoRaw(); From 58036a9e652d8e9b28a2a401c9fd37d8bee2a209 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:30:57 +0800 Subject: [PATCH 52/94] chore: simp --- frb_codegen/src/library/codegen/parser/function_parser/mod.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/function_parser/mod.rs b/frb_codegen/src/library/codegen/parser/function_parser/mod.rs index 180bc921eb..83485b8b2f 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/mod.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/mod.rs @@ -119,8 +119,6 @@ impl<'a, 'b> FunctionParser<'a, 'b> { output: IrMaybeResult { normal: info.ok_output.unwrap_or(Primitive(IrTypePrimitive::Unit)), error: info.error_output, - // Not used yet, thus give it a dummy type - delegate: IrType::Primitive(IrTypePrimitive::Unit), }, owner, mode, From 9bd2760d00cad676f46568c22ddc1f9799d7bb18 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:31:07 +0800 Subject: [PATCH 53/94] fix: er --- frb_codegen/src/library/codegen/ir/result.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index ab9a9f9ee8..80a9e143cd 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -24,7 +24,9 @@ impl IrMaybeResult { format!( "{}_{}", self.normal.safe_ident(), - self.error.map(|x| x.safe_ident()).unwrap_or("None") + self.error + .map(|x| x.safe_ident()) + .unwrap_or("None".to_owned()) ) } From 81ae12199b20cbb0fee19a94a36b09714a9a0828 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:33:17 +0800 Subject: [PATCH 54/94] feat: more --- .../generator/wire/dart/spec_generator/misc/ty/dart_fn.rs | 7 +++++-- .../generator/wire/rust/spec_generator/misc/ty/dart_fn.rs | 6 ++++++ .../generator/wire/rust/spec_generator/misc/ty/mod.rs | 2 +- 3 files changed, 12 insertions(+), 3 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index ecaaa43049..05e8361c67 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -3,6 +3,7 @@ use crate::codegen::generator::api_dart::spec_generator::base::ApiDartGenerator; use crate::codegen::generator::wire::dart::spec_generator::base::*; use crate::codegen::generator::wire::dart::spec_generator::misc::ty::WireDartGeneratorMiscTrait; use crate::codegen::generator::wire::dart::spec_generator::output_code::WireDartOutputCode; +use crate::codegen::generator::wire::rust::spec_generator::misc::ty::dart_fn::DartFnOutputAction; use crate::codegen::ir::ty::IrTypeTrait; use crate::library::codegen::generator::api_dart::spec_generator::info::ApiDartGeneratorInfoTrait; use itertools::Itertools; @@ -38,6 +39,8 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { .dart_api_type(); let output_normal_safe_ident = self.ir.output.normal.safe_ident(); let output_error_safe_ident = self.ir.output.error.safe_ident(); + let action_normal = DartFnOutputAction::Success as i32; + let action_error = DartFnOutputAction::Error as i32; let api_impl_body = format!( " @@ -57,10 +60,10 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { final serializer = SseSerializer(generalizedFrbRustBinding); assert((rawOutput != null) ^ (rawError != null)); if (rawOutput != null) {{ - serializer.buffer.putInt32(TODO); + serializer.buffer.putInt32({action_normal}); sse_encode_{output_normal_safe_ident}(rawOutput.value, serializer); }} else {{ - serializer.buffer.putInt32(TODO); + serializer.buffer.putInt32({action_error}); sse_encode_{output_error_safe_ident}(rawError.value, serializer); }} final output = serializer.intoRaw(); diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index 94b63adfda..0b1f15148b 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -83,3 +83,9 @@ fn generate_return_type_inner_to_outer(ir: &IrMaybeResult) -> String { }}" ) } + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum DartFnOutputAction { + Success = 0, + Error = 1, +} diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/mod.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/mod.rs index eabcb4ef77..181b0b3249 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/mod.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/mod.rs @@ -1,7 +1,7 @@ use crate::codegen::generator::wire::rust::spec_generator::base::*; mod boxed; -mod dart_fn; +pub(crate) mod dart_fn; mod dart_opaque; mod delegate; mod dynamic; From d77fae08a28deb6f09735cc64a9c631e3e7be095 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:38:20 +0800 Subject: [PATCH 55/94] Revert "refactor: mv" This reverts commit 2ddf2a3abfc39a13cd0a19693b265ae06c89ef9d. # Conflicts: # frb_codegen/src/library/codegen/ir/result.rs --- frb_codegen/src/library/codegen/ir/func.rs | 8 ++++++-- frb_codegen/src/library/codegen/ir/mod.rs | 1 - .../src/library/codegen/parser/function_parser/mod.rs | 5 ++--- .../src/library/codegen/parser/function_parser/output.rs | 2 ++ 4 files changed, 10 insertions(+), 6 deletions(-) diff --git a/frb_codegen/src/library/codegen/ir/func.rs b/frb_codegen/src/library/codegen/ir/func.rs index ae48eb8ab1..3137a6a29c 100644 --- a/frb_codegen/src/library/codegen/ir/func.rs +++ b/frb_codegen/src/library/codegen/ir/func.rs @@ -2,7 +2,6 @@ use crate::codegen::generator::codec::structs::CodecModePack; use crate::codegen::ir::comment::IrComment; use crate::codegen::ir::field::IrField; use crate::codegen::ir::namespace::NamespacedName; -use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::delegate::{IrTypeDelegate, IrTypeDelegatePrimitiveEnum}; use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::{IrContext, IrType, IrTypeTrait}; @@ -15,7 +14,7 @@ pub struct IrFunc { pub name: NamespacedName, pub id: i32, pub inputs: Vec, - pub output: IrMaybeResult, + pub output: IrFuncOutput, pub owner: IrFuncOwnerInfo, pub mode: IrFuncMode, pub stream_dart_await: bool, @@ -35,6 +34,11 @@ pub struct IrFuncInput { pub inner: IrField, } +pub struct IrFuncOutput { + pub normal: IrType, + pub error: Option, +} + #[derive(Copy)] pub enum IrFuncMode { Normal, diff --git a/frb_codegen/src/library/codegen/ir/mod.rs b/frb_codegen/src/library/codegen/ir/mod.rs index c1c6d1cf1d..40bb38b845 100644 --- a/frb_codegen/src/library/codegen/ir/mod.rs +++ b/frb_codegen/src/library/codegen/ir/mod.rs @@ -7,6 +7,5 @@ pub(crate) mod ident; pub(crate) mod import; pub(crate) mod namespace; pub(crate) mod pack; -pub(crate) mod result; pub(crate) mod ty; mod utils; diff --git a/frb_codegen/src/library/codegen/parser/function_parser/mod.rs b/frb_codegen/src/library/codegen/parser/function_parser/mod.rs index 83485b8b2f..08d90931cb 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/mod.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/mod.rs @@ -1,10 +1,9 @@ use crate::codegen::generator::codec::structs::{CodecMode, CodecModePack}; use crate::codegen::ir::func::{ - IrFunc, IrFuncInput, IrFuncMode, IrFuncOwnerInfo, IrFuncOwnerInfoMethod, + IrFunc, IrFuncInput, IrFuncMode, IrFuncOutput, IrFuncOwnerInfo, IrFuncOwnerInfoMethod, IrFuncOwnerInfoMethodMode, }; use crate::codegen::ir::namespace::{Namespace, NamespacedName}; -use crate::codegen::ir::result::IrMaybeResult; use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::rust_opaque::RustOpaqueCodecMode; use crate::codegen::ir::ty::IrType; @@ -116,7 +115,7 @@ impl<'a, 'b> FunctionParser<'a, 'b> { name: NamespacedName::new(namespace_refined, func_name), id: func_id, inputs: info.inputs, - output: IrMaybeResult { + output: IrFuncOutput { normal: info.ok_output.unwrap_or(Primitive(IrTypePrimitive::Unit)), error: info.error_output, }, diff --git a/frb_codegen/src/library/codegen/parser/function_parser/output.rs b/frb_codegen/src/library/codegen/parser/function_parser/output.rs index 29558cdd10..197cb94d58 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/output.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/output.rs @@ -1,7 +1,9 @@ use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::IrType; +use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; use crate::codegen::parser::function_parser::{FunctionParser, FunctionPartialInfo}; use crate::codegen::parser::type_parser::result::parse_type_maybe_result; +use crate::codegen::parser::type_parser::unencodable::splay_segments; use crate::codegen::parser::type_parser::TypeParserParsingContext; use syn::*; From 39c8339cfc2c361506102d6bc0f4c17a740ef8f0 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:38:46 +0800 Subject: [PATCH 56/94] Revert "Auxiliary commit to revert individual files from d77fae08a28deb6f09735cc64a9c631e3e7be095" This reverts commit 2309fb1d2fabff18aeb9c6806bd4d7a9c3e920a6. --- frb_codegen/src/library/codegen/ir/mod.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/frb_codegen/src/library/codegen/ir/mod.rs b/frb_codegen/src/library/codegen/ir/mod.rs index 40bb38b845..c1c6d1cf1d 100644 --- a/frb_codegen/src/library/codegen/ir/mod.rs +++ b/frb_codegen/src/library/codegen/ir/mod.rs @@ -7,5 +7,6 @@ pub(crate) mod ident; pub(crate) mod import; pub(crate) mod namespace; pub(crate) mod pack; +pub(crate) mod result; pub(crate) mod ty; mod utils; From cad2d6f5fbabf6f86a6eaa935e79b9e47779e26b Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:39:11 +0800 Subject: [PATCH 57/94] refactor: rename --- .../generator/wire/rust/spec_generator/misc/ty/dart_fn.rs | 4 ++-- frb_codegen/src/library/codegen/ir/result.rs | 4 ++-- frb_codegen/src/library/codegen/ir/ty/dart_fn.rs | 4 ++-- frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index 0b1f15148b..4f42e514b1 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -2,7 +2,7 @@ use crate::codegen::generator::acc::Acc; use crate::codegen::generator::wire::rust::spec_generator::base::*; use crate::codegen::generator::wire::rust::spec_generator::misc::ty::WireRustGeneratorMiscTrait; use crate::codegen::generator::wire::rust::spec_generator::output_code::WireRustOutputCode; -use crate::codegen::ir::result::IrMaybeResult; +use crate::codegen::ir::result::IrDartFnOutput; use crate::codegen::ir::ty::IrTypeTrait; use crate::library::misc::consts::HANDLER_NAME; use itertools::Itertools; @@ -62,7 +62,7 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { } } -fn generate_return_type_inner_to_outer(ir: &IrMaybeResult) -> String { +fn generate_return_type_inner_to_outer(ir: &IrDartFnOutput) -> String { let (branch_ok, branch_err) = if let Some(error) = &ir.error { ( "std::result::Result::Ok(value)", diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs index 80a9e143cd..8c965e9c94 100644 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ b/frb_codegen/src/library/codegen/ir/result.rs @@ -2,13 +2,13 @@ use crate::codegen::ir::ty::{IrContext, IrType}; use crate::library::codegen::ir::ty::IrTypeTrait; crate::ir! { -pub(crate) struct IrMaybeResult { +pub(crate) struct IrDartFnOutput { pub(crate) normal: IrType, pub(crate) error: Option, } } -impl IrMaybeResult { +impl IrDartFnOutput { pub(crate) fn visit_types bool>( &self, f: &mut F, diff --git a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs index 1029ea21c6..f0eb92821f 100644 --- a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs @@ -1,4 +1,4 @@ -use crate::codegen::ir::result::IrMaybeResult; +use crate::codegen::ir::result::IrDartFnOutput; use crate::codegen::ir::ty::dart_opaque::IrTypeDartOpaque; use crate::codegen::ir::ty::{IrContext, IrType, IrTypeTrait}; use itertools::Itertools; @@ -6,7 +6,7 @@ use itertools::Itertools; crate::ir! { pub struct IrTypeDartFn { pub inputs: Vec, - pub output: Box, + pub output: Box, } } diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index c82317dbfb..1389618f91 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -1,7 +1,7 @@ use crate::codegen::ir::field::IrField; use crate::codegen::ir::ident::IrIdent; use crate::codegen::ir::namespace::{Namespace, NamespacedName}; -use crate::codegen::ir::result::IrMaybeResult; +use crate::codegen::ir::result::IrDartFnOutput; use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; use crate::codegen::ir::ty::enumeration::{ IrEnum, IrEnumIdent, IrEnumMode, IrTypeEnumRef, IrVariant, IrVariantKind, @@ -53,7 +53,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { return Ok(IrType::DartFn(IrTypeDartFn { inputs, - output: Box::new(IrMaybeResult { + output: Box::new(IrDartFnOutput { normal: output.ok_output, error: output.error_output, }), From e544b89031c0c7c6eef7369c8ba2f0f343fb6689 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:40:02 +0800 Subject: [PATCH 58/94] refactor: mv --- .../rust/spec_generator/misc/ty/dart_fn.rs | 2 +- frb_codegen/src/library/codegen/ir/mod.rs | 1 - frb_codegen/src/library/codegen/ir/result.rs | 44 ------------------- .../src/library/codegen/ir/ty/dart_fn.rs | 41 ++++++++++++++++- .../codegen/parser/type_parser/dart_fn.rs | 2 +- 5 files changed, 42 insertions(+), 48 deletions(-) delete mode 100644 frb_codegen/src/library/codegen/ir/result.rs diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index 4f42e514b1..78f1136e27 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -2,7 +2,7 @@ use crate::codegen::generator::acc::Acc; use crate::codegen::generator::wire::rust::spec_generator::base::*; use crate::codegen::generator::wire::rust::spec_generator::misc::ty::WireRustGeneratorMiscTrait; use crate::codegen::generator::wire::rust::spec_generator::output_code::WireRustOutputCode; -use crate::codegen::ir::result::IrDartFnOutput; +use crate::codegen::ir::ty::dart_fn::IrDartFnOutput; use crate::codegen::ir::ty::IrTypeTrait; use crate::library::misc::consts::HANDLER_NAME; use itertools::Itertools; diff --git a/frb_codegen/src/library/codegen/ir/mod.rs b/frb_codegen/src/library/codegen/ir/mod.rs index c1c6d1cf1d..40bb38b845 100644 --- a/frb_codegen/src/library/codegen/ir/mod.rs +++ b/frb_codegen/src/library/codegen/ir/mod.rs @@ -7,6 +7,5 @@ pub(crate) mod ident; pub(crate) mod import; pub(crate) mod namespace; pub(crate) mod pack; -pub(crate) mod result; pub(crate) mod ty; mod utils; diff --git a/frb_codegen/src/library/codegen/ir/result.rs b/frb_codegen/src/library/codegen/ir/result.rs deleted file mode 100644 index 8c965e9c94..0000000000 --- a/frb_codegen/src/library/codegen/ir/result.rs +++ /dev/null @@ -1,44 +0,0 @@ -use crate::codegen::ir::ty::{IrContext, IrType}; -use crate::library::codegen::ir::ty::IrTypeTrait; - -crate::ir! { -pub(crate) struct IrDartFnOutput { - pub(crate) normal: IrType, - pub(crate) error: Option, -} -} - -impl IrDartFnOutput { - pub(crate) fn visit_types bool>( - &self, - f: &mut F, - ir_context: &impl IrContext, - ) { - self.normal.visit_types(f, ir_context); - if let Some(error) = &self.error { - error.visit_types(f, ir_context); - } - } - - pub(crate) fn safe_ident(&self) -> String { - format!( - "{}_{}", - self.normal.safe_ident(), - self.error - .map(|x| x.safe_ident()) - .unwrap_or("None".to_owned()) - ) - } - - pub(crate) fn rust_api_type(&self) -> String { - if let Some(error) = &self.error { - format!( - "std::result::Result<{}, {}>", - self.normal.rust_api_type(), - error.rust_api_type() - ) - } else { - self.normal.rust_api_type() - } - } -} diff --git a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs index f0eb92821f..296a3cbf00 100644 --- a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs @@ -1,4 +1,3 @@ -use crate::codegen::ir::result::IrDartFnOutput; use crate::codegen::ir::ty::dart_opaque::IrTypeDartOpaque; use crate::codegen::ir::ty::{IrContext, IrType, IrTypeTrait}; use itertools::Itertools; @@ -8,6 +7,11 @@ pub struct IrTypeDartFn { pub inputs: Vec, pub output: Box, } + +pub(crate) struct IrDartFnOutput { + pub(crate) normal: IrType, + pub(crate) error: Option, +} } impl IrTypeTrait for IrTypeDartFn { @@ -47,3 +51,38 @@ impl IrTypeDartFn { IrType::DartOpaque(IrTypeDartOpaque) } } + +impl IrDartFnOutput { + pub(crate) fn visit_types bool>( + &self, + f: &mut F, + ir_context: &impl IrContext, + ) { + self.normal.visit_types(f, ir_context); + if let Some(error) = &self.error { + error.visit_types(f, ir_context); + } + } + + pub(crate) fn safe_ident(&self) -> String { + format!( + "{}_{}", + self.normal.safe_ident(), + self.error + .map(|x| x.safe_ident()) + .unwrap_or("None".to_owned()) + ) + } + + pub(crate) fn rust_api_type(&self) -> String { + if let Some(error) = &self.error { + format!( + "std::result::Result<{}, {}>", + self.normal.rust_api_type(), + error.rust_api_type() + ) + } else { + self.normal.rust_api_type() + } + } +} diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 1389618f91..bb7db336e0 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -1,7 +1,7 @@ use crate::codegen::ir::field::IrField; use crate::codegen::ir::ident::IrIdent; use crate::codegen::ir::namespace::{Namespace, NamespacedName}; -use crate::codegen::ir::result::IrDartFnOutput; +use crate::codegen::ir::ty::dart_fn::IrDartFnOutput; use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; use crate::codegen::ir::ty::enumeration::{ IrEnum, IrEnumIdent, IrEnumMode, IrTypeEnumRef, IrVariant, IrVariantKind, From d10c27083cafcda8ec6e443b7cc1d32407825eb8 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:41:23 +0800 Subject: [PATCH 59/94] feat: ty --- frb_codegen/src/library/codegen/ir/ty/dart_fn.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs index 296a3cbf00..098cf7bad7 100644 --- a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs @@ -10,7 +10,9 @@ pub struct IrTypeDartFn { pub(crate) struct IrDartFnOutput { pub(crate) normal: IrType, - pub(crate) error: Option, + pub(crate) error: IrType, + /// Whether the error is provided to users, or error yields panic + pub(crate) api_fallible: bool, } } From 73655dcc3884d9704eff352f68b0c5dc7a654340 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:42:24 +0800 Subject: [PATCH 60/94] feat: writer --- .../src/library/codegen/parser/type_parser/dart_fn.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index bb7db336e0..62e24fb68a 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -3,6 +3,7 @@ use crate::codegen::ir::ident::IrIdent; use crate::codegen::ir::namespace::{Namespace, NamespacedName}; use crate::codegen::ir::ty::dart_fn::IrDartFnOutput; use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; +use crate::codegen::ir::ty::delegate::IrTypeDelegate; use crate::codegen::ir::ty::enumeration::{ IrEnum, IrEnumIdent, IrEnumMode, IrTypeEnumRef, IrVariant, IrVariantKind, }; @@ -55,7 +56,8 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { inputs, output: Box::new(IrDartFnOutput { normal: output.ok_output, - error: output.error_output, + error: output.error_output.unwrap_or(FALLBACK_ERROR_TYPE), + api_fallible: output.error_output.is_some(), }), })); @@ -131,6 +133,8 @@ fn create_enum_variant( } } +const FALLBACK_ERROR_TYPE: IrType = IrType::Delegate(IrTypeDelegate::String); + // // Use this unit "test" to see how a type will be parsed into a tree // #[cfg(test)] // mod tests { From f7a5ddb52adb1993763b50f26a17955f9f9c2e14 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:42:44 +0800 Subject: [PATCH 61/94] fix: err --- .../wire/rust/spec_generator/misc/ty/dart_fn.rs | 2 +- frb_codegen/src/library/codegen/ir/ty/dart_fn.rs | 16 ++++------------ 2 files changed, 5 insertions(+), 13 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index 78f1136e27..837875e180 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -63,7 +63,7 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { } fn generate_return_type_inner_to_outer(ir: &IrDartFnOutput) -> String { - let (branch_ok, branch_err) = if let Some(error) = &ir.error { + let (branch_ok, branch_err) = if ir.api_fallible { ( "std::result::Result::Ok(value)", "std::result::Result::Err(value)", diff --git a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs index 098cf7bad7..828b2a174e 100644 --- a/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/ir/ty/dart_fn.rs @@ -61,27 +61,19 @@ impl IrDartFnOutput { ir_context: &impl IrContext, ) { self.normal.visit_types(f, ir_context); - if let Some(error) = &self.error { - error.visit_types(f, ir_context); - } + self.error.visit_types(f, ir_context); } pub(crate) fn safe_ident(&self) -> String { - format!( - "{}_{}", - self.normal.safe_ident(), - self.error - .map(|x| x.safe_ident()) - .unwrap_or("None".to_owned()) - ) + format!("{}_{}", self.normal.safe_ident(), self.error.safe_ident()) } pub(crate) fn rust_api_type(&self) -> String { - if let Some(error) = &self.error { + if self.api_fallible { format!( "std::result::Result<{}, {}>", self.normal.rust_api_type(), - error.rust_api_type() + self.error.rust_api_type() ) } else { self.normal.rust_api_type() From 99e7e714c0b24e121212591c0a819c42d8c21231 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:46:16 +0800 Subject: [PATCH 62/94] feat: more --- .../wire/dart/spec_generator/misc/ty/dart_fn.rs | 4 ++-- .../wire/rust/spec_generator/misc/ty/dart_fn.rs | 11 +++++++++-- frb_example/dart_minimal/rust/src/frb_generated.rs | 1 + frb_rust/src/codec/sse.rs | 2 +- 4 files changed, 13 insertions(+), 5 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index 05e8361c67..b54a4d44bb 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -60,10 +60,10 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { final serializer = SseSerializer(generalizedFrbRustBinding); assert((rawOutput != null) ^ (rawError != null)); if (rawOutput != null) {{ - serializer.buffer.putInt32({action_normal}); + serializer.buffer.putUint8({action_normal}); sse_encode_{output_normal_safe_ident}(rawOutput.value, serializer); }} else {{ - serializer.buffer.putInt32({action_error}); + serializer.buffer.putUint8({action_error}); sse_encode_{output_error_safe_ident}(rawError.value, serializer); }} final output = serializer.intoRaw(); diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index 837875e180..c933608bb8 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -37,8 +37,15 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { async fn body(dart_opaque: flutter_rust_bridge::DartOpaque, {parameter_names_and_types}) -> {return_type_outer} {{ let args = vec![{into_dart_expressions}]; let message = {HANDLER_NAME}.dart_fn_invoke(dart_opaque, args).await; - let decoded = <{return_type_inner}>::sse_decode_single(message); - {return_type_inner_to_outer} + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + match action {{ + + }} + let ans = <{TODO}>::sse_decode(&mut deserializer); + deserializer.end(); + ans }} move |{parameter_names_and_types}| {{ diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index 4b20b684ab..11cadf6686 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -158,6 +158,7 @@ fn decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; + String::sse_decode_single() let decoded = ::sse_decode_single(message); match decoded { diff --git a/frb_rust/src/codec/sse.rs b/frb_rust/src/codec/sse.rs index 4cb5311a40..2587d9b963 100644 --- a/frb_rust/src/codec/sse.rs +++ b/frb_rust/src/codec/sse.rs @@ -3,8 +3,8 @@ use crate::generalized_isolate::IntoDart; use crate::handler::error::error_to_string; use crate::platform_types::{DartAbi, PlatformGeneralizedUint8ListPtr, WireSyncRust2DartSse}; use crate::rust2dart::action::Rust2DartAction; -use byteorder::NativeEndian; use byteorder::WriteBytesExt; +use byteorder::{NativeEndian, ReadBytesExt}; use std::any::Any; use std::backtrace::Backtrace; use std::io::Cursor; From 4827983d3ad32c395e64f6fbfd9d306a0bf97703 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:48:44 +0800 Subject: [PATCH 63/94] feat: more --- .../dart/spec_generator/misc/ty/dart_fn.rs | 1 + .../rust/spec_generator/misc/ty/dart_fn.rs | 51 +++++++++---------- 2 files changed, 24 insertions(+), 28 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index b54a4d44bb..9013672667 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -39,6 +39,7 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { .dart_api_type(); let output_normal_safe_ident = self.ir.output.normal.safe_ident(); let output_error_safe_ident = self.ir.output.error.safe_ident(); + let action_normal = DartFnOutputAction::Success as i32; let action_error = DartFnOutputAction::Error as i32; diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index c933608bb8..3c75d9f0cc 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -24,8 +24,24 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { .join(""); let return_type_outer = self.ir.output.rust_api_type(); - let return_type_inner = self.ir.output.delegate.rust_api_type(); - let return_type_inner_to_outer = generate_return_type_inner_to_outer(&self.ir.output); + let output_normal_type = self.ir.output.normal.rust_api_type(); + let output_error_type = self.ir.output.error.rust_api_type(); + + let action_normal = DartFnOutputAction::Success as i32; + let action_error = DartFnOutputAction::Error as i32; + + let (branch_normal, branch_err) = if self.ir.output.api_fallible { + ( + format!("std::result::Result::Ok(<{output_normal_type}>::sse_decode(&mut deserializer))"), + format!("std::result::Result::Err(<{output_error_type}>::sse_decode(&mut deserializer))"), + ) + } else { + ( + format!("<{output_normal_type}>::sse_decode(&mut deserializer)"), + r#"panic!("Dart throws exception but Rust side assume it is not failable")"# + .to_owned(), + ) + }; Acc::new_common( format!( @@ -40,10 +56,11 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); let action = deserializer.cursor.read_u8().unwrap(); - match action {{ - - }} - let ans = <{TODO}>::sse_decode(&mut deserializer); + let ans = match action {{ + {action_normal} => {branch_normal}, + {action_error} => {branch_error}, + _ => unreachable!(), + }}; deserializer.end(); ans }} @@ -69,28 +86,6 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { } } -fn generate_return_type_inner_to_outer(ir: &IrDartFnOutput) -> String { - let (branch_ok, branch_err) = if ir.api_fallible { - ( - "std::result::Result::Ok(value)", - "std::result::Result::Err(value)", - ) - } else { - ( - "value", - r#"panic!("Dart throws exception but Rust side assume it is not failable")"#, - ) - }; - - let delegate_type = ir.delegate.rust_api_type(); - format!( - "match decoded {{ - {delegate_type}::Ok(value) => {branch_ok}, - {delegate_type}::Err(value) => {branch_err}, - }}" - ) -} - #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub(crate) enum DartFnOutputAction { Success = 0, From c7fa286244d37c430960ba0dcf90c65e8446aee6 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:50:25 +0800 Subject: [PATCH 64/94] feat: more --- .../rust/spec_generator/misc/ty/dart_fn.rs | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index 3c75d9f0cc..16e3844889 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -30,17 +30,10 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { let action_normal = DartFnOutputAction::Success as i32; let action_error = DartFnOutputAction::Error as i32; - let (branch_normal, branch_err) = if self.ir.output.api_fallible { - ( - format!("std::result::Result::Ok(<{output_normal_type}>::sse_decode(&mut deserializer))"), - format!("std::result::Result::Err(<{output_error_type}>::sse_decode(&mut deserializer))"), - ) + let maybe_unwrap_ans = if self.ir.output.api_fallible { + "" } else { - ( - format!("<{output_normal_type}>::sse_decode(&mut deserializer)"), - r#"panic!("Dart throws exception but Rust side assume it is not failable")"# - .to_owned(), - ) + r#"let ans = ans.expect("Dart throws exception but Rust side assume it is not failable");"# }; Acc::new_common( @@ -57,12 +50,12 @@ impl<'a> WireRustGeneratorMiscTrait for DartFnWireRustGenerator<'a> { let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); let action = deserializer.cursor.read_u8().unwrap(); let ans = match action {{ - {action_normal} => {branch_normal}, - {action_error} => {branch_error}, + {action_normal} => std::result::Result::Ok(<{output_normal_type}>::sse_decode(&mut deserializer)), + {action_error} => std::result::Result::Err(<{output_error_type}>::sse_decode(&mut deserializer)), _ => unreachable!(), }}; deserializer.end(); - ans + {maybe_unwrap_ans}ans }} move |{parameter_names_and_types}| {{ From 7611cd77562d2451aa0f5a0f320ba1b549a7f7c4 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:50:52 +0800 Subject: [PATCH 65/94] fix: err --- frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 62e24fb68a..0ed41fbd4b 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -56,7 +56,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { inputs, output: Box::new(IrDartFnOutput { normal: output.ok_output, - error: output.error_output.unwrap_or(FALLBACK_ERROR_TYPE), + error: output.error_output.clone().unwrap_or(FALLBACK_ERROR_TYPE), api_fallible: output.error_output.is_some(), }), })); From 3f3afa9113018221455dd4e99313f548c0ef75ab Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:51:06 +0800 Subject: [PATCH 66/94] chore: simp --- .../codegen/parser/type_parser/dart_fn.rs | 33 ------------------- 1 file changed, 33 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 0ed41fbd4b..6255f625cb 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -7,13 +7,11 @@ use crate::codegen::ir::ty::delegate::IrTypeDelegate; use crate::codegen::ir::ty::enumeration::{ IrEnum, IrEnumIdent, IrEnumMode, IrTypeEnumRef, IrVariant, IrVariantKind, }; -use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::structure::IrStruct; use crate::codegen::ir::ty::IrType; use crate::codegen::parser::type_parser::result::{parse_type_maybe_result, ResultTypeInfo}; use crate::codegen::parser::type_parser::TypeParserWithContext; use crate::if_then_some; -use crate::library::codegen::ir::ty::IrTypeTrait; use anyhow::{bail, Context}; use syn::{ AngleBracketedGenericArguments, GenericArgument, PathArguments, PathSegment, ReturnType, Type, @@ -102,37 +100,6 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { } } -fn create_enum_variant( - namespace: Namespace, - enum_safe_ident: &str, - name: &str, - ty: IrType, -) -> IrVariant { - IrVariant { - name: IrIdent::new(name.to_owned()), - wrapper_name: IrIdent::new(format!("{enum_safe_ident}_{name}")), - comments: vec![], - kind: IrVariantKind::Struct(IrStruct { - name: NamespacedName::new(namespace, name.to_owned()), - wrapper_name: None, - is_fields_named: true, - dart_metadata: vec![], - ignore: false, - generate_hash: false, - generate_eq: false, - comments: vec![], - fields: vec![IrField { - ty, - name: IrIdent::new("value".to_owned()), - is_final: true, - comments: vec![], - default: None, - settings: Default::default(), - }], - }), - } -} - const FALLBACK_ERROR_TYPE: IrType = IrType::Delegate(IrTypeDelegate::String); // // Use this unit "test" to see how a type will be parsed into a tree From eed597a6329897809fa26ffaa82b0283e101a1f9 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:51:36 +0800 Subject: [PATCH 67/94] chore: codegen --- .../lib/src/rust/api/minimal.dart | 15 ---- .../lib/src/rust/frb_generated.dart | 79 +++++----------- .../lib/src/rust/frb_generated.io.dart | 17 +--- .../lib/src/rust/frb_generated.web.dart | 17 +--- .../dart_minimal/rust/src/frb_generated.rs | 90 +++---------------- 5 files changed, 36 insertions(+), 182 deletions(-) diff --git a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart index a80da1f5a3..9cb3f3fdaf 100644 --- a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart +++ b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart @@ -5,8 +5,6 @@ import '../frb_generated.dart'; import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; -import 'package:freezed_annotation/freezed_annotation.dart' hide protected; -part 'minimal.freezed.dart'; Future minimalAdder({required int a, required int b, dynamic hint}) => RustLib.instance.api.crateApiMinimalMinimalAdder(a: a, b: b, hint: hint); @@ -16,16 +14,3 @@ Future rustFunction( dynamic hint}) => RustLib.instance.api .crateApiMinimalRustFunction(dartCallback: dartCallback, hint: hint); - -@freezed -sealed class __delegate_Result__String_u_32 - with _$__delegate_Result__String_u_32 { - const __delegate_Result__String_u_32._(); - - const factory __delegate_Result__String_u_32.ok({ - required String value, - }) = __delegate_Result__String_u_32_ok; - const factory __delegate_Result__String_u_32.err({ - required int value, - }) = __delegate_Result__String_u_32_err; -} diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index 6c21901d07..1dea9ff027 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -142,7 +142,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_delegate_result_string_u_32( + sse_encode_DartFn_Inputs_String_Output_String_u_32( dartCallback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 3, port: port_); @@ -165,15 +165,28 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); Future Function(int, dynamic) - encode_DartFn_Inputs_String_Output_delegate_result_string_u_32( + encode_DartFn_Inputs_String_Output_String_u_32( FutureOr Function(String) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_String(rawArg0); - final rawOutput = await raw(arg0); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0)); + } catch (e) { + rawError = Box(e); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_delegate_result_string_u_32(rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_String(rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_u_32(rawError.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -186,8 +199,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( - dynamic raw) { + dco_decode_DartFn_Inputs_String_Output_String_u_32(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @@ -204,24 +216,6 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return raw as String; } - @protected - __delegate_Result__String_u_32 dco_decode_delegate_result_string_u_32( - dynamic raw) { - // Codec=Dco (DartCObject based), see doc to use other codecs - switch (raw[0]) { - case 0: - return __delegate_Result__String_u_32_ok( - value: dco_decode_String(raw[1]), - ); - case 1: - return __delegate_Result__String_u_32_err( - value: dco_decode_u_32(raw[1]), - ); - default: - throw Exception("unreachable"); - } - } - @protected int dco_decode_i_32(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs @@ -272,24 +266,6 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return utf8.decoder.convert(inner); } - @protected - __delegate_Result__String_u_32 sse_decode_delegate_result_string_u_32( - 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_value = sse_decode_String(deserializer); - return __delegate_Result__String_u_32_ok(value: var_value); - case 1: - var var_value = sse_decode_u_32(deserializer); - return __delegate_Result__String_u_32_err(value: var_value); - default: - throw UnimplementedError(''); - } - } - @protected int sse_decode_i_32(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -333,12 +309,11 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void sse_encode_DartFn_Inputs_String_Output_delegate_result_string_u_32( + void sse_encode_DartFn_Inputs_String_Output_String_u_32( FutureOr Function(String) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_Output_delegate_result_string_u_32(self), - serializer); + encode_DartFn_Inputs_String_Output_String_u_32(self), serializer); } @protected @@ -356,20 +331,6 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_prim_u_8_strict(utf8.encoder.convert(self), serializer); } - @protected - void sse_encode_delegate_result_string_u_32( - __delegate_Result__String_u_32 self, SseSerializer serializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - switch (self) { - case __delegate_Result__String_u_32_ok(value: final value): - sse_encode_i_32(0, serializer); - sse_encode_String(value, serializer); - case __delegate_Result__String_u_32_err(value: final value): - sse_encode_i_32(1, serializer); - sse_encode_u_32(value, serializer); - } - } - @protected void sse_encode_i_32(int self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart index 01247821a3..8e398f0d78 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart @@ -20,8 +20,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( - dynamic raw); + dco_decode_DartFn_Inputs_String_Output_String_u_32(dynamic raw); @protected Object dco_decode_DartOpaque(dynamic raw); @@ -29,10 +28,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String dco_decode_String(dynamic raw); - @protected - __delegate_Result__String_u_32 dco_decode_delegate_result_string_u_32( - dynamic raw); - @protected int dco_decode_i_32(dynamic raw); @@ -57,10 +52,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String sse_decode_String(SseDeserializer deserializer); - @protected - __delegate_Result__String_u_32 sse_decode_delegate_result_string_u_32( - SseDeserializer deserializer); - @protected int sse_decode_i_32(SseDeserializer deserializer); @@ -83,7 +74,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { bool sse_decode_bool(SseDeserializer deserializer); @protected - void sse_encode_DartFn_Inputs_String_Output_delegate_result_string_u_32( + void sse_encode_DartFn_Inputs_String_Output_String_u_32( FutureOr Function(String) self, SseSerializer serializer); @protected @@ -92,10 +83,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_String(String self, SseSerializer serializer); - @protected - void sse_encode_delegate_result_string_u_32( - __delegate_Result__String_u_32 self, SseSerializer serializer); - @protected void sse_encode_i_32(int self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart index 5d5f804ee6..5f4f0fb3df 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart @@ -19,8 +19,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( - dynamic raw); + dco_decode_DartFn_Inputs_String_Output_String_u_32(dynamic raw); @protected Object dco_decode_DartOpaque(dynamic raw); @@ -28,10 +27,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String dco_decode_String(dynamic raw); - @protected - __delegate_Result__String_u_32 dco_decode_delegate_result_string_u_32( - dynamic raw); - @protected int dco_decode_i_32(dynamic raw); @@ -56,10 +51,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String sse_decode_String(SseDeserializer deserializer); - @protected - __delegate_Result__String_u_32 sse_decode_delegate_result_string_u_32( - SseDeserializer deserializer); - @protected int sse_decode_i_32(SseDeserializer deserializer); @@ -82,7 +73,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { bool sse_decode_bool(SseDeserializer deserializer); @protected - void sse_encode_DartFn_Inputs_String_Output_delegate_result_string_u_32( + void sse_encode_DartFn_Inputs_String_Output_String_u_32( FutureOr Function(String) self, SseSerializer serializer); @protected @@ -91,10 +82,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_String(String self, SseSerializer serializer); - @protected - void sse_encode_delegate_result_string_u_32( - __delegate_Result__String_u_32 self, SseSerializer serializer); - @protected void sse_encode_i_32(int self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index 11cadf6686..3a10f85ff7 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -125,7 +125,7 @@ fn wire__crate__api__minimal__rust_function_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_dart_callback = decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( + let api_dart_callback = decode_DartFn_Inputs_String_Output_String_u_32( ::sse_decode(&mut deserializer), ); deserializer.end(); @@ -145,7 +145,7 @@ fn wire__crate__api__minimal__rust_function_impl( // Section: related_funcs -fn decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( +fn decode_DartFn_Inputs_String_Output_String_u_32( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture> { use flutter_rust_bridge::IntoDart; @@ -158,17 +158,16 @@ fn decode_DartFn_Inputs_String_Output_delegate_result_string_u_32( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - String::sse_decode_single() - let decoded = - ::sse_decode_single(message); - match decoded { - crate::api::minimal::__delegate_Result__String_u_32::Ok(value) => { - std::result::Result::Ok(value) - } - crate::api::minimal::__delegate_Result__String_u_32::Err(value) => { - std::result::Result::Err(value) - } - } + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err(::sse_decode(&mut deserializer)), + _ => unreachable!(), + }; + deserializer.end(); + ans } move |arg0: String| { @@ -197,30 +196,6 @@ impl SseDecode for String { } } -impl SseDecode for crate::api::minimal::__delegate_Result__String_u_32 { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - let mut tag_ = ::sse_decode(deserializer); - match tag_ { - 0 => { - let mut var_value = ::sse_decode(deserializer); - return crate::api::minimal::__delegate_Result__String_u_32::ok { - value: var_value, - }; - } - 1 => { - let mut var_value = ::sse_decode(deserializer); - return crate::api::minimal::__delegate_Result__String_u_32::err { - value: var_value, - }; - } - _ => { - unimplemented!(""); - } - } - } -} - impl SseDecode for i32 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -303,31 +278,6 @@ fn pde_ffi_dispatcher_sync_impl( // Section: rust2dart -// Codec=Dco (DartCObject based), see doc to use other codecs -impl flutter_rust_bridge::IntoDart for crate::api::minimal::__delegate_Result__String_u_32 { - fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { - match self { - crate::api::minimal::__delegate_Result__String_u_32::ok { value } => { - [0.into_dart(), value.into_into_dart().into_dart()].into_dart() - } - crate::api::minimal::__delegate_Result__String_u_32::err { value } => { - [1.into_dart(), value.into_into_dart().into_dart()].into_dart() - } - } - } -} -impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive - for crate::api::minimal::__delegate_Result__String_u_32 -{ -} -impl flutter_rust_bridge::IntoIntoDart - for crate::api::minimal::__delegate_Result__String_u_32 -{ - fn into_into_dart(self) -> crate::api::minimal::__delegate_Result__String_u_32 { - self - } -} - impl SseEncode for flutter_rust_bridge::DartOpaque { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -342,22 +292,6 @@ impl SseEncode for String { } } -impl SseEncode for crate::api::minimal::__delegate_Result__String_u_32 { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - match self { - crate::api::minimal::__delegate_Result__String_u_32::ok { value } => { - ::sse_encode(0, serializer); - ::sse_encode(value, serializer); - } - crate::api::minimal::__delegate_Result__String_u_32::err { value } => { - ::sse_encode(1, serializer); - ::sse_encode(value, serializer); - } - } - } -} - impl SseEncode for i32 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { From dcf415e4ae99407c30aee23b34f9885fff042dce Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:53:43 +0800 Subject: [PATCH 68/94] feat: more --- .../lib/flutter_rust_bridge_for_generated_common.dart | 1 + frb_dart/lib/src/misc/box.dart | 8 ++++++++ 2 files changed, 9 insertions(+) create mode 100644 frb_dart/lib/src/misc/box.dart diff --git a/frb_dart/lib/flutter_rust_bridge_for_generated_common.dart b/frb_dart/lib/flutter_rust_bridge_for_generated_common.dart index 015e60800c..bf8eec4e4b 100644 --- a/frb_dart/lib/flutter_rust_bridge_for_generated_common.dart +++ b/frb_dart/lib/flutter_rust_bridge_for_generated_common.dart @@ -23,6 +23,7 @@ export 'src/main_components/entrypoint.dart'; export 'src/main_components/handler.dart'; export 'src/main_components/wire.dart'; export 'src/manual_impl/_common.dart'; +export 'src/misc/box.dart'; export 'src/misc/rust_opaque.dart'; export 'src/rust_arc/_common.dart'; export 'src/stream/stream_sink.dart'; diff --git a/frb_dart/lib/src/misc/box.dart b/frb_dart/lib/src/misc/box.dart new file mode 100644 index 0000000000..a4d2c4e960 --- /dev/null +++ b/frb_dart/lib/src/misc/box.dart @@ -0,0 +1,8 @@ +/// {@macro flutter_rust_bridge.only_for_generated_code} +class Box { + /// {@macro flutter_rust_bridge.only_for_generated_code} + final T value; + + /// {@macro flutter_rust_bridge.only_for_generated_code} + const Box(this.value); +} From 69b8478ed3524e3d166c9b363fe578e14d5d6e85 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:54:33 +0800 Subject: [PATCH 69/94] feat: more --- .../generator/wire/dart/spec_generator/misc/ty/dart_fn.rs | 2 +- frb_example/dart_minimal/lib/src/rust/frb_generated.dart | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index 9013672667..e0254c27db 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -65,7 +65,7 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { sse_encode_{output_normal_safe_ident}(rawOutput.value, serializer); }} else {{ serializer.buffer.putUint8({action_error}); - sse_encode_{output_error_safe_ident}(rawError.value, serializer); + sse_encode_{output_error_safe_ident}(rawError!.value, serializer); }} final output = serializer.intoRaw(); diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index 1dea9ff027..370cc2586b 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -185,7 +185,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(rawOutput.value, serializer); } else { serializer.buffer.putUint8(1); - sse_encode_u_32(rawError.value, serializer); + sse_encode_u_32(rawError!.value, serializer); } final output = serializer.intoRaw(); From ac7e3932170a8bbd43d27d191ff49bb83d55e396 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:55:29 +0800 Subject: [PATCH 70/94] chore: simp --- .../lib/src/rust/frb_generated.dart | 54 ++++++++++--------- .../lib/src/rust/frb_generated.io.dart | 24 +++++---- .../lib/src/rust/frb_generated.web.dart | 24 +++++---- .../dart_minimal/rust/src/api/minimal.rs | 2 +- .../dart_minimal/rust/src/frb_generated.rs | 44 ++++++++------- 5 files changed, 81 insertions(+), 67 deletions(-) diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index 370cc2586b..59a5a9fdf7 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -142,7 +142,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_String_u_32( + sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( dartCallback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 3, port: port_); @@ -165,13 +165,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); Future Function(int, dynamic) - encode_DartFn_Inputs_String_Output_String_u_32( + encode_DartFn_Inputs_String_Output_String_AnyhowException( FutureOr Function(String) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_String(rawArg0); Box? rawOutput; - Box? rawError; + Box? rawError; try { rawOutput = Box(await raw(arg0)); } catch (e) { @@ -185,7 +185,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(rawOutput.value, serializer); } else { serializer.buffer.putUint8(1); - sse_encode_u_32(rawError!.value, serializer); + sse_encode_AnyhowException(rawError!.value, serializer); } final output = serializer.intoRaw(); @@ -197,9 +197,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { }; } + @protected + AnyhowException dco_decode_AnyhowException(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return AnyhowException(raw as String); + } + @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String_u_32(dynamic raw) { + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @@ -228,12 +235,6 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return raw as Uint8List; } - @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 @@ -252,6 +253,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return dcoDecodeI64OrU64(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 Object sse_decode_DartOpaque(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -279,12 +287,6 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return deserializer.buffer.getUint8List(len_); } - @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 @@ -309,11 +311,19 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void sse_encode_DartFn_Inputs_String_Output_String_u_32( + void sse_encode_AnyhowException( + AnyhowException self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + throw UnimplementedError('Unreachable ()'); + } + + @protected + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( FutureOr Function(String) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_Output_String_u_32(self), serializer); + encode_DartFn_Inputs_String_Output_String_AnyhowException(self), + serializer); } @protected @@ -345,12 +355,6 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { serializer.buffer.putUint8List(self); } - @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 diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart index 8e398f0d78..7dc373a0f4 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart @@ -18,9 +18,13 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { required super.portManager, }); + @protected + AnyhowException dco_decode_AnyhowException(dynamic raw); + @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String_u_32(dynamic raw); + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + dynamic raw); @protected Object dco_decode_DartOpaque(dynamic raw); @@ -34,9 +38,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); - @protected - int dco_decode_u_32(dynamic raw); - @protected int dco_decode_u_8(dynamic raw); @@ -46,6 +47,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected int dco_decode_usize(dynamic raw); + @protected + AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer); + @protected Object sse_decode_DartOpaque(SseDeserializer deserializer); @@ -58,9 +62,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); - @protected - int sse_decode_u_32(SseDeserializer deserializer); - @protected int sse_decode_u_8(SseDeserializer deserializer); @@ -74,7 +75,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { bool sse_decode_bool(SseDeserializer deserializer); @protected - void sse_encode_DartFn_Inputs_String_Output_String_u_32( + void sse_encode_AnyhowException( + AnyhowException self, SseSerializer serializer); + + @protected + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( FutureOr Function(String) self, SseSerializer serializer); @protected @@ -90,9 +95,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_list_prim_u_8_strict( Uint8List self, SseSerializer serializer); - @protected - void sse_encode_u_32(int self, SseSerializer serializer); - @protected void sse_encode_u_8(int self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart index 5f4f0fb3df..3e0c4724d5 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart @@ -17,9 +17,13 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { required super.portManager, }); + @protected + AnyhowException dco_decode_AnyhowException(dynamic raw); + @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String_u_32(dynamic raw); + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + dynamic raw); @protected Object dco_decode_DartOpaque(dynamic raw); @@ -33,9 +37,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); - @protected - int dco_decode_u_32(dynamic raw); - @protected int dco_decode_u_8(dynamic raw); @@ -45,6 +46,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected int dco_decode_usize(dynamic raw); + @protected + AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer); + @protected Object sse_decode_DartOpaque(SseDeserializer deserializer); @@ -57,9 +61,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); - @protected - int sse_decode_u_32(SseDeserializer deserializer); - @protected int sse_decode_u_8(SseDeserializer deserializer); @@ -73,7 +74,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { bool sse_decode_bool(SseDeserializer deserializer); @protected - void sse_encode_DartFn_Inputs_String_Output_String_u_32( + void sse_encode_AnyhowException( + AnyhowException self, SseSerializer serializer); + + @protected + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( FutureOr Function(String) self, SseSerializer serializer); @protected @@ -89,9 +94,6 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_list_prim_u_8_strict( Uint8List self, SseSerializer serializer); - @protected - void sse_encode_u_32(int self, SseSerializer serializer); - @protected void sse_encode_u_8(int self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/rust/src/api/minimal.rs b/frb_example/dart_minimal/rust/src/api/minimal.rs index b2cb5dd225..7da80622be 100644 --- a/frb_example/dart_minimal/rust/src/api/minimal.rs +++ b/frb_example/dart_minimal/rust/src/api/minimal.rs @@ -9,6 +9,6 @@ pub fn minimal_adder(a: i32, b: i32) -> i32 { a + b } -pub async fn rust_function(dart_callback: impl Fn(String) -> DartFnFuture>) { +pub async fn rust_function(dart_callback: impl Fn(String) -> DartFnFuture>) { unimplemented!() } diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index 3a10f85ff7..b304f2fe0a 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -125,7 +125,7 @@ fn wire__crate__api__minimal__rust_function_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_dart_callback = decode_DartFn_Inputs_String_Output_String_u_32( + let api_dart_callback = decode_DartFn_Inputs_String_Output_String_AnyhowException( ::sse_decode(&mut deserializer), ); deserializer.end(); @@ -145,15 +145,19 @@ fn wire__crate__api__minimal__rust_function_impl( // Section: related_funcs -fn decode_DartFn_Inputs_String_Output_String_u_32( +fn decode_DartFn_Inputs_String_Output_String_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, -) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture> { +) -> impl Fn( + String, +) -> flutter_rust_bridge::DartFnFuture< + std::result::Result, +> { use flutter_rust_bridge::IntoDart; async fn body( dart_opaque: flutter_rust_bridge::DartOpaque, arg0: String, - ) -> std::result::Result { + ) -> std::result::Result { let args = vec![arg0.into_into_dart().into_dart()]; let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) @@ -163,7 +167,9 @@ fn decode_DartFn_Inputs_String_Output_String_u_32( let action = deserializer.cursor.read_u8().unwrap(); let ans = match action { 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), - 1 => std::result::Result::Err(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), _ => unreachable!(), }; deserializer.end(); @@ -180,6 +186,13 @@ fn decode_DartFn_Inputs_String_Output_String_u_32( // Section: dart2rust +impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + unreachable!(""); + } +} + impl SseDecode for flutter_rust_bridge::DartOpaque { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -215,13 +228,6 @@ impl SseDecode for Vec { } } -impl SseDecode for u32 { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - deserializer.cursor.read_u32::().unwrap() - } -} - impl SseDecode for u8 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -278,6 +284,13 @@ fn pde_ffi_dispatcher_sync_impl( // Section: rust2dart +impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(format!("{:?}", self), serializer); + } +} + impl SseEncode for flutter_rust_bridge::DartOpaque { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -309,13 +322,6 @@ impl SseEncode for Vec { } } -impl SseEncode for u32 { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - serializer.cursor.write_u32::(self).unwrap(); - } -} - impl SseEncode for u8 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { From 759be71496b860adf86fb4c2794e95ea45be04d7 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:56:14 +0800 Subject: [PATCH 71/94] feat: more --- .../generator/wire/dart/spec_generator/misc/ty/dart_fn.rs | 8 ++++---- frb_example/dart_minimal/lib/src/rust/frb_generated.dart | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs index e0254c27db..a6115512f1 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/misc/ty/dart_fn.rs @@ -44,7 +44,7 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { let action_error = DartFnOutputAction::Error as i32; let api_impl_body = format!( - " + r#" Future Function(int, {repeated_dynamics}) encode_{ir_safe_ident}({dart_api_type} raw) {{ return (callId, {raw_parameter_names}) async {{ @@ -54,8 +54,8 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { Box<{output_error_dart_api_type}>? rawError; try {{ rawOutput = Box(await raw({parameter_names})); - }} catch (e) {{ - rawError = Box(e); + }} catch (e, s) {{ + rawError = Box(AnyhowException("$e\n\n$s")); }} final serializer = SseSerializer(generalizedFrbRustBinding); @@ -73,7 +73,7 @@ impl<'a> WireDartGeneratorMiscTrait for DartFnWireDartGenerator<'a> { callId: callId, ptr: output.ptr, rustVecLen: output.rustVecLen, dataLen: output.dataLen); }}; }} - ", + "#, ); Some(Acc::new_common(WireDartOutputCode { api_impl_class_body: api_impl_body, diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index 59a5a9fdf7..7553fc655e 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -174,8 +174,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { Box? rawError; try { rawOutput = Box(await raw(arg0)); - } catch (e) { - rawError = Box(e); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); } final serializer = SseSerializer(generalizedFrbRustBinding); From 0f0f96f827fd23d976d7ba96c5499f987788e2b7 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:57:02 +0800 Subject: [PATCH 72/94] feat: more --- .../src/library/codegen/generator/codec/sse/ty/delegate.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs b/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs index 46396f93b2..81b4e29777 100644 --- a/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs +++ b/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs @@ -15,9 +15,10 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> { IrTypeDelegate::Array(_) => "self.inner".to_owned(), IrTypeDelegate::String => "utf8.encoder.convert(self)".to_owned(), IrTypeDelegate::PrimitiveEnum(_) => "self.index".to_owned(), - IrTypeDelegate::Backtrace | IrTypeDelegate::AnyhowException => { + IrTypeDelegate::Backtrace => { return Some(format!("{};", lang.throw_unreachable(""))); } + IrTypeDelegate::AnyhowException => TODO, IrTypeDelegate::Map(_) => { "self.entries.map((e) => (e.key, e.value)).toList()".to_owned() } @@ -128,9 +129,10 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> { IrTypeDelegate::PrimitiveEnum(inner) => { rust_decode_primitive_enum(inner, self.context.ir_pack, "inner") } - IrTypeDelegate::Backtrace | IrTypeDelegate::AnyhowException => { + IrTypeDelegate::Backtrace => { return Some(format!("{};", lang.throw_unreachable(""))); } + IrTypeDelegate::AnyhowException => TODO, IrTypeDelegate::Map(_) => "inner.into_iter().collect()".to_owned(), IrTypeDelegate::Set(_) => "inner.into_iter().collect()".to_owned(), IrTypeDelegate::Time(ir) => { From e96f3e47a65bb9a858db0aa0e6c1322fdae5e054 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:58:17 +0800 Subject: [PATCH 73/94] feat: more --- .../src/library/codegen/generator/codec/sse/ty/delegate.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs b/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs index 81b4e29777..f259f23701 100644 --- a/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs +++ b/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs @@ -18,7 +18,7 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> { IrTypeDelegate::Backtrace => { return Some(format!("{};", lang.throw_unreachable(""))); } - IrTypeDelegate::AnyhowException => TODO, + IrTypeDelegate::AnyhowException => "self.message", IrTypeDelegate::Map(_) => { "self.entries.map((e) => (e.key, e.value)).toList()".to_owned() } @@ -132,7 +132,7 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> { IrTypeDelegate::Backtrace => { return Some(format!("{};", lang.throw_unreachable(""))); } - IrTypeDelegate::AnyhowException => TODO, + IrTypeDelegate::AnyhowException => r#"anyhow::anyhow!("{}", inner)"#, IrTypeDelegate::Map(_) => "inner.into_iter().collect()".to_owned(), IrTypeDelegate::Set(_) => "inner.into_iter().collect()".to_owned(), IrTypeDelegate::Time(ir) => { From e161d7b1a8a5ec1476a234d9fb02f6b24c5981b9 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:58:42 +0800 Subject: [PATCH 74/94] fix: err --- .../src/library/codegen/generator/codec/sse/ty/delegate.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs b/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs index f259f23701..46b51098f6 100644 --- a/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs +++ b/frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs @@ -18,7 +18,7 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> { IrTypeDelegate::Backtrace => { return Some(format!("{};", lang.throw_unreachable(""))); } - IrTypeDelegate::AnyhowException => "self.message", + IrTypeDelegate::AnyhowException => "self.message".to_owned(), IrTypeDelegate::Map(_) => { "self.entries.map((e) => (e.key, e.value)).toList()".to_owned() } @@ -132,7 +132,7 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> { IrTypeDelegate::Backtrace => { return Some(format!("{};", lang.throw_unreachable(""))); } - IrTypeDelegate::AnyhowException => r#"anyhow::anyhow!("{}", inner)"#, + IrTypeDelegate::AnyhowException => r#"anyhow::anyhow!("{}", inner)"#.to_owned(), IrTypeDelegate::Map(_) => "inner.into_iter().collect()".to_owned(), IrTypeDelegate::Set(_) => "inner.into_iter().collect()".to_owned(), IrTypeDelegate::Time(ir) => { From 519513178246df4fdd053457a7632e2c6045255e Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:59:02 +0800 Subject: [PATCH 75/94] chore: codegen --- frb_example/dart_minimal/lib/src/rust/frb_generated.dart | 2 +- frb_example/dart_minimal/rust/src/frb_generated.rs | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index 7553fc655e..313875f43a 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -314,7 +314,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { void sse_encode_AnyhowException( AnyhowException self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs - throw UnimplementedError('Unreachable ()'); + sse_encode_String(self.message, serializer); } @protected diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index b304f2fe0a..520b195e29 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -189,7 +189,8 @@ fn decode_DartFn_Inputs_String_Output_String_AnyhowException( impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - unreachable!(""); + let mut inner = ::sse_decode(deserializer); + return anyhow::anyhow!("{}", inner); } } From bfd2e3cb162c2d9c36e1a3d476e712ed07bcafbb Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:59:32 +0800 Subject: [PATCH 76/94] chore: more demo --- frb_example/dart_minimal/rust/src/api/minimal.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/frb_example/dart_minimal/rust/src/api/minimal.rs b/frb_example/dart_minimal/rust/src/api/minimal.rs index 7da80622be..cc21eceec9 100644 --- a/frb_example/dart_minimal/rust/src/api/minimal.rs +++ b/frb_example/dart_minimal/rust/src/api/minimal.rs @@ -9,6 +9,10 @@ pub fn minimal_adder(a: i32, b: i32) -> i32 { a + b } -pub async fn rust_function(dart_callback: impl Fn(String) -> DartFnFuture>) { +pub async fn rust_function_1(dart_callback: impl Fn(String) -> DartFnFuture) { + unimplemented!() +} + +pub async fn rust_function_2(dart_callback: impl Fn(String) -> DartFnFuture>>) { unimplemented!() } From 3ab4a7e4753f9c900615248a5c72f7090c3575d9 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 13:59:44 +0800 Subject: [PATCH 77/94] chore: codegen --- .../lib/src/rust/api/minimal.dart | 11 +- .../lib/src/rust/frb_generated.dart | 119 +++++++++++++++--- .../lib/src/rust/frb_generated.io.dart | 17 ++- .../lib/src/rust/frb_generated.web.dart | 17 ++- .../dart_minimal/rust/src/frb_generated.rs | 91 ++++++++++++-- 5 files changed, 216 insertions(+), 39 deletions(-) diff --git a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart index 9cb3f3fdaf..d4b6bf8982 100644 --- a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart +++ b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart @@ -9,8 +9,13 @@ import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; Future minimalAdder({required int a, required int b, dynamic hint}) => RustLib.instance.api.crateApiMinimalMinimalAdder(a: a, b: b, hint: hint); -Future rustFunction( - {required FutureOr Function(String) dartCallback, +Future rustFunction1( + {required FutureOr Function(String) dartCallback, dynamic hint}) => + RustLib.instance.api + .crateApiMinimalRustFunction1(dartCallback: dartCallback, hint: hint); + +Future rustFunction2( + {required FutureOr Function(String) dartCallback, dynamic hint}) => RustLib.instance.api - .crateApiMinimalRustFunction(dartCallback: dartCallback, hint: hint); + .crateApiMinimalRustFunction2(dartCallback: dartCallback, hint: hint); diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index 313875f43a..ee617a75ca 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -56,7 +56,7 @@ class RustLib extends BaseEntrypoint { String get codegenVersion => '2.0.0-dev.34'; @override - int get rustContentHash => -957330701; + int get rustContentHash => -431697752; static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig( @@ -72,8 +72,12 @@ abstract class RustLibApi extends BaseApi { Future crateApiMinimalMinimalAdder( {required int a, required int b, dynamic hint}); - Future crateApiMinimalRustFunction( - {required FutureOr Function(String) dartCallback, dynamic hint}); + Future crateApiMinimalRustFunction1( + {required FutureOr Function(String) dartCallback, dynamic hint}); + + Future crateApiMinimalRustFunction2( + {required FutureOr Function(String) dartCallback, + dynamic hint}); } class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @@ -137,12 +141,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); @override - Future crateApiMinimalRustFunction( - {required FutureOr Function(String) dartCallback, dynamic hint}) { + Future crateApiMinimalRustFunction1( + {required FutureOr Function(String) dartCallback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + sse_encode_DartFn_Inputs_String_Output_i_32_String( dartCallback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 3, port: port_); @@ -151,26 +155,88 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { decodeSuccessData: sse_decode_unit, decodeErrorData: null, ), - constMeta: kCrateApiMinimalRustFunctionConstMeta, + constMeta: kCrateApiMinimalRustFunction1ConstMeta, + argValues: [dartCallback], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta get kCrateApiMinimalRustFunction1ConstMeta => + const TaskConstMeta( + debugName: "rust_function_1", + argNames: ["dartCallback"], + ); + + @override + Future crateApiMinimalRustFunction2( + {required FutureOr Function(String) dartCallback, + dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( + dartCallback, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 4, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: kCrateApiMinimalRustFunction2ConstMeta, argValues: [dartCallback], apiImpl: this, hint: hint, )); } - TaskConstMeta get kCrateApiMinimalRustFunctionConstMeta => + TaskConstMeta get kCrateApiMinimalRustFunction2ConstMeta => const TaskConstMeta( - debugName: "rust_function", + debugName: "rust_function_2", argNames: ["dartCallback"], ); Future Function(int, dynamic) - encode_DartFn_Inputs_String_Output_String_AnyhowException( - FutureOr Function(String) raw) { + encode_DartFn_Inputs_String_Output_i_32_String( + FutureOr Function(String) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_String(rawArg0); - Box? rawOutput; + Box? rawOutput; + Box? 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_i_32(rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_String(rawError!.value, serializer); + } + final output = serializer.intoRaw(); + + generalizedFrbRustBinding.dartFnDeliverOutput( + callId: callId, + ptr: output.ptr, + rustVecLen: output.rustVecLen, + dataLen: output.dataLen); + }; + } + + Future Function(int, dynamic) + encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( + FutureOr Function(String) raw) { + return (callId, rawArg0) async { + final arg0 = dco_decode_String(rawArg0); + + Box? rawOutput; Box? rawError; try { rawOutput = Box(await raw(arg0)); @@ -182,7 +248,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { assert((rawOutput != null) ^ (rawError != null)); if (rawOutput != null) { serializer.buffer.putUint8(0); - sse_encode_String(rawOutput.value, serializer); + sse_encode_list_prim_u_8_strict(rawOutput.value, serializer); } else { serializer.buffer.putUint8(1); sse_encode_AnyhowException(rawError!.value, serializer); @@ -204,8 +270,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_i_32_String(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError(''); + } + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -318,11 +391,21 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer) { + void sse_encode_DartFn_Inputs_String_Output_i_32_String( + FutureOr Function(String) self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_DartOpaque( + encode_DartFn_Inputs_String_Output_i_32_String(self), serializer); + } + + @protected + void + sse_encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_Output_String_AnyhowException(self), + encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( + self), serializer); } diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart index 7dc373a0f4..723fdcdb03 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart @@ -22,8 +22,12 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { AnyhowException dco_decode_AnyhowException(dynamic raw); @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_i_32_String(dynamic raw); + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( dynamic raw); @protected @@ -79,8 +83,13 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { AnyhowException self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer); + void sse_encode_DartFn_Inputs_String_Output_i_32_String( + FutureOr Function(String) self, SseSerializer serializer); + + @protected + void + sse_encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer); @protected void sse_encode_DartOpaque(Object self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart index 3e0c4724d5..f36e037daf 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart @@ -21,8 +21,12 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { AnyhowException dco_decode_AnyhowException(dynamic raw); @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_i_32_String(dynamic raw); + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( dynamic raw); @protected @@ -78,8 +82,13 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { AnyhowException self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer); + void sse_encode_DartFn_Inputs_String_Output_i_32_String( + FutureOr Function(String) self, SseSerializer serializer); + + @protected + void + sse_encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer); @protected void sse_encode_DartOpaque(Object self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index 520b195e29..ae18aec5ee 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -31,7 +31,7 @@ flutter_rust_bridge::frb_generated_boilerplate!( default_rust_auto_opaque = RustAutoOpaqueMoi, ); pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.34"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -957330701; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -431697752; // Section: executor @@ -103,7 +103,7 @@ fn wire__crate__api__minimal__minimal_adder_impl( }, ) } -fn wire__crate__api__minimal__rust_function_impl( +fn wire__crate__api__minimal__rust_function_1_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, @@ -111,7 +111,7 @@ fn wire__crate__api__minimal__rust_function_impl( ) { FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( flutter_rust_bridge::for_generated::TaskInfo { - debug_name: "rust_function", + debug_name: "rust_function_1", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, @@ -125,7 +125,7 @@ fn wire__crate__api__minimal__rust_function_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_dart_callback = decode_DartFn_Inputs_String_Output_String_AnyhowException( + let api_dart_callback = decode_DartFn_Inputs_String_Output_i_32_String( ::sse_decode(&mut deserializer), ); deserializer.end(); @@ -133,7 +133,47 @@ fn wire__crate__api__minimal__rust_function_impl( transform_result_sse( (move || async move { Result::<_, ()>::Ok( - crate::api::minimal::rust_function(api_dart_callback).await, + crate::api::minimal::rust_function_1(api_dart_callback).await, + ) + })() + .await, + ) + } + }, + ) +} +fn wire__crate__api__minimal__rust_function_2_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "rust_function_2", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_dart_callback = + decode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( + ::sse_decode(&mut deserializer), + ); + deserializer.end(); + move |context| async move { + transform_result_sse( + (move || async move { + Result::<_, ()>::Ok( + crate::api::minimal::rust_function_2(api_dart_callback).await, ) })() .await, @@ -145,19 +185,49 @@ fn wire__crate__api__minimal__rust_function_impl( // Section: related_funcs -fn decode_DartFn_Inputs_String_Output_String_AnyhowException( +fn decode_DartFn_Inputs_String_Output_i_32_String( + dart_opaque: flutter_rust_bridge::DartOpaque, +) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture { + use flutter_rust_bridge::IntoDart; + + async fn body(dart_opaque: flutter_rust_bridge::DartOpaque, arg0: String) -> i32 { + let args = vec![arg0.into_into_dart().into_dart()]; + let message = FLUTTER_RUST_BRIDGE_HANDLER + .dart_fn_invoke(dart_opaque, args) + .await; + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err(::sse_decode(&mut deserializer)), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans + } + + move |arg0: String| { + flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body( + dart_opaque.clone(), + arg0, + )) + } +} +fn decode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( String, ) -> flutter_rust_bridge::DartFnFuture< - std::result::Result, + std::result::Result, flutter_rust_bridge::for_generated::anyhow::Error>, > { use flutter_rust_bridge::IntoDart; async fn body( dart_opaque: flutter_rust_bridge::DartOpaque, arg0: String, - ) -> std::result::Result { + ) -> std::result::Result, flutter_rust_bridge::for_generated::anyhow::Error> { let args = vec![arg0.into_into_dart().into_dart()]; let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) @@ -166,7 +236,7 @@ fn decode_DartFn_Inputs_String_Output_String_AnyhowException( let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); let action = deserializer.cursor.read_u8().unwrap(); let ans = match action { - 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), + 0 => std::result::Result::Ok(>::sse_decode(&mut deserializer)), 1 => std::result::Result::Err( ::sse_decode(&mut deserializer), ), @@ -266,7 +336,8 @@ fn pde_ffi_dispatcher_primary_impl( match func_id { 1 => wire__crate__api__minimal__init_app_impl(port, ptr, rust_vec_len, data_len), 2 => wire__crate__api__minimal__minimal_adder_impl(port, ptr, rust_vec_len, data_len), - 3 => wire__crate__api__minimal__rust_function_impl(port, ptr, rust_vec_len, data_len), + 3 => wire__crate__api__minimal__rust_function_1_impl(port, ptr, rust_vec_len, data_len), + 4 => wire__crate__api__minimal__rust_function_2_impl(port, ptr, rust_vec_len, data_len), _ => unreachable!(), } } From 52e1522f214177a9b159c3590df926524ba6a76b Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 14:00:12 +0800 Subject: [PATCH 78/94] fix: err --- .../library/codegen/parser/type_parser/dart_fn.rs | 2 +- .../dart_minimal/lib/src/rust/frb_generated.dart | 15 ++++++++------- .../lib/src/rust/frb_generated.io.dart | 4 ++-- .../lib/src/rust/frb_generated.web.dart | 4 ++-- .../dart_minimal/rust/src/frb_generated.rs | 8 +++++--- 5 files changed, 18 insertions(+), 15 deletions(-) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 6255f625cb..5d1c930afe 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -100,7 +100,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { } } -const FALLBACK_ERROR_TYPE: IrType = IrType::Delegate(IrTypeDelegate::String); +const FALLBACK_ERROR_TYPE: IrType = IrType::Delegate(IrTypeDelegate::AnyhowException); // // Use this unit "test" to see how a type will be parsed into a tree // #[cfg(test)] diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index ee617a75ca..245e093fb3 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -146,7 +146,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_i_32_String( + sse_encode_DartFn_Inputs_String_Output_i_32_AnyhowException( dartCallback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 3, port: port_); @@ -198,13 +198,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); Future Function(int, dynamic) - encode_DartFn_Inputs_String_Output_i_32_String( + encode_DartFn_Inputs_String_Output_i_32_AnyhowException( FutureOr Function(String) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_String(rawArg0); Box? rawOutput; - Box? rawError; + Box? rawError; try { rawOutput = Box(await raw(arg0)); } catch (e, s) { @@ -218,7 +218,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(rawOutput.value, serializer); } else { serializer.buffer.putUint8(1); - sse_encode_String(rawError!.value, serializer); + sse_encode_AnyhowException(rawError!.value, serializer); } final output = serializer.intoRaw(); @@ -271,7 +271,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_i_32_String(dynamic raw) { + dco_decode_DartFn_Inputs_String_Output_i_32_AnyhowException(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @@ -391,11 +391,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void sse_encode_DartFn_Inputs_String_Output_i_32_String( + void sse_encode_DartFn_Inputs_String_Output_i_32_AnyhowException( FutureOr Function(String) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_Output_i_32_String(self), serializer); + encode_DartFn_Inputs_String_Output_i_32_AnyhowException(self), + serializer); } @protected diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart index 723fdcdb03..a61e1d6fe8 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart @@ -23,7 +23,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_i_32_String(dynamic raw); + dco_decode_DartFn_Inputs_String_Output_i_32_AnyhowException(dynamic raw); @protected FutureOr Function(String) @@ -83,7 +83,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { AnyhowException self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_String_Output_i_32_String( + void sse_encode_DartFn_Inputs_String_Output_i_32_AnyhowException( FutureOr Function(String) self, SseSerializer serializer); @protected diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart index f36e037daf..8b310c7f1f 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart @@ -22,7 +22,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_i_32_String(dynamic raw); + dco_decode_DartFn_Inputs_String_Output_i_32_AnyhowException(dynamic raw); @protected FutureOr Function(String) @@ -82,7 +82,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { AnyhowException self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_String_Output_i_32_String( + void sse_encode_DartFn_Inputs_String_Output_i_32_AnyhowException( FutureOr Function(String) self, SseSerializer serializer); @protected diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index ae18aec5ee..c1b9b70d43 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -125,7 +125,7 @@ fn wire__crate__api__minimal__rust_function_1_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_dart_callback = decode_DartFn_Inputs_String_Output_i_32_String( + let api_dart_callback = decode_DartFn_Inputs_String_Output_i_32_AnyhowException( ::sse_decode(&mut deserializer), ); deserializer.end(); @@ -185,7 +185,7 @@ fn wire__crate__api__minimal__rust_function_2_impl( // Section: related_funcs -fn decode_DartFn_Inputs_String_Output_i_32_String( +fn decode_DartFn_Inputs_String_Output_i_32_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture { use flutter_rust_bridge::IntoDart; @@ -200,7 +200,9 @@ fn decode_DartFn_Inputs_String_Output_i_32_String( let action = deserializer.cursor.read_u8().unwrap(); let ans = match action { 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), - 1 => std::result::Result::Err(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), _ => unreachable!(), }; deserializer.end(); From 29c5e6cb605825fd939c44afae0f38e608ff6fe6 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 14:03:29 +0800 Subject: [PATCH 79/94] feat: test --- frb_example/pure_dart/rust/src/api/dart_fn.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/frb_example/pure_dart/rust/src/api/dart_fn.rs b/frb_example/pure_dart/rust/src/api/dart_fn.rs index 97b53cb84e..2041302b74 100644 --- a/frb_example/pure_dart/rust/src/api/dart_fn.rs +++ b/frb_example/pure_dart/rust/src/api/dart_fn.rs @@ -63,3 +63,10 @@ pub async fn rust_call_dart_multi_times_twin_normal( callback().await; } } + +pub async fn rust_call_dart_return_result_twin_normal( + callback: impl Fn(i32) -> DartFnFuture>, + expect_return_ok: bool, +) { + assert_eq!(callback().await.is_ok(), expect_return_ok); +} From fa22e1b29185565f64cf0f99b3a8986e654384f1 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 14:04:00 +0800 Subject: [PATCH 80/94] feat: more --- frb_example/pure_dart/rust/src/api/dart_fn.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/frb_example/pure_dart/rust/src/api/dart_fn.rs b/frb_example/pure_dart/rust/src/api/dart_fn.rs index 2041302b74..3c5361fc60 100644 --- a/frb_example/pure_dart/rust/src/api/dart_fn.rs +++ b/frb_example/pure_dart/rust/src/api/dart_fn.rs @@ -65,8 +65,8 @@ pub async fn rust_call_dart_multi_times_twin_normal( } pub async fn rust_call_dart_return_result_twin_normal( - callback: impl Fn(i32) -> DartFnFuture>, - expect_return_ok: bool, + callback: impl Fn(String) -> DartFnFuture>, + expect_output: Option, ) { - assert_eq!(callback().await.is_ok(), expect_return_ok); + assert_eq!(callback("hello".to_owned()).await.ok(), expect_output); } From 19209746dfdb83af466c4cc8935a17e484852717 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 14:05:22 +0800 Subject: [PATCH 81/94] feat: more --- frb_example/pure_dart/rust/src/api/dart_fn.rs | 2 +- frb_example/pure_dart/test/api/dart_fn_test.dart | 13 +++++++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/frb_example/pure_dart/rust/src/api/dart_fn.rs b/frb_example/pure_dart/rust/src/api/dart_fn.rs index 3c5361fc60..8383ea9e36 100644 --- a/frb_example/pure_dart/rust/src/api/dart_fn.rs +++ b/frb_example/pure_dart/rust/src/api/dart_fn.rs @@ -68,5 +68,5 @@ pub async fn rust_call_dart_return_result_twin_normal( callback: impl Fn(String) -> DartFnFuture>, expect_output: Option, ) { - assert_eq!(callback("hello".to_owned()).await.ok(), expect_output); + assert_eq!(callback("hi".to_owned()).await.ok(), expect_output); } diff --git a/frb_example/pure_dart/test/api/dart_fn_test.dart b/frb_example/pure_dart/test/api/dart_fn_test.dart index 22a8a24b75..7ddaac2868 100644 --- a/frb_example/pure_dart/test/api/dart_fn_test.dart +++ b/frb_example/pure_dart/test/api/dart_fn_test.dart @@ -81,4 +81,17 @@ Future main({bool skipRustLibInit = false}) async { callback: () => callCount++, numTimes: 10); expect(callCount, 10); }); + + group('rustCallDartReturnResultTwinNormal', () { + test('when normal', () async { + await rustCallDartReturnResultTwinNormal( + callback: (s) => s * 2, expectOutput: "hihi"); + }); + + test('when error', () async { + await rustCallDartReturnResultTwinNormal( + callback: (s) => throw Exception('dummy exception'), + expectOutput: null); + }); + }); } From 0bdc7fda97bd9b153b7c10e362531d69aa6a8a44 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 14:06:08 +0800 Subject: [PATCH 82/94] chore: more demo --- .../lib/src/rust/api/minimal.dart | 14 +- .../lib/src/rust/frb_generated.dart | 161 ++++++------------ .../lib/src/rust/frb_generated.io.dart | 26 +-- .../lib/src/rust/frb_generated.web.dart | 26 +-- .../dart_minimal/rust/src/api/minimal.rs | 11 +- .../dart_minimal/rust/src/frb_generated.rs | 124 +++++--------- .../dart_minimal/test/minimal_test.dart | 13 ++ 7 files changed, 145 insertions(+), 230 deletions(-) diff --git a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart index d4b6bf8982..8bed5d889a 100644 --- a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart +++ b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart @@ -9,13 +9,9 @@ import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; Future minimalAdder({required int a, required int b, dynamic hint}) => RustLib.instance.api.crateApiMinimalMinimalAdder(a: a, b: b, hint: hint); -Future rustFunction1( - {required FutureOr Function(String) dartCallback, dynamic hint}) => - RustLib.instance.api - .crateApiMinimalRustFunction1(dartCallback: dartCallback, hint: hint); - -Future rustFunction2( - {required FutureOr Function(String) dartCallback, +Future rustCallDartReturnResultTwinNormal( + {required FutureOr Function(String) callback, + String? expectOutput, dynamic hint}) => - RustLib.instance.api - .crateApiMinimalRustFunction2(dartCallback: dartCallback, hint: hint); + RustLib.instance.api.crateApiMinimalRustCallDartReturnResultTwinNormal( + callback: callback, expectOutput: expectOutput, hint: hint); diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index 245e093fb3..5b51d2b232 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -56,7 +56,7 @@ class RustLib extends BaseEntrypoint { String get codegenVersion => '2.0.0-dev.34'; @override - int get rustContentHash => -431697752; + int get rustContentHash => 471216942; static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig( @@ -72,11 +72,9 @@ abstract class RustLibApi extends BaseApi { Future crateApiMinimalMinimalAdder( {required int a, required int b, dynamic hint}); - Future crateApiMinimalRustFunction1( - {required FutureOr Function(String) dartCallback, dynamic hint}); - - Future crateApiMinimalRustFunction2( - {required FutureOr Function(String) dartCallback, + Future crateApiMinimalRustCallDartReturnResultTwinNormal( + {required FutureOr Function(String) callback, + String? expectOutput, dynamic hint}); } @@ -141,69 +139,44 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); @override - Future crateApiMinimalRustFunction1( - {required FutureOr Function(String) dartCallback, dynamic hint}) { - return handler.executeNormal(NormalTask( - callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_i_32_AnyhowException( - dartCallback, serializer); - pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 3, port: port_); - }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: null, - ), - constMeta: kCrateApiMinimalRustFunction1ConstMeta, - argValues: [dartCallback], - apiImpl: this, - hint: hint, - )); - } - - TaskConstMeta get kCrateApiMinimalRustFunction1ConstMeta => - const TaskConstMeta( - debugName: "rust_function_1", - argNames: ["dartCallback"], - ); - - @override - Future crateApiMinimalRustFunction2( - {required FutureOr Function(String) dartCallback, + Future crateApiMinimalRustCallDartReturnResultTwinNormal( + {required FutureOr Function(String) callback, + String? expectOutput, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( - dartCallback, serializer); + sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + callback, serializer); + sse_encode_opt_String(expectOutput, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 4, port: port_); + funcId: 3, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, decodeErrorData: null, ), - constMeta: kCrateApiMinimalRustFunction2ConstMeta, - argValues: [dartCallback], + constMeta: kCrateApiMinimalRustCallDartReturnResultTwinNormalConstMeta, + argValues: [callback, expectOutput], apiImpl: this, hint: hint, )); } - TaskConstMeta get kCrateApiMinimalRustFunction2ConstMeta => - const TaskConstMeta( - debugName: "rust_function_2", - argNames: ["dartCallback"], - ); + TaskConstMeta + get kCrateApiMinimalRustCallDartReturnResultTwinNormalConstMeta => + const TaskConstMeta( + debugName: "rust_call_dart_return_result_twin_normal", + argNames: ["callback", "expectOutput"], + ); Future Function(int, dynamic) - encode_DartFn_Inputs_String_Output_i_32_AnyhowException( - FutureOr Function(String) raw) { + encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_String(rawArg0); - Box? rawOutput; + Box? rawOutput; Box? rawError; try { rawOutput = Box(await raw(arg0)); @@ -215,40 +188,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { assert((rawOutput != null) ^ (rawError != null)); if (rawOutput != null) { serializer.buffer.putUint8(0); - sse_encode_i_32(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 Function(int, dynamic) - encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( - FutureOr Function(String) raw) { - return (callId, rawArg0) async { - final arg0 = dco_decode_String(rawArg0); - - Box? rawOutput; - Box? 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_list_prim_u_8_strict(rawOutput.value, serializer); + sse_encode_String(rawOutput.value, serializer); } else { serializer.buffer.putUint8(1); sse_encode_AnyhowException(rawError!.value, serializer); @@ -270,15 +210,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_i_32_AnyhowException(dynamic raw) { - // Codec=Dco (DartCObject based), see doc to use other codecs - throw UnimplementedError(''); - } - - @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -308,6 +241,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return raw as Uint8List; } + @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 int dco_decode_u_8(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs @@ -360,6 +299,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return deserializer.buffer.getUint8List(len_); } + @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 int sse_decode_u_8(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -391,22 +341,11 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void sse_encode_DartFn_Inputs_String_Output_i_32_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer) { + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_Output_i_32_AnyhowException(self), - serializer); - } - - @protected - void - sse_encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - sse_encode_DartOpaque( - encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( - self), + encode_DartFn_Inputs_String_Output_String_AnyhowException(self), serializer); } @@ -439,6 +378,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { serializer.buffer.putUint8List(self); } + @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_u_8(int self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart index a61e1d6fe8..5116f69de5 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart @@ -22,12 +22,8 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { AnyhowException dco_decode_AnyhowException(dynamic raw); @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_i_32_AnyhowException(dynamic raw); - - @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( dynamic raw); @protected @@ -42,6 +38,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); + @protected + String? dco_decode_opt_String(dynamic raw); + @protected int dco_decode_u_8(dynamic raw); @@ -66,6 +65,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); + @protected + String? sse_decode_opt_String(SseDeserializer deserializer); + @protected int sse_decode_u_8(SseDeserializer deserializer); @@ -83,13 +85,8 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { AnyhowException self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_String_Output_i_32_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer); - - @protected - void - sse_encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer); + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer); @protected void sse_encode_DartOpaque(Object self, SseSerializer serializer); @@ -104,6 +101,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_list_prim_u_8_strict( Uint8List self, SseSerializer serializer); + @protected + void sse_encode_opt_String(String? self, SseSerializer serializer); + @protected void sse_encode_u_8(int self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart index 8b310c7f1f..323a9c2ac7 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart @@ -21,12 +21,8 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { AnyhowException dco_decode_AnyhowException(dynamic raw); @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_i_32_AnyhowException(dynamic raw); - - @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( dynamic raw); @protected @@ -41,6 +37,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); + @protected + String? dco_decode_opt_String(dynamic raw); + @protected int dco_decode_u_8(dynamic raw); @@ -65,6 +64,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); + @protected + String? sse_decode_opt_String(SseDeserializer deserializer); + @protected int sse_decode_u_8(SseDeserializer deserializer); @@ -82,13 +84,8 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { AnyhowException self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_String_Output_i_32_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer); - - @protected - void - sse_encode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer); + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer); @protected void sse_encode_DartOpaque(Object self, SseSerializer serializer); @@ -103,6 +100,9 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_list_prim_u_8_strict( Uint8List self, SseSerializer serializer); + @protected + void sse_encode_opt_String(String? self, SseSerializer serializer); + @protected void sse_encode_u_8(int self, SseSerializer serializer); diff --git a/frb_example/dart_minimal/rust/src/api/minimal.rs b/frb_example/dart_minimal/rust/src/api/minimal.rs index cc21eceec9..3b9de75862 100644 --- a/frb_example/dart_minimal/rust/src/api/minimal.rs +++ b/frb_example/dart_minimal/rust/src/api/minimal.rs @@ -9,10 +9,9 @@ pub fn minimal_adder(a: i32, b: i32) -> i32 { a + b } -pub async fn rust_function_1(dart_callback: impl Fn(String) -> DartFnFuture) { - unimplemented!() -} - -pub async fn rust_function_2(dart_callback: impl Fn(String) -> DartFnFuture>>) { - unimplemented!() +pub async fn rust_call_dart_return_result_twin_normal( + callback: impl Fn(String) -> DartFnFuture>, + expect_output: Option, +) { + assert_eq!(callback("hi".to_owned()).await.ok(), expect_output); } diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index c1b9b70d43..23c382adc7 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -31,7 +31,7 @@ flutter_rust_bridge::frb_generated_boilerplate!( default_rust_auto_opaque = RustAutoOpaqueMoi, ); pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.34"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -431697752; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 471216942; // Section: executor @@ -103,7 +103,7 @@ fn wire__crate__api__minimal__minimal_adder_impl( }, ) } -fn wire__crate__api__minimal__rust_function_1_impl( +fn wire__crate__api__minimal__rust_call_dart_return_result_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, @@ -111,7 +111,7 @@ fn wire__crate__api__minimal__rust_function_1_impl( ) { FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( flutter_rust_bridge::for_generated::TaskInfo { - debug_name: "rust_function_1", + debug_name: "rust_call_dart_return_result_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, @@ -125,55 +125,20 @@ fn wire__crate__api__minimal__rust_function_1_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_dart_callback = decode_DartFn_Inputs_String_Output_i_32_AnyhowException( + let api_callback = decode_DartFn_Inputs_String_Output_String_AnyhowException( ::sse_decode(&mut deserializer), ); + let api_expect_output = >::sse_decode(&mut deserializer); deserializer.end(); move |context| async move { transform_result_sse( (move || async move { Result::<_, ()>::Ok( - crate::api::minimal::rust_function_1(api_dart_callback).await, - ) - })() - .await, - ) - } - }, - ) -} -fn wire__crate__api__minimal__rust_function_2_impl( - port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( - flutter_rust_bridge::for_generated::TaskInfo { - debug_name: "rust_function_2", - port: Some(port_), - mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, - }, - move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_dart_callback = - decode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( - ::sse_decode(&mut deserializer), - ); - deserializer.end(); - move |context| async move { - transform_result_sse( - (move || async move { - Result::<_, ()>::Ok( - crate::api::minimal::rust_function_2(api_dart_callback).await, + crate::api::minimal::rust_call_dart_return_result_twin_normal( + api_callback, + api_expect_output, + ) + .await, ) })() .await, @@ -185,51 +150,19 @@ fn wire__crate__api__minimal__rust_function_2_impl( // Section: related_funcs -fn decode_DartFn_Inputs_String_Output_i_32_AnyhowException( - dart_opaque: flutter_rust_bridge::DartOpaque, -) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture { - use flutter_rust_bridge::IntoDart; - - async fn body(dart_opaque: flutter_rust_bridge::DartOpaque, arg0: String) -> i32 { - let args = vec![arg0.into_into_dart().into_dart()]; - let message = FLUTTER_RUST_BRIDGE_HANDLER - .dart_fn_invoke(dart_opaque, args) - .await; - - let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let action = deserializer.cursor.read_u8().unwrap(); - let ans = match action { - 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), - 1 => std::result::Result::Err( - ::sse_decode(&mut deserializer), - ), - _ => unreachable!(), - }; - deserializer.end(); - let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); - ans - } - - move |arg0: String| { - flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body( - dart_opaque.clone(), - arg0, - )) - } -} -fn decode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( +fn decode_DartFn_Inputs_String_Output_String_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( String, ) -> flutter_rust_bridge::DartFnFuture< - std::result::Result, flutter_rust_bridge::for_generated::anyhow::Error>, + std::result::Result, > { use flutter_rust_bridge::IntoDart; async fn body( dart_opaque: flutter_rust_bridge::DartOpaque, arg0: String, - ) -> std::result::Result, flutter_rust_bridge::for_generated::anyhow::Error> { + ) -> std::result::Result { let args = vec![arg0.into_into_dart().into_dart()]; let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) @@ -238,7 +171,7 @@ fn decode_DartFn_Inputs_String_Output_list_prim_u_8_strict_AnyhowException( let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); let action = deserializer.cursor.read_u8().unwrap(); let ans = match action { - 0 => std::result::Result::Ok(>::sse_decode(&mut deserializer)), + 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), 1 => std::result::Result::Err( ::sse_decode(&mut deserializer), ), @@ -301,6 +234,17 @@ impl SseDecode for Vec { } } +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode(deserializer)); + } else { + return None; + } + } +} + impl SseDecode for u8 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -338,8 +282,12 @@ fn pde_ffi_dispatcher_primary_impl( match func_id { 1 => wire__crate__api__minimal__init_app_impl(port, ptr, rust_vec_len, data_len), 2 => wire__crate__api__minimal__minimal_adder_impl(port, ptr, rust_vec_len, data_len), - 3 => wire__crate__api__minimal__rust_function_1_impl(port, ptr, rust_vec_len, data_len), - 4 => wire__crate__api__minimal__rust_function_2_impl(port, ptr, rust_vec_len, data_len), + 3 => wire__crate__api__minimal__rust_call_dart_return_result_twin_normal_impl( + port, + ptr, + rust_vec_len, + data_len, + ), _ => unreachable!(), } } @@ -396,6 +344,16 @@ impl SseEncode for Vec { } } +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + impl SseEncode for u8 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { diff --git a/frb_example/dart_minimal/test/minimal_test.dart b/frb_example/dart_minimal/test/minimal_test.dart index 7ad47f69d7..170b2a6b58 100644 --- a/frb_example/dart_minimal/test/minimal_test.dart +++ b/frb_example/dart_minimal/test/minimal_test.dart @@ -14,4 +14,17 @@ Future main() async { print('Action: Call rust (after)'); }); print('Action: Configure tests (end)'); + + group('rustCallDartReturnResultTwinNormal', () { + test('when normal', () async { + await rustCallDartReturnResultTwinNormal( + callback: (s) => s * 2, expectOutput: "hihi"); + }); + + test('when error', () async { + await rustCallDartReturnResultTwinNormal( + callback: (s) => throw Exception('dummy exception'), + expectOutput: null); + }); + }); } From 93901ed98fef25b8420e63f80c465c7076bbc5d4 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 14:07:12 +0800 Subject: [PATCH 83/94] chore: rm temp --- .../lib/src/rust/api/minimal.dart | 7 - .../lib/src/rust/frb_generated.dart | 234 +----------------- .../lib/src/rust/frb_generated.io.dart | 74 ------ .../lib/src/rust/frb_generated.web.dart | 74 ------ .../dart_minimal/rust/src/api/minimal.rs | 9 +- .../dart_minimal/rust/src/frb_generated.rs | 212 +--------------- .../dart_minimal/test/minimal_test.dart | 13 - 7 files changed, 3 insertions(+), 620 deletions(-) diff --git a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart index 8bed5d889a..534c389e97 100644 --- a/frb_example/dart_minimal/lib/src/rust/api/minimal.dart +++ b/frb_example/dart_minimal/lib/src/rust/api/minimal.dart @@ -8,10 +8,3 @@ import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; Future minimalAdder({required int a, required int b, dynamic hint}) => RustLib.instance.api.crateApiMinimalMinimalAdder(a: a, b: b, hint: hint); - -Future rustCallDartReturnResultTwinNormal( - {required FutureOr Function(String) callback, - String? expectOutput, - dynamic hint}) => - RustLib.instance.api.crateApiMinimalRustCallDartReturnResultTwinNormal( - callback: callback, expectOutput: expectOutput, hint: hint); diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart index 5b51d2b232..1af5f09a52 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -56,7 +56,7 @@ class RustLib extends BaseEntrypoint { String get codegenVersion => '2.0.0-dev.34'; @override - int get rustContentHash => 471216942; + int get rustContentHash => -2119384465; static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig( @@ -71,11 +71,6 @@ abstract class RustLibApi extends BaseApi { Future crateApiMinimalMinimalAdder( {required int a, required int b, dynamic hint}); - - Future crateApiMinimalRustCallDartReturnResultTwinNormal( - {required FutureOr Function(String) callback, - String? expectOutput, - dynamic hint}); } class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @@ -138,273 +133,46 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["a", "b"], ); - @override - Future crateApiMinimalRustCallDartReturnResultTwinNormal( - {required FutureOr Function(String) callback, - String? expectOutput, - dynamic hint}) { - return handler.executeNormal(NormalTask( - callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( - callback, serializer); - sse_encode_opt_String(expectOutput, serializer); - pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 3, port: port_); - }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: null, - ), - constMeta: kCrateApiMinimalRustCallDartReturnResultTwinNormalConstMeta, - argValues: [callback, expectOutput], - apiImpl: this, - hint: hint, - )); - } - - TaskConstMeta - get kCrateApiMinimalRustCallDartReturnResultTwinNormalConstMeta => - const TaskConstMeta( - debugName: "rust_call_dart_return_result_twin_normal", - argNames: ["callback", "expectOutput"], - ); - - Future Function(int, dynamic) - encode_DartFn_Inputs_String_Output_String_AnyhowException( - FutureOr Function(String) raw) { - return (callId, rawArg0) async { - final arg0 = dco_decode_String(rawArg0); - - Box? rawOutput; - Box? 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_String(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); - }; - } - - @protected - AnyhowException dco_decode_AnyhowException(dynamic raw) { - // Codec=Dco (DartCObject based), see doc to use other codecs - return AnyhowException(raw as String); - } - - @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String_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 - String dco_decode_String(dynamic raw) { - // Codec=Dco (DartCObject based), see doc to use other codecs - return raw as String; - } - @protected int dco_decode_i_32(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs return raw as 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 - 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 - 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 - int dco_decode_usize(dynamic raw) { - // Codec=Dco (DartCObject based), see doc to use other codecs - return dcoDecodeI64OrU64(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 - 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 - 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 int sse_decode_i_32(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs return deserializer.buffer.getInt32(); } - @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 - 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 - int sse_decode_u_8(SseDeserializer deserializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - return deserializer.buffer.getUint8(); - } - @protected void sse_decode_unit(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs } - @protected - int sse_decode_usize(SseDeserializer deserializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - return deserializer.buffer.getUint64(); - } - @protected bool sse_decode_bool(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs return deserializer.buffer.getUint8() != 0; } - @protected - void sse_encode_AnyhowException( - AnyhowException self, SseSerializer serializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - sse_encode_String(self.message, serializer); - } - - @protected - void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - sse_encode_DartOpaque( - encode_DartFn_Inputs_String_Output_String_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( - PlatformPointerUtil.ptrToInt(encodeDartOpaque( - self, portManager.dartHandlerPort, generalizedFrbRustBinding)), - 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_i_32(int self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs serializer.buffer.putInt32(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_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_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(int self, SseSerializer serializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - serializer.buffer.putUint64(self); - } - @protected void sse_encode_bool(bool self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart index 5116f69de5..db066194c9 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.io.dart @@ -18,101 +18,27 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { required super.portManager, }); - @protected - AnyhowException dco_decode_AnyhowException(dynamic raw); - - @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( - dynamic raw); - - @protected - Object dco_decode_DartOpaque(dynamic raw); - - @protected - String dco_decode_String(dynamic raw); - @protected int dco_decode_i_32(dynamic raw); - @protected - Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); - - @protected - String? dco_decode_opt_String(dynamic raw); - - @protected - int dco_decode_u_8(dynamic raw); - @protected void dco_decode_unit(dynamic raw); - @protected - int dco_decode_usize(dynamic raw); - - @protected - AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer); - - @protected - Object sse_decode_DartOpaque(SseDeserializer deserializer); - - @protected - String sse_decode_String(SseDeserializer deserializer); - @protected int sse_decode_i_32(SseDeserializer deserializer); - @protected - Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); - - @protected - String? sse_decode_opt_String(SseDeserializer deserializer); - - @protected - int sse_decode_u_8(SseDeserializer deserializer); - @protected void sse_decode_unit(SseDeserializer deserializer); - @protected - int sse_decode_usize(SseDeserializer deserializer); - @protected bool sse_decode_bool(SseDeserializer deserializer); - @protected - void sse_encode_AnyhowException( - AnyhowException self, SseSerializer serializer); - - @protected - void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer); - - @protected - void sse_encode_DartOpaque(Object self, SseSerializer serializer); - - @protected - void sse_encode_String(String self, SseSerializer serializer); - @protected void sse_encode_i_32(int self, SseSerializer serializer); - @protected - void sse_encode_list_prim_u_8_strict( - Uint8List self, SseSerializer serializer); - - @protected - void sse_encode_opt_String(String? self, SseSerializer serializer); - - @protected - void sse_encode_u_8(int self, SseSerializer serializer); - @protected void sse_encode_unit(void self, SseSerializer serializer); - @protected - void sse_encode_usize(int self, SseSerializer serializer); - @protected void sse_encode_bool(bool self, SseSerializer serializer); } diff --git a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart index 323a9c2ac7..33132575cd 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.web.dart @@ -17,101 +17,27 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { required super.portManager, }); - @protected - AnyhowException dco_decode_AnyhowException(dynamic raw); - - @protected - FutureOr Function(String) - dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( - dynamic raw); - - @protected - Object dco_decode_DartOpaque(dynamic raw); - - @protected - String dco_decode_String(dynamic raw); - @protected int dco_decode_i_32(dynamic raw); - @protected - Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); - - @protected - String? dco_decode_opt_String(dynamic raw); - - @protected - int dco_decode_u_8(dynamic raw); - @protected void dco_decode_unit(dynamic raw); - @protected - int dco_decode_usize(dynamic raw); - - @protected - AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer); - - @protected - Object sse_decode_DartOpaque(SseDeserializer deserializer); - - @protected - String sse_decode_String(SseDeserializer deserializer); - @protected int sse_decode_i_32(SseDeserializer deserializer); - @protected - Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); - - @protected - String? sse_decode_opt_String(SseDeserializer deserializer); - - @protected - int sse_decode_u_8(SseDeserializer deserializer); - @protected void sse_decode_unit(SseDeserializer deserializer); - @protected - int sse_decode_usize(SseDeserializer deserializer); - @protected bool sse_decode_bool(SseDeserializer deserializer); - @protected - void sse_encode_AnyhowException( - AnyhowException self, SseSerializer serializer); - - @protected - void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( - FutureOr Function(String) self, SseSerializer serializer); - - @protected - void sse_encode_DartOpaque(Object self, SseSerializer serializer); - - @protected - void sse_encode_String(String self, SseSerializer serializer); - @protected void sse_encode_i_32(int self, SseSerializer serializer); - @protected - void sse_encode_list_prim_u_8_strict( - Uint8List self, SseSerializer serializer); - - @protected - void sse_encode_opt_String(String? self, SseSerializer serializer); - - @protected - void sse_encode_u_8(int self, SseSerializer serializer); - @protected void sse_encode_unit(void self, SseSerializer serializer); - @protected - void sse_encode_usize(int self, SseSerializer serializer); - @protected void sse_encode_bool(bool self, SseSerializer serializer); } diff --git a/frb_example/dart_minimal/rust/src/api/minimal.rs b/frb_example/dart_minimal/rust/src/api/minimal.rs index 3b9de75862..517e29973f 100644 --- a/frb_example/dart_minimal/rust/src/api/minimal.rs +++ b/frb_example/dart_minimal/rust/src/api/minimal.rs @@ -1,4 +1,4 @@ -use flutter_rust_bridge::{frb, DartFnFuture}; +use flutter_rust_bridge::frb; #[frb(init)] pub fn init_app() { @@ -8,10 +8,3 @@ pub fn init_app() { pub fn minimal_adder(a: i32, b: i32) -> i32 { a + b } - -pub async fn rust_call_dart_return_result_twin_normal( - callback: impl Fn(String) -> DartFnFuture>, - expect_output: Option, -) { - assert_eq!(callback("hi".to_owned()).await.ok(), expect_output); -} diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index 23c382adc7..20b8e03143 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -31,7 +31,7 @@ flutter_rust_bridge::frb_generated_boilerplate!( default_rust_auto_opaque = RustAutoOpaqueMoi, ); pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.34"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 471216942; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -2119384465; // Section: executor @@ -103,118 +103,9 @@ fn wire__crate__api__minimal__minimal_adder_impl( }, ) } -fn wire__crate__api__minimal__rust_call_dart_return_result_twin_normal_impl( - port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( - flutter_rust_bridge::for_generated::TaskInfo { - debug_name: "rust_call_dart_return_result_twin_normal", - port: Some(port_), - mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, - }, - move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_String_Output_String_AnyhowException( - ::sse_decode(&mut deserializer), - ); - let api_expect_output = >::sse_decode(&mut deserializer); - deserializer.end(); - move |context| async move { - transform_result_sse( - (move || async move { - Result::<_, ()>::Ok( - crate::api::minimal::rust_call_dart_return_result_twin_normal( - api_callback, - api_expect_output, - ) - .await, - ) - })() - .await, - ) - } - }, - ) -} - -// Section: related_funcs - -fn decode_DartFn_Inputs_String_Output_String_AnyhowException( - dart_opaque: flutter_rust_bridge::DartOpaque, -) -> impl Fn( - String, -) -> flutter_rust_bridge::DartFnFuture< - std::result::Result, -> { - use flutter_rust_bridge::IntoDart; - - async fn body( - dart_opaque: flutter_rust_bridge::DartOpaque, - arg0: String, - ) -> std::result::Result { - let args = vec![arg0.into_into_dart().into_dart()]; - let message = FLUTTER_RUST_BRIDGE_HANDLER - .dart_fn_invoke(dart_opaque, args) - .await; - - let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let action = deserializer.cursor.read_u8().unwrap(); - let ans = match action { - 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), - 1 => std::result::Result::Err( - ::sse_decode(&mut deserializer), - ), - _ => unreachable!(), - }; - deserializer.end(); - ans - } - - move |arg0: String| { - flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body( - dart_opaque.clone(), - arg0, - )) - } -} // Section: dart2rust -impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - let mut inner = ::sse_decode(deserializer); - return anyhow::anyhow!("{}", inner); - } -} - -impl SseDecode for flutter_rust_bridge::DartOpaque { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - let mut inner = ::sse_decode(deserializer); - return unsafe { flutter_rust_bridge::for_generated::sse_decode_dart_opaque(inner) }; - } -} - -impl SseDecode for String { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - let mut inner = >::sse_decode(deserializer); - return String::from_utf8(inner).unwrap(); - } -} - impl SseDecode for i32 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -222,48 +113,11 @@ impl SseDecode for i32 { } } -impl SseDecode for Vec { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - let mut len_ = ::sse_decode(deserializer); - let mut ans_ = vec![]; - for idx_ in 0..len_ { - ans_.push(::sse_decode(deserializer)); - } - return ans_; - } -} - -impl SseDecode for Option { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - if (::sse_decode(deserializer)) { - return Some(::sse_decode(deserializer)); - } else { - return None; - } - } -} - -impl SseDecode for u8 { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - deserializer.cursor.read_u8().unwrap() - } -} - impl SseDecode for () { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {} } -impl SseDecode for usize { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - deserializer.cursor.read_u64::().unwrap() as _ - } -} - impl SseDecode for bool { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -282,12 +136,6 @@ fn pde_ffi_dispatcher_primary_impl( match func_id { 1 => wire__crate__api__minimal__init_app_impl(port, ptr, rust_vec_len, data_len), 2 => wire__crate__api__minimal__minimal_adder_impl(port, ptr, rust_vec_len, data_len), - 3 => wire__crate__api__minimal__rust_call_dart_return_result_twin_normal_impl( - port, - ptr, - rust_vec_len, - data_len, - ), _ => unreachable!(), } } @@ -306,27 +154,6 @@ fn pde_ffi_dispatcher_sync_impl( // Section: rust2dart -impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - ::sse_encode(format!("{:?}", self), serializer); - } -} - -impl SseEncode for flutter_rust_bridge::DartOpaque { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - ::sse_encode(self.encode(), serializer); - } -} - -impl SseEncode for String { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - >::sse_encode(self.into_bytes(), serializer); - } -} - impl SseEncode for i32 { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -334,48 +161,11 @@ impl SseEncode for i32 { } } -impl SseEncode for Vec { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - ::sse_encode(self.len() as _, serializer); - for item in self { - ::sse_encode(item, serializer); - } - } -} - -impl SseEncode for Option { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - ::sse_encode(self.is_some(), serializer); - if let Some(value) = self { - ::sse_encode(value, serializer); - } - } -} - -impl SseEncode for u8 { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - serializer.cursor.write_u8(self).unwrap(); - } -} - impl SseEncode for () { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {} } -impl SseEncode for usize { - // Codec=Sse (Serialization based), see doc to use other codecs - fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - serializer - .cursor - .write_u64::(self as _) - .unwrap(); - } -} - impl SseEncode for bool { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { diff --git a/frb_example/dart_minimal/test/minimal_test.dart b/frb_example/dart_minimal/test/minimal_test.dart index 170b2a6b58..7ad47f69d7 100644 --- a/frb_example/dart_minimal/test/minimal_test.dart +++ b/frb_example/dart_minimal/test/minimal_test.dart @@ -14,17 +14,4 @@ Future main() async { print('Action: Call rust (after)'); }); print('Action: Configure tests (end)'); - - group('rustCallDartReturnResultTwinNormal', () { - test('when normal', () async { - await rustCallDartReturnResultTwinNormal( - callback: (s) => s * 2, expectOutput: "hihi"); - }); - - test('when error', () async { - await rustCallDartReturnResultTwinNormal( - callback: (s) => throw Exception('dummy exception'), - expectOutput: null); - }); - }); } From e757593a108921a2ef554005ab217ab2180970e0 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 14:08:03 +0800 Subject: [PATCH 84/94] chore: rm --- .../lib/src/rust/api/minimal.freezed.dart | 369 ------------------ 1 file changed, 369 deletions(-) delete mode 100644 frb_example/dart_minimal/lib/src/rust/api/minimal.freezed.dart diff --git a/frb_example/dart_minimal/lib/src/rust/api/minimal.freezed.dart b/frb_example/dart_minimal/lib/src/rust/api/minimal.freezed.dart deleted file mode 100644 index e26f3ade4f..0000000000 --- a/frb_example/dart_minimal/lib/src/rust/api/minimal.freezed.dart +++ /dev/null @@ -1,369 +0,0 @@ -// coverage:ignore-file -// GENERATED CODE - DO NOT MODIFY BY HAND -// ignore_for_file: type=lint -// ignore_for_file: unused_element, deprecated_member_use, deprecated_member_use_from_same_package, use_function_type_syntax_for_parameters, unnecessary_const, avoid_init_to_null, invalid_override_different_default_values_named, prefer_expression_function_bodies, annotate_overrides, invalid_annotation_target, unnecessary_question_mark - -part of 'minimal.dart'; - -// ************************************************************************** -// FreezedGenerator -// ************************************************************************** - -T _$identity(T value) => value; - -final _privateConstructorUsedError = UnsupportedError( - 'It seems like you constructed your class using `MyClass._()`. This constructor is only meant to be used by freezed and you are not supposed to need it nor use it.\nPlease check the documentation here for more information: https://github.com/rrousselGit/freezed#custom-getters-and-methods'); - -/// @nodoc -mixin _$_delegate_Result__String_u_32 { - Object get value => throw _privateConstructorUsedError; - @optionalTypeArgs - TResult when({ - required TResult Function(String value) ok, - required TResult Function(int value) err, - }) => - throw _privateConstructorUsedError; - @optionalTypeArgs - TResult? whenOrNull({ - TResult? Function(String value)? ok, - TResult? Function(int value)? err, - }) => - throw _privateConstructorUsedError; - @optionalTypeArgs - TResult maybeWhen({ - TResult Function(String value)? ok, - TResult Function(int value)? err, - required TResult orElse(), - }) => - throw _privateConstructorUsedError; - @optionalTypeArgs - TResult map({ - required TResult Function(__delegate_Result__String_u_32_ok value) ok, - required TResult Function(__delegate_Result__String_u_32_err value) err, - }) => - throw _privateConstructorUsedError; - @optionalTypeArgs - TResult? mapOrNull({ - TResult? Function(__delegate_Result__String_u_32_ok value)? ok, - TResult? Function(__delegate_Result__String_u_32_err value)? err, - }) => - throw _privateConstructorUsedError; - @optionalTypeArgs - TResult maybeMap({ - TResult Function(__delegate_Result__String_u_32_ok value)? ok, - TResult Function(__delegate_Result__String_u_32_err value)? err, - required TResult orElse(), - }) => - throw _privateConstructorUsedError; -} - -/// @nodoc -abstract class _$_delegate_Result__String_u_32CopyWith<$Res> { - factory _$_delegate_Result__String_u_32CopyWith( - __delegate_Result__String_u_32 value, - $Res Function(__delegate_Result__String_u_32) then) = - __$_delegate_Result__String_u_32CopyWithImpl<$Res, - __delegate_Result__String_u_32>; -} - -/// @nodoc -class __$_delegate_Result__String_u_32CopyWithImpl<$Res, - $Val extends __delegate_Result__String_u_32> - implements _$_delegate_Result__String_u_32CopyWith<$Res> { - __$_delegate_Result__String_u_32CopyWithImpl(this._value, this._then); - - // ignore: unused_field - final $Val _value; - // ignore: unused_field - final $Res Function($Val) _then; -} - -/// @nodoc -abstract class _$$_delegate_Result__String_u_32_okImplCopyWith<$Res> { - factory _$$_delegate_Result__String_u_32_okImplCopyWith( - _$_delegate_Result__String_u_32_okImpl value, - $Res Function(_$_delegate_Result__String_u_32_okImpl) then) = - __$$_delegate_Result__String_u_32_okImplCopyWithImpl<$Res>; - @useResult - $Res call({String value}); -} - -/// @nodoc -class __$$_delegate_Result__String_u_32_okImplCopyWithImpl<$Res> - extends __$_delegate_Result__String_u_32CopyWithImpl<$Res, - _$_delegate_Result__String_u_32_okImpl> - implements _$$_delegate_Result__String_u_32_okImplCopyWith<$Res> { - __$$_delegate_Result__String_u_32_okImplCopyWithImpl( - _$_delegate_Result__String_u_32_okImpl _value, - $Res Function(_$_delegate_Result__String_u_32_okImpl) _then) - : super(_value, _then); - - @pragma('vm:prefer-inline') - @override - $Res call({ - Object? value = null, - }) { - return _then(_$_delegate_Result__String_u_32_okImpl( - value: null == value - ? _value.value - : value // ignore: cast_nullable_to_non_nullable - as String, - )); - } -} - -/// @nodoc - -class _$_delegate_Result__String_u_32_okImpl - extends __delegate_Result__String_u_32_ok { - const _$_delegate_Result__String_u_32_okImpl({required this.value}) - : super._(); - - @override - final String value; - - @override - String toString() { - return '__delegate_Result__String_u_32.ok(value: $value)'; - } - - @override - bool operator ==(Object other) { - return identical(this, other) || - (other.runtimeType == runtimeType && - other is _$_delegate_Result__String_u_32_okImpl && - (identical(other.value, value) || other.value == value)); - } - - @override - int get hashCode => Object.hash(runtimeType, value); - - @JsonKey(ignore: true) - @override - @pragma('vm:prefer-inline') - _$$_delegate_Result__String_u_32_okImplCopyWith< - _$_delegate_Result__String_u_32_okImpl> - get copyWith => __$$_delegate_Result__String_u_32_okImplCopyWithImpl< - _$_delegate_Result__String_u_32_okImpl>(this, _$identity); - - @override - @optionalTypeArgs - TResult when({ - required TResult Function(String value) ok, - required TResult Function(int value) err, - }) { - return ok(value); - } - - @override - @optionalTypeArgs - TResult? whenOrNull({ - TResult? Function(String value)? ok, - TResult? Function(int value)? err, - }) { - return ok?.call(value); - } - - @override - @optionalTypeArgs - TResult maybeWhen({ - TResult Function(String value)? ok, - TResult Function(int value)? err, - required TResult orElse(), - }) { - if (ok != null) { - return ok(value); - } - return orElse(); - } - - @override - @optionalTypeArgs - TResult map({ - required TResult Function(__delegate_Result__String_u_32_ok value) ok, - required TResult Function(__delegate_Result__String_u_32_err value) err, - }) { - return ok(this); - } - - @override - @optionalTypeArgs - TResult? mapOrNull({ - TResult? Function(__delegate_Result__String_u_32_ok value)? ok, - TResult? Function(__delegate_Result__String_u_32_err value)? err, - }) { - return ok?.call(this); - } - - @override - @optionalTypeArgs - TResult maybeMap({ - TResult Function(__delegate_Result__String_u_32_ok value)? ok, - TResult Function(__delegate_Result__String_u_32_err value)? err, - required TResult orElse(), - }) { - if (ok != null) { - return ok(this); - } - return orElse(); - } -} - -abstract class __delegate_Result__String_u_32_ok - extends __delegate_Result__String_u_32 { - const factory __delegate_Result__String_u_32_ok( - {required final String value}) = _$_delegate_Result__String_u_32_okImpl; - const __delegate_Result__String_u_32_ok._() : super._(); - - @override - String get value; - @JsonKey(ignore: true) - _$$_delegate_Result__String_u_32_okImplCopyWith< - _$_delegate_Result__String_u_32_okImpl> - get copyWith => throw _privateConstructorUsedError; -} - -/// @nodoc -abstract class _$$_delegate_Result__String_u_32_errImplCopyWith<$Res> { - factory _$$_delegate_Result__String_u_32_errImplCopyWith( - _$_delegate_Result__String_u_32_errImpl value, - $Res Function(_$_delegate_Result__String_u_32_errImpl) then) = - __$$_delegate_Result__String_u_32_errImplCopyWithImpl<$Res>; - @useResult - $Res call({int value}); -} - -/// @nodoc -class __$$_delegate_Result__String_u_32_errImplCopyWithImpl<$Res> - extends __$_delegate_Result__String_u_32CopyWithImpl<$Res, - _$_delegate_Result__String_u_32_errImpl> - implements _$$_delegate_Result__String_u_32_errImplCopyWith<$Res> { - __$$_delegate_Result__String_u_32_errImplCopyWithImpl( - _$_delegate_Result__String_u_32_errImpl _value, - $Res Function(_$_delegate_Result__String_u_32_errImpl) _then) - : super(_value, _then); - - @pragma('vm:prefer-inline') - @override - $Res call({ - Object? value = null, - }) { - return _then(_$_delegate_Result__String_u_32_errImpl( - value: null == value - ? _value.value - : value // ignore: cast_nullable_to_non_nullable - as int, - )); - } -} - -/// @nodoc - -class _$_delegate_Result__String_u_32_errImpl - extends __delegate_Result__String_u_32_err { - const _$_delegate_Result__String_u_32_errImpl({required this.value}) - : super._(); - - @override - final int value; - - @override - String toString() { - return '__delegate_Result__String_u_32.err(value: $value)'; - } - - @override - bool operator ==(Object other) { - return identical(this, other) || - (other.runtimeType == runtimeType && - other is _$_delegate_Result__String_u_32_errImpl && - (identical(other.value, value) || other.value == value)); - } - - @override - int get hashCode => Object.hash(runtimeType, value); - - @JsonKey(ignore: true) - @override - @pragma('vm:prefer-inline') - _$$_delegate_Result__String_u_32_errImplCopyWith< - _$_delegate_Result__String_u_32_errImpl> - get copyWith => __$$_delegate_Result__String_u_32_errImplCopyWithImpl< - _$_delegate_Result__String_u_32_errImpl>(this, _$identity); - - @override - @optionalTypeArgs - TResult when({ - required TResult Function(String value) ok, - required TResult Function(int value) err, - }) { - return err(value); - } - - @override - @optionalTypeArgs - TResult? whenOrNull({ - TResult? Function(String value)? ok, - TResult? Function(int value)? err, - }) { - return err?.call(value); - } - - @override - @optionalTypeArgs - TResult maybeWhen({ - TResult Function(String value)? ok, - TResult Function(int value)? err, - required TResult orElse(), - }) { - if (err != null) { - return err(value); - } - return orElse(); - } - - @override - @optionalTypeArgs - TResult map({ - required TResult Function(__delegate_Result__String_u_32_ok value) ok, - required TResult Function(__delegate_Result__String_u_32_err value) err, - }) { - return err(this); - } - - @override - @optionalTypeArgs - TResult? mapOrNull({ - TResult? Function(__delegate_Result__String_u_32_ok value)? ok, - TResult? Function(__delegate_Result__String_u_32_err value)? err, - }) { - return err?.call(this); - } - - @override - @optionalTypeArgs - TResult maybeMap({ - TResult Function(__delegate_Result__String_u_32_ok value)? ok, - TResult Function(__delegate_Result__String_u_32_err value)? err, - required TResult orElse(), - }) { - if (err != null) { - return err(this); - } - return orElse(); - } -} - -abstract class __delegate_Result__String_u_32_err - extends __delegate_Result__String_u_32 { - const factory __delegate_Result__String_u_32_err({required final int value}) = - _$_delegate_Result__String_u_32_errImpl; - const __delegate_Result__String_u_32_err._() : super._(); - - @override - int get value; - @JsonKey(ignore: true) - _$$_delegate_Result__String_u_32_errImplCopyWith< - _$_delegate_Result__String_u_32_errImpl> - get copyWith => throw _privateConstructorUsedError; -} From 3559f5d5ce5b550bf55ff404815742cfafc58cca Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 14:12:11 +0800 Subject: [PATCH 85/94] chore: codegen --- .../gallery/lib/src/rust/frb_generated.dart | 2 +- frb_example/gallery/rust/src/frb_generated.rs | 3 +- frb_example/pure_dart/frb_generated.h | 22 + .../pure_dart/lib/src/rust/api/dart_fn.dart | 7 + .../dart_fn_twin_rust_async.dart | 8 + .../dart_fn_twin_rust_async_sse.dart | 8 + .../api/pseudo_manual/dart_fn_twin_sse.dart | 8 + .../pure_dart/lib/src/rust/frb_generated.dart | 706 ++++- .../lib/src/rust/frb_generated.io.dart | 193 +- .../lib/src/rust/frb_generated.web.dart | 154 +- .../pseudo_manual/dart_fn_twin_rust_async.rs | 7 + .../dart_fn_twin_rust_async_sse.rs | 8 + .../src/api/pseudo_manual/dart_fn_twin_sse.rs | 8 + .../pure_dart/rust/src/frb_generated.io.rs | 47 + .../pure_dart/rust/src/frb_generated.rs | 400 ++- .../pure_dart/rust/src/frb_generated.web.rs | 47 + .../dart_fn_twin_rust_async_sse_test.dart | 13 + .../dart_fn_twin_rust_async_test.dart | 13 + .../pseudo_manual/dart_fn_twin_sse_test.dart | 13 + .../lib/src/rust/api/dart_fn.dart | 7 + .../dart_fn_twin_rust_async.dart | 8 + .../lib/src/rust/frb_generated.dart | 2518 +++++++++-------- .../lib/src/rust/frb_generated.io.dart | 53 +- .../lib/src/rust/frb_generated.web.dart | 53 +- .../pure_dart_pde/rust/src/api/dart_fn.rs | 7 + .../pseudo_manual/dart_fn_twin_rust_async.rs | 7 + .../pure_dart_pde/rust/src/frb_generated.rs | 2381 +++++++++------- .../pure_dart_pde/test/api/dart_fn_test.dart | 13 + .../dart_fn_twin_rust_async_test.dart | 13 + 29 files changed, 4172 insertions(+), 2555 deletions(-) diff --git a/frb_example/gallery/lib/src/rust/frb_generated.dart b/frb_example/gallery/lib/src/rust/frb_generated.dart index fc97089edc..23b30c3bfe 100644 --- a/frb_example/gallery/lib/src/rust/frb_generated.dart +++ b/frb_example/gallery/lib/src/rust/frb_generated.dart @@ -264,7 +264,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { void sse_encode_AnyhowException( AnyhowException self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs - throw UnimplementedError('Unreachable ()'); + sse_encode_String(self.message, serializer); } @protected diff --git a/frb_example/gallery/rust/src/frb_generated.rs b/frb_example/gallery/rust/src/frb_generated.rs index edf02382da..058c82cf8c 100644 --- a/frb_example/gallery/rust/src/frb_generated.rs +++ b/frb_example/gallery/rust/src/frb_generated.rs @@ -89,7 +89,8 @@ fn wire__crate__api__mandelbrot__draw_mandelbrot_impl( impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - unreachable!(""); + let mut inner = ::sse_decode(deserializer); + return anyhow::anyhow!("{}", inner); } } diff --git a/frb_example/pure_dart/frb_generated.h b/frb_example/pure_dart/frb_generated.h index 4c4d0ed966..3a76722851 100644 --- a/frb_example/pure_dart/frb_generated.h +++ b/frb_example/pure_dart/frb_generated.h @@ -3394,6 +3394,10 @@ void frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_mult void frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal(int64_t port_, const void *callback); +void frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal(int64_t port_, + const void *callback, + struct wire_cst_list_prim_u_8_strict *expect_output); + void frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_return_twin_normal(int64_t port_, const void *callback); @@ -6331,6 +6335,10 @@ void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_ void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_async(int64_t port_, const void *callback); +void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async(int64_t port_, + const void *callback, + struct wire_cst_list_prim_u_8_strict *expect_output); + void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async(int64_t port_, const void *callback); @@ -6362,6 +6370,11 @@ void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_ int32_t rust_vec_len_, int32_t data_len_); +void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse(int64_t port_, + uint8_t *ptr_, + int32_t rust_vec_len_, + int32_t data_len_); + void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_twin_rust_async_sse(int64_t port_, uint8_t *ptr_, int32_t rust_vec_len_, @@ -6402,6 +6415,11 @@ void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_ int32_t rust_vec_len_, int32_t data_len_); +void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse(int64_t port_, + uint8_t *ptr_, + int32_t rust_vec_len_, + int32_t data_len_); + void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_twin_sse(int64_t port_, uint8_t *ptr_, int32_t rust_vec_len_, @@ -15087,6 +15105,7 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_loopback_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_multi_times_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_return_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal); @@ -15920,6 +15939,7 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_loopback_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_multi_times_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_async); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_simple_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_two_args_twin_rust_async); @@ -15928,6 +15948,7 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_loopback_twin_rust_async_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_multi_times_twin_rust_async_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_one_arg_twin_rust_async_sse); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_twin_rust_async_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_simple_twin_rust_async_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_two_args_twin_rust_async_sse); @@ -15936,6 +15957,7 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_loopback_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_multi_times_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_one_arg_twin_sse); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_simple_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_two_args_twin_sse); diff --git a/frb_example/pure_dart/lib/src/rust/api/dart_fn.dart b/frb_example/pure_dart/lib/src/rust/api/dart_fn.dart index e7628efe6e..0be5cfee39 100644 --- a/frb_example/pure_dart/lib/src/rust/api/dart_fn.dart +++ b/frb_example/pure_dart/lib/src/rust/api/dart_fn.dart @@ -57,6 +57,13 @@ Future rustCallDartMultiTimesTwinNormal( RustLib.instance.api.crateApiDartFnRustCallDartMultiTimesTwinNormal( callback: callback, numTimes: numTimes, hint: hint); +Future rustCallDartReturnResultTwinNormal( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) => + RustLib.instance.api.crateApiDartFnRustCallDartReturnResultTwinNormal( + callback: callback, expectOutput: expectOutput, hint: hint); + class DemoStructForRustCallDartTwinNormal { final String name; diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async.dart index f72e56e515..6f244815a9 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async.dart @@ -64,6 +64,14 @@ Future rustCallDartMultiTimesTwinRustAsync( .crateApiPseudoManualDartFnTwinRustAsyncRustCallDartMultiTimesTwinRustAsync( callback: callback, numTimes: numTimes, hint: hint); +Future rustCallDartReturnResultTwinRustAsync( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) => + RustLib.instance.api + .crateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnResultTwinRustAsync( + callback: callback, expectOutput: expectOutput, hint: hint); + class DemoStructForRustCallDartTwinRustAsync { final String name; diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async_sse.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async_sse.dart index 64cb6e7985..045c082555 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async_sse.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async_sse.dart @@ -64,6 +64,14 @@ Future rustCallDartMultiTimesTwinRustAsyncSse( .crateApiPseudoManualDartFnTwinRustAsyncSseRustCallDartMultiTimesTwinRustAsyncSse( callback: callback, numTimes: numTimes, hint: hint); +Future rustCallDartReturnResultTwinRustAsyncSse( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) => + RustLib.instance.api + .crateApiPseudoManualDartFnTwinRustAsyncSseRustCallDartReturnResultTwinRustAsyncSse( + callback: callback, expectOutput: expectOutput, hint: hint); + class DemoStructForRustCallDartTwinRustAsyncSse { final String name; diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_sse.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_sse.dart index 05bb66754f..bf9ba81827 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_sse.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/dart_fn_twin_sse.dart @@ -64,6 +64,14 @@ Future rustCallDartMultiTimesTwinSse( .crateApiPseudoManualDartFnTwinSseRustCallDartMultiTimesTwinSse( callback: callback, numTimes: numTimes, hint: hint); +Future rustCallDartReturnResultTwinSse( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) => + RustLib.instance.api + .crateApiPseudoManualDartFnTwinSseRustCallDartReturnResultTwinSse( + callback: callback, expectOutput: expectOutput, hint: hint); + class DemoStructForRustCallDartTwinSse { final String name; diff --git a/frb_example/pure_dart/lib/src/rust/frb_generated.dart b/frb_example/pure_dart/lib/src/rust/frb_generated.dart index d8684988b3..750933ca19 100644 --- a/frb_example/pure_dart/lib/src/rust/frb_generated.dart +++ b/frb_example/pure_dart/lib/src/rust/frb_generated.dart @@ -308,7 +308,7 @@ class RustLib extends BaseEntrypoint { String get codegenVersion => '2.0.0-dev.34'; @override - int get rustContentHash => -128436911; + int get rustContentHash => -1320820513; static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig( @@ -481,6 +481,11 @@ abstract class RustLibApi extends BaseApi { Future crateApiDartFnRustCallDartOneArgTwinNormal( {required FutureOr Function(String) callback, dynamic hint}); + Future crateApiDartFnRustCallDartReturnResultTwinNormal( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}); + Future crateApiDartFnRustCallDartReturnTwinNormal( {required FutureOr Function() callback, dynamic hint}); @@ -3599,6 +3604,12 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualDartFnTwinRustAsyncRustCallDartOneArgTwinRustAsync( {required FutureOr Function(String) callback, dynamic hint}); + Future + crateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnResultTwinRustAsync( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}); + Future crateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnTwinRustAsync( {required FutureOr Function() callback, dynamic hint}); @@ -3641,6 +3652,12 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualDartFnTwinRustAsyncSseRustCallDartOneArgTwinRustAsyncSse( {required FutureOr Function(String) callback, dynamic hint}); + Future + crateApiPseudoManualDartFnTwinRustAsyncSseRustCallDartReturnResultTwinRustAsyncSse( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}); + Future crateApiPseudoManualDartFnTwinRustAsyncSseRustCallDartReturnTwinRustAsyncSse( {required FutureOr Function() callback, dynamic hint}); @@ -3680,6 +3697,11 @@ abstract class RustLibApi extends BaseApi { Future crateApiPseudoManualDartFnTwinSseRustCallDartOneArgTwinSse( {required FutureOr Function(String) callback, dynamic hint}); + Future crateApiPseudoManualDartFnTwinSseRustCallDartReturnResultTwinSse( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}); + Future crateApiPseudoManualDartFnTwinSseRustCallDartReturnTwinSse( {required FutureOr Function() callback, dynamic hint}); @@ -13516,7 +13538,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { var arg0 = - cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( callback); return wire .wire__crate__api__dart_fn__rust_call_dart_loopback_twin_normal( @@ -13546,7 +13568,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { - var arg0 = cst_encode_DartFn_Inputs__Output_unit(callback); + var arg0 = + cst_encode_DartFn_Inputs__Output_unit_AnyhowException(callback); var arg1 = cst_encode_i_32(numTimes); return wire .wire__crate__api__dart_fn__rust_call_dart_multi_times_twin_normal( @@ -13574,7 +13597,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { {required FutureOr Function(String) callback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { - var arg0 = cst_encode_DartFn_Inputs_String_Output_unit(callback); + var arg0 = cst_encode_DartFn_Inputs_String_Output_unit_AnyhowException( + callback); return wire .wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal( port_, arg0); @@ -13596,12 +13620,46 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["callback"], ); + @override + Future crateApiDartFnRustCallDartReturnResultTwinNormal( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + var arg0 = + cst_encode_DartFn_Inputs_String_Output_String_AnyhowException( + callback); + var arg1 = cst_encode_opt_String(expectOutput); + return wire + .wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal( + port_, arg0, arg1); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: null, + ), + constMeta: kCrateApiDartFnRustCallDartReturnResultTwinNormalConstMeta, + argValues: [callback, expectOutput], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiDartFnRustCallDartReturnResultTwinNormalConstMeta => + const TaskConstMeta( + debugName: "rust_call_dart_return_result_twin_normal", + argNames: ["callback", "expectOutput"], + ); + @override Future crateApiDartFnRustCallDartReturnTwinNormal( {required FutureOr Function() callback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { - var arg0 = cst_encode_DartFn_Inputs__Output_String(callback); + var arg0 = + cst_encode_DartFn_Inputs__Output_String_AnyhowException(callback); return wire .wire__crate__api__dart_fn__rust_call_dart_return_twin_normal( port_, arg0); @@ -13628,7 +13686,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { {required FutureOr Function() callback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { - var arg0 = cst_encode_DartFn_Inputs__Output_unit(callback); + var arg0 = + cst_encode_DartFn_Inputs__Output_unit_AnyhowException(callback); return wire .wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal( port_, arg0); @@ -13659,7 +13718,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { var arg0 = - cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( callback); return wire .wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal( @@ -13690,7 +13749,9 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { var arg0 = cst_encode_DartOpaque(input); - var arg1 = cst_encode_DartFn_Inputs_DartOpaque_Output_unit(callback); + var arg1 = + cst_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + callback); return wire .wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_arg_twin_normal( port_, arg0, arg1); @@ -13719,7 +13780,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { {required FutureOr Function() callback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { - var arg0 = cst_encode_DartFn_Inputs__Output_DartOpaque(callback); + var arg0 = cst_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( + callback); return wire .wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_result_twin_normal( port_, arg0); @@ -38900,7 +38962,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { var arg0 = - cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( callback); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_loopback_twin_rust_async( @@ -38933,7 +38995,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { - var arg0 = cst_encode_DartFn_Inputs__Output_unit(callback); + var arg0 = + cst_encode_DartFn_Inputs__Output_unit_AnyhowException(callback); var arg1 = cst_encode_i_32(numTimes); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_multi_times_twin_rust_async( @@ -38964,7 +39027,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { {required FutureOr Function(String) callback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { - var arg0 = cst_encode_DartFn_Inputs_String_Output_unit(callback); + var arg0 = cst_encode_DartFn_Inputs_String_Output_unit_AnyhowException( + callback); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_async( port_, arg0); @@ -38988,13 +39052,49 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["callback"], ); + @override + Future + crateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnResultTwinRustAsync( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + var arg0 = + cst_encode_DartFn_Inputs_String_Output_String_AnyhowException( + callback); + var arg1 = cst_encode_opt_String(expectOutput); + return wire + .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async( + port_, arg0, arg1); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnResultTwinRustAsyncConstMeta, + argValues: [callback, expectOutput], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnResultTwinRustAsyncConstMeta => + const TaskConstMeta( + debugName: "rust_call_dart_return_result_twin_rust_async", + argNames: ["callback", "expectOutput"], + ); + @override Future crateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnTwinRustAsync( {required FutureOr Function() callback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { - var arg0 = cst_encode_DartFn_Inputs__Output_String(callback); + var arg0 = + cst_encode_DartFn_Inputs__Output_String_AnyhowException(callback); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async( port_, arg0); @@ -39024,7 +39124,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { {required FutureOr Function() callback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { - var arg0 = cst_encode_DartFn_Inputs__Output_unit(callback); + var arg0 = + cst_encode_DartFn_Inputs__Output_unit_AnyhowException(callback); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_simple_twin_rust_async( port_, arg0); @@ -39058,7 +39159,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { var arg0 = - cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( callback); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_two_args_twin_rust_async( @@ -39092,7 +39193,9 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { var arg0 = cst_encode_DartOpaque(input); - var arg1 = cst_encode_DartFn_Inputs_DartOpaque_Output_unit(callback); + var arg1 = + cst_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + callback); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with_dart_opaque_arg_twin_rust_async( port_, arg0, arg1); @@ -39122,7 +39225,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { {required FutureOr Function() callback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { - var arg0 = cst_encode_DartFn_Inputs__Output_DartOpaque(callback); + var arg0 = cst_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( + callback); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with_dart_opaque_result_twin_rust_async( port_, arg0); @@ -39156,7 +39260,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse_AnyhowException( callback, serializer); final raw_ = serializer.intoRaw(); return wire @@ -39191,7 +39295,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_unit(callback, serializer); + sse_encode_DartFn_Inputs__Output_unit_AnyhowException( + callback, serializer); sse_encode_i_32(numTimes, serializer); final raw_ = serializer.intoRaw(); return wire @@ -39224,7 +39329,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_unit(callback, serializer); + sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( + callback, serializer); final raw_ = serializer.intoRaw(); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_one_arg_twin_rust_async_sse( @@ -39249,6 +39355,42 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["callback"], ); + @override + Future + crateApiPseudoManualDartFnTwinRustAsyncSseRustCallDartReturnResultTwinRustAsyncSse( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + callback, serializer); + sse_encode_opt_String(expectOutput, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualDartFnTwinRustAsyncSseRustCallDartReturnResultTwinRustAsyncSseConstMeta, + argValues: [callback, expectOutput], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualDartFnTwinRustAsyncSseRustCallDartReturnResultTwinRustAsyncSseConstMeta => + const TaskConstMeta( + debugName: "rust_call_dart_return_result_twin_rust_async_sse", + argNames: ["callback", "expectOutput"], + ); + @override Future crateApiPseudoManualDartFnTwinRustAsyncSseRustCallDartReturnTwinRustAsyncSse( @@ -39256,7 +39398,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_String(callback, serializer); + sse_encode_DartFn_Inputs__Output_String_AnyhowException( + callback, serializer); final raw_ = serializer.intoRaw(); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_twin_rust_async_sse( @@ -39288,7 +39431,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_unit(callback, serializer); + sse_encode_DartFn_Inputs__Output_unit_AnyhowException( + callback, serializer); final raw_ = serializer.intoRaw(); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_simple_twin_rust_async_sse( @@ -39323,7 +39467,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit_AnyhowException( callback, serializer); final raw_ = serializer.intoRaw(); return wire @@ -39359,7 +39503,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(input, serializer); - sse_encode_DartFn_Inputs_DartOpaque_Output_unit(callback, serializer); + sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + callback, serializer); final raw_ = serializer.intoRaw(); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_with_dart_opaque_arg_twin_rust_async_sse( @@ -39392,7 +39537,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_DartOpaque(callback, serializer); + sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( + callback, serializer); final raw_ = serializer.intoRaw(); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_with_dart_opaque_result_twin_rust_async_sse( @@ -39427,7 +39573,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse_AnyhowException( callback, serializer); final raw_ = serializer.intoRaw(); return wire @@ -39461,7 +39607,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_unit(callback, serializer); + sse_encode_DartFn_Inputs__Output_unit_AnyhowException( + callback, serializer); sse_encode_i_32(numTimes, serializer); final raw_ = serializer.intoRaw(); return wire @@ -39493,7 +39640,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_unit(callback, serializer); + sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( + callback, serializer); final raw_ = serializer.intoRaw(); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_one_arg_twin_sse( @@ -39518,13 +39666,49 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["callback"], ); + @override + Future crateApiPseudoManualDartFnTwinSseRustCallDartReturnResultTwinSse( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + callback, serializer); + sse_encode_opt_String(expectOutput, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualDartFnTwinSseRustCallDartReturnResultTwinSseConstMeta, + argValues: [callback, expectOutput], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualDartFnTwinSseRustCallDartReturnResultTwinSseConstMeta => + const TaskConstMeta( + debugName: "rust_call_dart_return_result_twin_sse", + argNames: ["callback", "expectOutput"], + ); + @override Future crateApiPseudoManualDartFnTwinSseRustCallDartReturnTwinSse( {required FutureOr Function() callback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_String(callback, serializer); + sse_encode_DartFn_Inputs__Output_String_AnyhowException( + callback, serializer); final raw_ = serializer.intoRaw(); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_twin_sse( @@ -39555,7 +39739,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_unit(callback, serializer); + sse_encode_DartFn_Inputs__Output_unit_AnyhowException( + callback, serializer); final raw_ = serializer.intoRaw(); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_simple_twin_sse( @@ -39589,7 +39774,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit_AnyhowException( callback, serializer); final raw_ = serializer.intoRaw(); return wire @@ -39625,7 +39810,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(input, serializer); - sse_encode_DartFn_Inputs_DartOpaque_Output_unit(callback, serializer); + sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + callback, serializer); final raw_ = serializer.intoRaw(); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_with_dart_opaque_arg_twin_sse( @@ -39657,7 +39843,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_DartOpaque(callback, serializer); + sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( + callback, serializer); final raw_ = serializer.intoRaw(); return wire .wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_with_dart_opaque_result_twin_sse( @@ -92633,15 +92820,28 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); Future Function(int, dynamic) - encode_DartFn_Inputs_DartOpaque_Output_unit( + encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_DartOpaque(rawArg0); - final rawOutput = await raw(arg0); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + 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( @@ -92652,15 +92852,62 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { }; } - Future Function(int, dynamic) encode_DartFn_Inputs_String_Output_unit( - FutureOr Function(String) raw) { + Future Function(int, dynamic) + encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) raw) { + return (callId, rawArg0) async { + final arg0 = dco_decode_String(rawArg0); + + Box? rawOutput; + Box? 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_String(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 Function(int, dynamic) + encode_DartFn_Inputs_String_Output_unit_AnyhowException( + FutureOr Function(String) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_String(rawArg0); - final rawOutput = await raw(arg0); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + 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( @@ -92672,7 +92919,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic, dynamic) - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinNormal) raw) { return (callId, rawArg0, rawArg1) async { @@ -92680,10 +92927,23 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final arg1 = dco_decode_demo_struct_for_rust_call_dart_twin_normal(rawArg1); - final rawOutput = await raw(arg0, arg1); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0, arg1)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + 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( @@ -92695,7 +92955,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic, dynamic) - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsync) raw) { @@ -92704,10 +92964,23 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final arg1 = dco_decode_demo_struct_for_rust_call_dart_twin_rust_async(rawArg1); - final rawOutput = await raw(arg0, arg1); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0, arg1)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + 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( @@ -92719,7 +92992,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic, dynamic) - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsyncSse) raw) { @@ -92729,10 +93002,23 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { dco_decode_demo_struct_for_rust_call_dart_twin_rust_async_sse( rawArg1); - final rawOutput = await raw(arg0, arg1); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0, arg1)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + 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( @@ -92744,17 +93030,30 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic, dynamic) - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinSse) raw) { return (callId, rawArg0, rawArg1) async { final arg0 = dco_decode_String(rawArg0); final arg1 = dco_decode_demo_struct_for_rust_call_dart_twin_sse(rawArg1); - final rawOutput = await raw(arg0, arg1); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0, arg1)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + 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( @@ -92767,14 +93066,28 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { Future Function( int, - ) encode_DartFn_Inputs__Output_DartOpaque(FutureOr Function() raw) { + ) encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( + FutureOr Function() raw) { return ( callId, ) async { - final rawOutput = await raw(); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw()); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartOpaque(rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_DartOpaque(rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_AnyhowException(rawError!.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -92787,14 +93100,28 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { Future Function( int, - ) encode_DartFn_Inputs__Output_String(FutureOr Function() raw) { + ) encode_DartFn_Inputs__Output_String_AnyhowException( + FutureOr Function() raw) { return ( callId, ) async { - final rawOutput = await raw(); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw()); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_String(rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_String(rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_AnyhowException(rawError!.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -92807,14 +93134,28 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { Future Function( int, - ) encode_DartFn_Inputs__Output_unit(FutureOr Function() raw) { + ) encode_DartFn_Inputs__Output_unit_AnyhowException( + FutureOr Function() raw) { return ( callId, ) async { - final rawOutput = await raw(); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw()); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + 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( @@ -92826,7 +93167,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic) - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinNormal) raw) { @@ -92834,11 +93175,24 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final arg0 = dco_decode_demo_struct_for_rust_call_dart_twin_normal(rawArg0); - final rawOutput = await raw(arg0); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_demo_struct_for_rust_call_dart_twin_normal( - rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_demo_struct_for_rust_call_dart_twin_normal( + rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_AnyhowException(rawError!.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -92850,7 +93204,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic) - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsync) raw) { @@ -92858,11 +93212,24 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final arg0 = dco_decode_demo_struct_for_rust_call_dart_twin_rust_async(rawArg0); - final rawOutput = await raw(arg0); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_demo_struct_for_rust_call_dart_twin_rust_async( - rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_demo_struct_for_rust_call_dart_twin_rust_async( + rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_AnyhowException(rawError!.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -92874,7 +93241,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic) - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsyncSse) raw) { @@ -92883,11 +93250,24 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { dco_decode_demo_struct_for_rust_call_dart_twin_rust_async_sse( rawArg0); - final rawOutput = await raw(arg0); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_demo_struct_for_rust_call_dart_twin_rust_async_sse( - rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_demo_struct_for_rust_call_dart_twin_rust_async_sse( + rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_AnyhowException(rawError!.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -92899,17 +93279,31 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic) - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinSse) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_demo_struct_for_rust_call_dart_twin_sse(rawArg0); - final rawOutput = await raw(arg0); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_demo_struct_for_rust_call_dart_twin_sse(rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_demo_struct_for_rust_call_dart_twin_sse( + rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_AnyhowException(rawError!.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -96126,21 +96520,30 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function(Object) - dco_decode_DartFn_Inputs_DartOpaque_Output_unit(dynamic raw) { + dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @protected - FutureOr Function(String) dco_decode_DartFn_Inputs_String_Output_unit( - dynamic raw) { + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError(''); + } + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_unit_AnyhowException(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @protected FutureOr Function(String, DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -96148,7 +96551,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function(String, DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -96156,7 +96559,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function(String, DemoStructForRustCallDartTwinRustAsyncSse) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -96164,28 +96567,29 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function(String, DemoStructForRustCallDartTwinSse) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_DartOpaque( - dynamic raw) { + FutureOr Function() + dco_decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_String( - dynamic raw) { + FutureOr Function() + dco_decode_DartFn_Inputs__Output_String_AnyhowException(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_unit(dynamic raw) { + FutureOr Function() + dco_decode_DartFn_Inputs__Output_unit_AnyhowException(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @@ -96193,7 +96597,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function( DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -96202,7 +96606,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function( DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -96211,7 +96615,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function( DemoStructForRustCallDartTwinRustAsyncSse) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -96220,7 +96624,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function( DemoStructForRustCallDartTwinSse) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -136049,85 +136453,98 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - PlatformPointer cst_encode_DartFn_Inputs_DartOpaque_Output_unit( - FutureOr Function(Object) raw) { + PlatformPointer + cst_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + FutureOr Function(Object) raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_DartOpaque( + encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException(raw)); + } + + @protected + PlatformPointer cst_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) raw) { // Codec=Cst (C-struct based), see doc to use other codecs return cst_encode_DartOpaque( - encode_DartFn_Inputs_DartOpaque_Output_unit(raw)); + encode_DartFn_Inputs_String_Output_String_AnyhowException(raw)); } @protected - PlatformPointer cst_encode_DartFn_Inputs_String_Output_unit( + PlatformPointer cst_encode_DartFn_Inputs_String_Output_unit_AnyhowException( FutureOr Function(String) raw) { // Codec=Cst (C-struct based), see doc to use other codecs - return cst_encode_DartOpaque(encode_DartFn_Inputs_String_Output_unit(raw)); + return cst_encode_DartOpaque( + encode_DartFn_Inputs_String_Output_unit_AnyhowException(raw)); } @protected PlatformPointer - cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinNormal) raw) { // Codec=Cst (C-struct based), see doc to use other codecs return cst_encode_DartOpaque( - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( raw)); } @protected PlatformPointer - cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsync) raw) { // Codec=Cst (C-struct based), see doc to use other codecs return cst_encode_DartOpaque( - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( raw)); } @protected - PlatformPointer cst_encode_DartFn_Inputs__Output_DartOpaque( + PlatformPointer cst_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( FutureOr Function() raw) { // Codec=Cst (C-struct based), see doc to use other codecs - return cst_encode_DartOpaque(encode_DartFn_Inputs__Output_DartOpaque(raw)); + return cst_encode_DartOpaque( + encode_DartFn_Inputs__Output_DartOpaque_AnyhowException(raw)); } @protected - PlatformPointer cst_encode_DartFn_Inputs__Output_String( + PlatformPointer cst_encode_DartFn_Inputs__Output_String_AnyhowException( FutureOr Function() raw) { // Codec=Cst (C-struct based), see doc to use other codecs - return cst_encode_DartOpaque(encode_DartFn_Inputs__Output_String(raw)); + return cst_encode_DartOpaque( + encode_DartFn_Inputs__Output_String_AnyhowException(raw)); } @protected - PlatformPointer cst_encode_DartFn_Inputs__Output_unit( + PlatformPointer cst_encode_DartFn_Inputs__Output_unit_AnyhowException( FutureOr Function() raw) { // Codec=Cst (C-struct based), see doc to use other codecs - return cst_encode_DartOpaque(encode_DartFn_Inputs__Output_unit(raw)); + return cst_encode_DartOpaque( + encode_DartFn_Inputs__Output_unit_AnyhowException(raw)); } @protected PlatformPointer - cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinNormal) raw) { // Codec=Cst (C-struct based), see doc to use other codecs return cst_encode_DartOpaque( - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( raw)); } @protected PlatformPointer - cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsync) raw) { // Codec=Cst (C-struct based), see doc to use other codecs return cst_encode_DartOpaque( - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( raw)); } @@ -137139,7 +137556,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { void sse_encode_AnyhowException( AnyhowException self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs - throw UnimplementedError('Unreachable ()'); + sse_encode_String(self.message, serializer); } @protected @@ -138761,150 +139178,163 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void sse_encode_DartFn_Inputs_DartOpaque_Output_unit( + void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_DartOpaque_Output_unit(self), serializer); + encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException(self), + serializer); } @protected - void sse_encode_DartFn_Inputs_String_Output_unit( + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_DartOpaque( + encode_DartFn_Inputs_String_Output_String_AnyhowException(self), + serializer); + } + + @protected + void sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( FutureOr Function(String) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_Output_unit(self), serializer); + encode_DartFn_Inputs_String_Output_unit_AnyhowException(self), + serializer); } @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinNormal) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( self), serializer); } @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsync) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( self), serializer); } @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsyncSse) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit_AnyhowException( self), serializer); } @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinSse) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit_AnyhowException( self), serializer); } @protected - void sse_encode_DartFn_Inputs__Output_DartOpaque( + void sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( FutureOr Function() self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs__Output_DartOpaque(self), serializer); + encode_DartFn_Inputs__Output_DartOpaque_AnyhowException(self), + serializer); } @protected - void sse_encode_DartFn_Inputs__Output_String( + void sse_encode_DartFn_Inputs__Output_String_AnyhowException( FutureOr Function() self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs__Output_String(self), serializer); + encode_DartFn_Inputs__Output_String_AnyhowException(self), serializer); } @protected - void sse_encode_DartFn_Inputs__Output_unit( + void sse_encode_DartFn_Inputs__Output_unit_AnyhowException( FutureOr Function() self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs - sse_encode_DartOpaque(encode_DartFn_Inputs__Output_unit(self), serializer); + sse_encode_DartOpaque( + encode_DartFn_Inputs__Output_unit_AnyhowException(self), serializer); } @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinNormal) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( self), serializer); } @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsync) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( self), serializer); } @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsyncSse) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse_AnyhowException( self), serializer); } @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinSse) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse_AnyhowException( self), serializer); } diff --git a/frb_example/pure_dart/lib/src/rust/frb_generated.io.dart b/frb_example/pure_dart/lib/src/rust/frb_generated.io.dart index b3e31a0d49..b82660f745 100644 --- a/frb_example/pure_dart/lib/src/rust/frb_generated.io.dart +++ b/frb_example/pure_dart/lib/src/rust/frb_generated.io.dart @@ -2053,65 +2053,72 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected FutureOr Function(Object) - dco_decode_DartFn_Inputs_DartOpaque_Output_unit(dynamic raw); + dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + dynamic raw); @protected - FutureOr Function(String) dco_decode_DartFn_Inputs_String_Output_unit( - dynamic raw); + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + dynamic raw); + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_unit_AnyhowException(dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinRustAsyncSse) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit_AnyhowException( dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinSse) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit_AnyhowException( dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_DartOpaque( - dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_String( - dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_String_AnyhowException(dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_unit(dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_unit_AnyhowException(dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinRustAsyncSse) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse_AnyhowException( dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinSse) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse_AnyhowException( dynamic raw); @protected @@ -29367,48 +29374,53 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithImplBlockInMultiFile raw); @protected - PlatformPointer cst_encode_DartFn_Inputs_DartOpaque_Output_unit( - FutureOr Function(Object) raw); + PlatformPointer + cst_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + FutureOr Function(Object) raw); @protected - PlatformPointer cst_encode_DartFn_Inputs_String_Output_unit( + PlatformPointer cst_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) raw); + + @protected + PlatformPointer cst_encode_DartFn_Inputs_String_Output_unit_AnyhowException( FutureOr Function(String) raw); @protected PlatformPointer - cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinNormal) raw); @protected PlatformPointer - cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsync) raw); @protected - PlatformPointer cst_encode_DartFn_Inputs__Output_DartOpaque( + PlatformPointer cst_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( FutureOr Function() raw); @protected - PlatformPointer cst_encode_DartFn_Inputs__Output_String( + PlatformPointer cst_encode_DartFn_Inputs__Output_String_AnyhowException( FutureOr Function() raw); @protected - PlatformPointer cst_encode_DartFn_Inputs__Output_unit( + PlatformPointer cst_encode_DartFn_Inputs__Output_unit_AnyhowException( FutureOr Function() raw); @protected PlatformPointer - cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinNormal) raw); @protected PlatformPointer - cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsync) raw); @@ -30928,23 +30940,27 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_Chrono_Utc(DateTime self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_DartOpaque_Output_unit( + void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_String_Output_unit( + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer); + + @protected + void sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( FutureOr Function(String) self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinNormal) self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsync) self, @@ -30952,7 +30968,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsyncSse) self, @@ -30960,26 +30976,26 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinSse) self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_DartOpaque( + void sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_String( + void sse_encode_DartFn_Inputs__Output_String_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_unit( + void sse_encode_DartFn_Inputs__Output_unit_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinNormal) self, @@ -30987,7 +31003,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsync) self, @@ -30995,7 +31011,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsyncSse) self, @@ -31003,7 +31019,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinSse) self, @@ -39558,6 +39574,30 @@ class RustLibWire implements BaseWire { _wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normalPtr .asFunction)>(); + void wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal( + int port_, + ffi.Pointer callback, + ffi.Pointer expect_output, + ) { + return _wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal( + port_, + callback, + expect_output, + ); + } + + late final _wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normalPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.Pointer, + ffi.Pointer)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal'); + late final _wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal = + _wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normalPtr + .asFunction< + void Function(int, ffi.Pointer, + ffi.Pointer)>(); + void wire__crate__api__dart_fn__rust_call_dart_return_twin_normal( int port_, ffi.Pointer callback, @@ -58014,6 +58054,31 @@ class RustLibWire implements BaseWire { _wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_asyncPtr .asFunction)>(); + void + wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async( + int port_, + ffi.Pointer callback, + ffi.Pointer expect_output, + ) { + return _wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async( + port_, + callback, + expect_output, + ); + } + + late final _wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_asyncPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.Pointer, + ffi.Pointer)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async'); + late final _wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async = + _wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_asyncPtr + .asFunction< + void Function(int, ffi.Pointer, + ffi.Pointer)>(); + void wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async( int port_, @@ -58194,6 +58259,31 @@ class RustLibWire implements BaseWire { _wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_one_arg_twin_rust_async_ssePtr .asFunction, int, int)>(); + void + wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_ssePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.Pointer, + ffi.Int32, ffi.Int32)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse'); + late final _wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse = + _wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_ssePtr + .asFunction, int, int)>(); + void wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_twin_rust_async_sse( int port_, @@ -58394,6 +58484,31 @@ class RustLibWire implements BaseWire { _wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_one_arg_twin_ssePtr .asFunction, int, int)>(); + void + wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_ssePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.Pointer, + ffi.Int32, ffi.Int32)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse'); + late final _wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse = + _wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_ssePtr + .asFunction, int, int)>(); + void wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_twin_sse( int port_, diff --git a/frb_example/pure_dart/lib/src/rust/frb_generated.web.dart b/frb_example/pure_dart/lib/src/rust/frb_generated.web.dart index 2195a9b604..a985777320 100644 --- a/frb_example/pure_dart/lib/src/rust/frb_generated.web.dart +++ b/frb_example/pure_dart/lib/src/rust/frb_generated.web.dart @@ -2052,65 +2052,72 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected FutureOr Function(Object) - dco_decode_DartFn_Inputs_DartOpaque_Output_unit(dynamic raw); + dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + dynamic raw); @protected - FutureOr Function(String) dco_decode_DartFn_Inputs_String_Output_unit( - dynamic raw); + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + dynamic raw); + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_unit_AnyhowException(dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinRustAsyncSse) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit_AnyhowException( dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinSse) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit_AnyhowException( dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_DartOpaque( - dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_String( - dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_String_AnyhowException(dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_unit(dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_unit_AnyhowException(dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinRustAsyncSse) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse_AnyhowException( dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinSse) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse_AnyhowException( dynamic raw); @protected @@ -26057,48 +26064,53 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithImplBlockInMultiFile raw); @protected - PlatformPointer cst_encode_DartFn_Inputs_DartOpaque_Output_unit( - FutureOr Function(Object) raw); + PlatformPointer + cst_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + FutureOr Function(Object) raw); + + @protected + PlatformPointer cst_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) raw); @protected - PlatformPointer cst_encode_DartFn_Inputs_String_Output_unit( + PlatformPointer cst_encode_DartFn_Inputs_String_Output_unit_AnyhowException( FutureOr Function(String) raw); @protected PlatformPointer - cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinNormal) raw); @protected PlatformPointer - cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + cst_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsync) raw); @protected - PlatformPointer cst_encode_DartFn_Inputs__Output_DartOpaque( + PlatformPointer cst_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( FutureOr Function() raw); @protected - PlatformPointer cst_encode_DartFn_Inputs__Output_String( + PlatformPointer cst_encode_DartFn_Inputs__Output_String_AnyhowException( FutureOr Function() raw); @protected - PlatformPointer cst_encode_DartFn_Inputs__Output_unit( + PlatformPointer cst_encode_DartFn_Inputs__Output_unit_AnyhowException( FutureOr Function() raw); @protected PlatformPointer - cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinNormal) raw); @protected PlatformPointer - cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + cst_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsync) raw); @@ -27618,23 +27630,27 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_Chrono_Utc(DateTime self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_DartOpaque_Output_unit( + void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_String_Output_unit( + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer); + + @protected + void sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( FutureOr Function(String) self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinNormal) self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsync) self, @@ -27642,7 +27658,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsyncSse) self, @@ -27650,26 +27666,26 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinSse) self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_DartOpaque( + void sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_String( + void sse_encode_DartFn_Inputs__Output_String_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_unit( + void sse_encode_DartFn_Inputs__Output_unit_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinNormal) self, @@ -27677,7 +27693,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsync) self, @@ -27685,7 +27701,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsyncSse) self, @@ -27693,7 +27709,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinSse) self, @@ -35504,6 +35520,14 @@ class RustLibWire implements BaseWire { wasmModule.wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal( port_, callback); + void wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal( + NativePortType port_, + PlatformPointer callback, + String? expect_output) => + wasmModule + .wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal( + port_, callback, expect_output); + void wire__crate__api__dart_fn__rust_call_dart_return_twin_normal( NativePortType port_, PlatformPointer callback) => wasmModule.wire__crate__api__dart_fn__rust_call_dart_return_twin_normal( @@ -41583,6 +41607,14 @@ class RustLibWire implements BaseWire { .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_async( port_, callback); + void wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async( + NativePortType port_, + PlatformPointer callback, + String? expect_output) => + wasmModule + .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async( + port_, callback, expect_output); + void wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async( NativePortType port_, PlatformPointer callback) => wasmModule @@ -41642,6 +41674,15 @@ class RustLibWire implements BaseWire { .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_one_arg_twin_rust_async_sse( port_, ptr_, rust_vec_len_, data_len_); + void wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse( + port_, ptr_, rust_vec_len_, data_len_); + void wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_twin_rust_async_sse( NativePortType port_, PlatformGeneralizedUint8ListPtr ptr_, @@ -41714,6 +41755,15 @@ class RustLibWire implements BaseWire { .wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_one_arg_twin_sse( port_, ptr_, rust_vec_len_, data_len_); + void wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse( + port_, ptr_, rust_vec_len_, data_len_); + void wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_twin_sse( NativePortType port_, PlatformGeneralizedUint8ListPtr ptr_, @@ -57018,6 +57068,12 @@ class RustLibWasmModule implements WasmModule { external void wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal( NativePortType port_, PlatformPointer callback); + external void + wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal( + NativePortType port_, + PlatformPointer callback, + String? expect_output); + external void wire__crate__api__dart_fn__rust_call_dart_return_twin_normal( NativePortType port_, PlatformPointer callback); @@ -61204,6 +61260,12 @@ class RustLibWasmModule implements WasmModule { wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_async( NativePortType port_, PlatformPointer callback); + external void + wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async( + NativePortType port_, + PlatformPointer callback, + String? expect_output); + external void wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async( NativePortType port_, PlatformPointer callback); @@ -61247,6 +61309,13 @@ class RustLibWasmModule implements WasmModule { int rust_vec_len_, int data_len_); + external void + wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + external void wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_twin_rust_async_sse( NativePortType port_, @@ -61303,6 +61372,13 @@ class RustLibWasmModule implements WasmModule { int rust_vec_len_, int data_len_); + external void + wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + external void wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_twin_sse( NativePortType port_, diff --git a/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_rust_async.rs b/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_rust_async.rs index 439d3c3801..c412bc8546 100644 --- a/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_rust_async.rs +++ b/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_rust_async.rs @@ -67,3 +67,10 @@ pub async fn rust_call_dart_multi_times_twin_rust_async( callback().await; } } + +pub async fn rust_call_dart_return_result_twin_rust_async( + callback: impl Fn(String) -> DartFnFuture>, + expect_output: Option, +) { + assert_eq!(callback("hi".to_owned()).await.ok(), expect_output); +} diff --git a/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_rust_async_sse.rs b/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_rust_async_sse.rs index c01b05b718..ac2140a726 100644 --- a/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_rust_async_sse.rs +++ b/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_rust_async_sse.rs @@ -79,3 +79,11 @@ pub async fn rust_call_dart_multi_times_twin_rust_async_sse( callback().await; } } + +#[flutter_rust_bridge::frb(serialize)] +pub async fn rust_call_dart_return_result_twin_rust_async_sse( + callback: impl Fn(String) -> DartFnFuture>, + expect_output: Option, +) { + assert_eq!(callback("hi".to_owned()).await.ok(), expect_output); +} diff --git a/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_sse.rs b/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_sse.rs index cb18aab284..e8e58971a8 100644 --- a/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_sse.rs +++ b/frb_example/pure_dart/rust/src/api/pseudo_manual/dart_fn_twin_sse.rs @@ -75,3 +75,11 @@ pub async fn rust_call_dart_multi_times_twin_sse( callback().await; } } + +#[flutter_rust_bridge::frb(serialize)] +pub async fn rust_call_dart_return_result_twin_sse( + callback: impl Fn(String) -> DartFnFuture>, + expect_output: Option, +) { + assert_eq!(callback("hi".to_owned()).await.ok(), expect_output); +} diff --git a/frb_example/pure_dart/rust/src/frb_generated.io.rs b/frb_example/pure_dart/rust/src/frb_generated.io.rs index d03f12af83..f9dfb9f8c7 100644 --- a/frb_example/pure_dart/rust/src/frb_generated.io.rs +++ b/frb_example/pure_dart/rust/src/frb_generated.io.rs @@ -16539,6 +16539,19 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_c wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal_impl(port_, callback) } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal( + port_: i64, + callback: *const std::ffi::c_void, + expect_output: *mut wire_cst_list_prim_u_8_strict, +) { + wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal_impl( + port_, + callback, + expect_output, + ) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__dart_fn__rust_call_dart_return_twin_normal( port_: i64, @@ -24323,6 +24336,15 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__ wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_async_impl(port_, callback) } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async( + port_: i64, + callback: *const std::ffi::c_void, + expect_output: *mut wire_cst_list_prim_u_8_strict, +) { + wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async_impl(port_, callback, expect_output) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async( port_: i64, @@ -24394,6 +24416,16 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__ wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_one_arg_twin_rust_async_sse_impl(port_, ptr_, rust_vec_len_, data_len_) } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse_impl(port_, ptr_, rust_vec_len_, data_len_) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_twin_rust_async_sse( port_: i64, @@ -24489,6 +24521,21 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__ ) } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_twin_sse( port_: i64, diff --git a/frb_example/pure_dart/rust/src/frb_generated.rs b/frb_example/pure_dart/rust/src/frb_generated.rs index 4ae2cd4feb..a44ec01dad 100644 --- a/frb_example/pure_dart/rust/src/frb_generated.rs +++ b/frb_example/pure_dart/rust/src/frb_generated.rs @@ -76,7 +76,7 @@ flutter_rust_bridge::frb_generated_boilerplate!( default_rust_auto_opaque = RustAutoOpaqueNom, ); pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.34"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -128436911; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1320820513; // Section: executor @@ -1027,7 +1027,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_loopback_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, callback: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_loopback_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal(callback.cst_decode()); move |context| async move { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_loopback_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco((move || async move { Result::<_,()>::Ok(crate::api::dart_fn::rust_call_dart_loopback_twin_normal(api_callback).await) })().await) @@ -1045,7 +1045,8 @@ fn wire__crate__api__dart_fn__rust_call_dart_multi_times_twin_normal_impl( mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let api_callback = decode_DartFn_Inputs__Output_unit(callback.cst_decode()); + let api_callback = + decode_DartFn_Inputs__Output_unit_AnyhowException(callback.cst_decode()); let api_num_times = num_times.cst_decode(); move |context| async move { transform_result_dco( @@ -1075,7 +1076,8 @@ fn wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal_impl( mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let api_callback = decode_DartFn_Inputs_String_Output_unit(callback.cst_decode()); + let api_callback = + decode_DartFn_Inputs_String_Output_unit_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco( (move || async move { @@ -1090,24 +1092,30 @@ fn wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal_impl( }, ) } -fn wire__crate__api__dart_fn__rust_call_dart_return_twin_normal_impl( +fn wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, callback: impl CstDecode, + expect_output: impl CstDecode>, ) { FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( flutter_rust_bridge::for_generated::TaskInfo { - debug_name: "rust_call_dart_return_twin_normal", + debug_name: "rust_call_dart_return_result_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let api_callback = decode_DartFn_Inputs__Output_String(callback.cst_decode()); + let api_callback = + decode_DartFn_Inputs_String_Output_String_AnyhowException(callback.cst_decode()); + let api_expect_output = expect_output.cst_decode(); move |context| async move { transform_result_dco( (move || async move { Result::<_, ()>::Ok( - crate::api::dart_fn::rust_call_dart_return_twin_normal(api_callback) - .await, + crate::api::dart_fn::rust_call_dart_return_result_twin_normal( + api_callback, + api_expect_output, + ) + .await, ) })() .await, @@ -1116,23 +1124,24 @@ fn wire__crate__api__dart_fn__rust_call_dart_return_twin_normal_impl( }, ) } -fn wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl( +fn wire__crate__api__dart_fn__rust_call_dart_return_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, callback: impl CstDecode, ) { FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( flutter_rust_bridge::for_generated::TaskInfo { - debug_name: "rust_call_dart_simple_twin_normal", + debug_name: "rust_call_dart_return_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let api_callback = decode_DartFn_Inputs__Output_unit(callback.cst_decode()); + let api_callback = + decode_DartFn_Inputs__Output_String_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco( (move || async move { Result::<_, ()>::Ok( - crate::api::dart_fn::rust_call_dart_simple_twin_normal(api_callback) + crate::api::dart_fn::rust_call_dart_return_twin_normal(api_callback) .await, ) })() @@ -1142,26 +1151,24 @@ fn wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl( }, ) } -fn wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal_impl( +fn wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, callback: impl CstDecode, ) { FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( flutter_rust_bridge::for_generated::TaskInfo { - debug_name: "rust_call_dart_two_args_twin_normal", + debug_name: "rust_call_dart_simple_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { let api_callback = - decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( - callback.cst_decode(), - ); + decode_DartFn_Inputs__Output_unit_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco( (move || async move { Result::<_, ()>::Ok( - crate::api::dart_fn::rust_call_dart_two_args_twin_normal(api_callback) + crate::api::dart_fn::rust_call_dart_simple_twin_normal(api_callback) .await, ) })() @@ -1171,6 +1178,16 @@ fn wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal_impl( }, ) } +fn wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + callback: impl CstDecode, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_two_args_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException(callback.cst_decode()); move |context| async move { + transform_result_dco((move || async move { + Result::<_,()>::Ok(crate::api::dart_fn::rust_call_dart_two_args_twin_normal(api_callback).await) + })().await) + } }) +} fn wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_arg_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, input: impl CstDecode, @@ -1184,7 +1201,8 @@ fn wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_arg_twin_normal_im }, move || { let api_input = input.cst_decode(); - let api_callback = decode_DartFn_Inputs_DartOpaque_Output_unit(callback.cst_decode()); + let api_callback = + decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco( (move || async move { @@ -1206,7 +1224,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_result_twin_normal port_: flutter_rust_bridge::for_generated::MessagePort, callback: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_with_dart_opaque_result_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs__Output_DartOpaque(callback.cst_decode()); move |context| async move { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_with_dart_opaque_result_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco((move || async move { Result::<_,()>::Ok(crate::api::dart_fn::rust_call_dart_with_dart_opaque_result_twin_normal(api_callback).await) })().await) @@ -14282,7 +14300,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_loop port_: flutter_rust_bridge::for_generated::MessagePort, callback: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_loopback_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async(callback.cst_decode()); move |context| async move { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_loopback_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_loopback_twin_rust_async(api_callback).await) })().await) @@ -14293,7 +14311,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_mult callback: impl CstDecode, num_times: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_multi_times_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs__Output_unit(callback.cst_decode());let api_num_times = num_times.cst_decode(); move |context| async move { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_multi_times_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs__Output_unit_AnyhowException(callback.cst_decode());let api_num_times = num_times.cst_decode(); move |context| async move { transform_result_dco((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_multi_times_twin_rust_async(api_callback, api_num_times).await) })().await) @@ -14303,17 +14321,28 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_ port_: flutter_rust_bridge::for_generated::MessagePort, callback: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_one_arg_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs_String_Output_unit(callback.cst_decode()); move |context| async move { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_one_arg_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs_String_Output_unit_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_one_arg_twin_rust_async(api_callback).await) })().await) } }) } +fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + callback: impl CstDecode, + expect_output: impl CstDecode>, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_return_result_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs_String_Output_String_AnyhowException(callback.cst_decode());let api_expect_output = expect_output.cst_decode(); move |context| async move { + transform_result_dco((move || async move { + Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_return_result_twin_rust_async(api_callback, api_expect_output).await) + })().await) + } }) +} fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async_impl( port_: flutter_rust_bridge::for_generated::MessagePort, callback: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_return_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs__Output_String(callback.cst_decode()); move |context| async move { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_return_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs__Output_String_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_return_twin_rust_async(api_callback).await) })().await) @@ -14323,7 +14352,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_simp port_: flutter_rust_bridge::for_generated::MessagePort, callback: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_simple_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs__Output_unit(callback.cst_decode()); move |context| async move { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_simple_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs__Output_unit_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_simple_twin_rust_async(api_callback).await) })().await) @@ -14333,7 +14362,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_two_ port_: flutter_rust_bridge::for_generated::MessagePort, callback: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_two_args_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit(callback.cst_decode()); move |context| async move { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_two_args_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_two_args_twin_rust_async(api_callback).await) })().await) @@ -14344,7 +14373,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with input: impl CstDecode, callback: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_with_dart_opaque_arg_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_input = input.cst_decode();let api_callback = decode_DartFn_Inputs_DartOpaque_Output_unit(callback.cst_decode()); move |context| async move { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_with_dart_opaque_arg_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_input = input.cst_decode();let api_callback = decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_with_dart_opaque_arg_twin_rust_async(api_input, api_callback).await) })().await) @@ -14354,7 +14383,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with port_: flutter_rust_bridge::for_generated::MessagePort, callback: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_with_dart_opaque_result_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs__Output_DartOpaque(callback.cst_decode()); move |context| async move { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_with_dart_opaque_result_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_callback = decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(callback.cst_decode()); move |context| async move { transform_result_dco((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_with_dart_opaque_result_twin_rust_async(api_callback).await) })().await) @@ -14369,7 +14398,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_ FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_loopback_twin_rust_async_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::rust_call_dart_loopback_twin_rust_async_sse(api_callback).await) })().await) @@ -14384,7 +14413,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_ FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_multi_times_twin_rust_async_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_unit(::sse_decode(&mut deserializer)); + let api_callback = decode_DartFn_Inputs__Output_unit_AnyhowException(::sse_decode(&mut deserializer)); let api_num_times = ::sse_decode(&mut deserializer);deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::rust_call_dart_multi_times_twin_rust_async_sse(api_callback, api_num_times).await) @@ -14400,12 +14429,28 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_ FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_one_arg_twin_rust_async_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_String_Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs_String_Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::rust_call_dart_one_arg_twin_rust_async_sse(api_callback).await) })().await) } }) } +fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_return_result_twin_rust_async_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { + let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_callback = decode_DartFn_Inputs_String_Output_String_AnyhowException(::sse_decode(&mut deserializer)); +let api_expect_output = >::sse_decode(&mut deserializer);deserializer.end(); move |context| async move { + transform_result_sse((move || async move { + Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::rust_call_dart_return_result_twin_rust_async_sse(api_callback, api_expect_output).await) + })().await) + } }) +} fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_twin_rust_async_sse_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -14415,7 +14460,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_ FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_return_twin_rust_async_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_String(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs__Output_String_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::rust_call_dart_return_twin_rust_async_sse(api_callback).await) })().await) @@ -14430,7 +14475,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_ FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_simple_twin_rust_async_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs__Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::rust_call_dart_simple_twin_rust_async_sse(api_callback).await) })().await) @@ -14445,7 +14490,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_ FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_two_args_twin_rust_async_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::rust_call_dart_two_args_twin_rust_async_sse(api_callback).await) })().await) @@ -14461,7 +14506,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_ let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); let api_input = ::sse_decode(&mut deserializer); -let api_callback = decode_DartFn_Inputs_DartOpaque_Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { +let api_callback = decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::rust_call_dart_with_dart_opaque_arg_twin_rust_async_sse(api_input, api_callback).await) })().await) @@ -14476,7 +14521,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_ FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_with_dart_opaque_result_twin_rust_async_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_DartOpaque(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::rust_call_dart_with_dart_opaque_result_twin_rust_async_sse(api_callback).await) })().await) @@ -14491,7 +14536,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_loopback_tw FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_loopback_twin_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_sse::rust_call_dart_loopback_twin_sse(api_callback).await) })().await) @@ -14506,7 +14551,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_multi_times FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_multi_times_twin_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_unit(::sse_decode(&mut deserializer)); + let api_callback = decode_DartFn_Inputs__Output_unit_AnyhowException(::sse_decode(&mut deserializer)); let api_num_times = ::sse_decode(&mut deserializer);deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_sse::rust_call_dart_multi_times_twin_sse(api_callback, api_num_times).await) @@ -14522,12 +14567,28 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_one_arg_twi FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_one_arg_twin_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_String_Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs_String_Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_sse::rust_call_dart_one_arg_twin_sse(api_callback).await) })().await) } }) } +fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_return_result_twin_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { + let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_callback = decode_DartFn_Inputs_String_Output_String_AnyhowException(::sse_decode(&mut deserializer)); +let api_expect_output = >::sse_decode(&mut deserializer);deserializer.end(); move |context| async move { + transform_result_sse((move || async move { + Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_sse::rust_call_dart_return_result_twin_sse(api_callback, api_expect_output).await) + })().await) + } }) +} fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_twin_sse_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -14537,7 +14598,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_twin FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_return_twin_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_String(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs__Output_String_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_sse::rust_call_dart_return_twin_sse(api_callback).await) })().await) @@ -14552,7 +14613,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_simple_twin FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_simple_twin_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs__Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_sse::rust_call_dart_simple_twin_sse(api_callback).await) })().await) @@ -14567,7 +14628,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_two_args_tw FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_two_args_twin_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_sse::rust_call_dart_two_args_twin_sse(api_callback).await) })().await) @@ -14583,7 +14644,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_with_dart_o let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); let api_input = ::sse_decode(&mut deserializer); -let api_callback = decode_DartFn_Inputs_DartOpaque_Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { +let api_callback = decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_sse::rust_call_dart_with_dart_opaque_arg_twin_sse(api_input, api_callback).await) })().await) @@ -14598,7 +14659,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_with_dart_o FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_with_dart_opaque_result_twin_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_DartOpaque(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_sse::rust_call_dart_with_dart_opaque_result_twin_sse(api_callback).await) })().await) @@ -41085,7 +41146,7 @@ const _: fn() = || { // Section: related_funcs -fn decode_DartFn_Inputs_DartOpaque_Output_unit( +fn decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn(flutter_rust_bridge::DartOpaque) -> flutter_rust_bridge::DartFnFuture<()> { use flutter_rust_bridge::IntoDart; @@ -41098,7 +41159,19 @@ fn decode_DartFn_Inputs_DartOpaque_Output_unit( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: flutter_rust_bridge::DartOpaque| { @@ -41108,7 +41181,45 @@ fn decode_DartFn_Inputs_DartOpaque_Output_unit( )) } } -fn decode_DartFn_Inputs_String_Output_unit( +fn decode_DartFn_Inputs_String_Output_String_AnyhowException( + dart_opaque: flutter_rust_bridge::DartOpaque, +) -> impl Fn( + String, +) -> flutter_rust_bridge::DartFnFuture< + std::result::Result, +> { + use flutter_rust_bridge::IntoDart; + + async fn body( + dart_opaque: flutter_rust_bridge::DartOpaque, + arg0: String, + ) -> std::result::Result { + let args = vec![arg0.into_into_dart().into_dart()]; + let message = FLUTTER_RUST_BRIDGE_HANDLER + .dart_fn_invoke(dart_opaque, args) + .await; + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + ans + } + + move |arg0: String| { + flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body( + dart_opaque.clone(), + arg0, + )) + } +} +fn decode_DartFn_Inputs_String_Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture<()> { use flutter_rust_bridge::IntoDart; @@ -41118,7 +41229,19 @@ fn decode_DartFn_Inputs_String_Output_unit( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: String| { @@ -41128,7 +41251,7 @@ fn decode_DartFn_Inputs_String_Output_unit( )) } } -fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( +fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( String, @@ -41148,7 +41271,19 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: String, arg1: crate::api::dart_fn::DemoStructForRustCallDartTwinNormal| { @@ -41159,7 +41294,7 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output )) } } -fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( +fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( String, @@ -41179,7 +41314,19 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Ou let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: String, arg1: crate::api::pseudo_manual::dart_fn_twin_rust_async::DemoStructForRustCallDartTwinRustAsync| { @@ -41187,7 +41334,7 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Ou dart_opaque.clone(), arg0, arg1 )) } -}fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit( +}fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn(String, crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::DemoStructForRustCallDartTwinRustAsyncSse) -> flutter_rust_bridge::DartFnFuture<()>{ use flutter_rust_bridge::IntoDart; @@ -41204,7 +41351,19 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Ou let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: String, arg1: crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::DemoStructForRustCallDartTwinRustAsyncSse| { @@ -41213,7 +41372,7 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Ou )) } } -fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit( +fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( String, @@ -41233,7 +41392,19 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_un let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: String, @@ -41245,7 +41416,7 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_sse_Output_un )) } } -fn decode_DartFn_Inputs__Output_DartOpaque( +fn decode_DartFn_Inputs__Output_DartOpaque_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn() -> flutter_rust_bridge::DartFnFuture { use flutter_rust_bridge::IntoDart; @@ -41255,14 +41426,28 @@ fn decode_DartFn_Inputs__Output_DartOpaque( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - ::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode( + &mut deserializer, + )), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move || { flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body(dart_opaque.clone())) } } -fn decode_DartFn_Inputs__Output_String( +fn decode_DartFn_Inputs__Output_String_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn() -> flutter_rust_bridge::DartFnFuture { use flutter_rust_bridge::IntoDart; @@ -41272,14 +41457,26 @@ fn decode_DartFn_Inputs__Output_String( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - ::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move || { flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body(dart_opaque.clone())) } } -fn decode_DartFn_Inputs__Output_unit( +fn decode_DartFn_Inputs__Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn() -> flutter_rust_bridge::DartFnFuture<()> { use flutter_rust_bridge::IntoDart; @@ -41289,14 +41486,26 @@ fn decode_DartFn_Inputs__Output_unit( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move || { flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body(dart_opaque.clone())) } } -fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( +fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( crate::api::dart_fn::DemoStructForRustCallDartTwinNormal, @@ -41313,7 +41522,23 @@ fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_s let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - ::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok( + ::sse_decode( + &mut deserializer, + ), + ), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: crate::api::dart_fn::DemoStructForRustCallDartTwinNormal| { @@ -41323,7 +41548,7 @@ fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_s )) } } -fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( +fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( crate::api::pseudo_manual::dart_fn_twin_rust_async::DemoStructForRustCallDartTwinRustAsync, @@ -41341,7 +41566,17 @@ fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_de let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - ::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err(::sse_decode(&mut deserializer)), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: crate::api::pseudo_manual::dart_fn_twin_rust_async::DemoStructForRustCallDartTwinRustAsync| { @@ -41349,7 +41584,7 @@ fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_de dart_opaque.clone(), arg0 )) } -}fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse( +}fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_sse_Output_demo_struct_for_rust_call_dart_twin_rust_async_sse_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn(crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::DemoStructForRustCallDartTwinRustAsyncSse) -> flutter_rust_bridge::DartFnFuture{ use flutter_rust_bridge::IntoDart; @@ -41359,7 +41594,17 @@ fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_de let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - ::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err(::sse_decode(&mut deserializer)), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: crate::api::pseudo_manual::dart_fn_twin_rust_async_sse::DemoStructForRustCallDartTwinRustAsyncSse| { @@ -41368,7 +41613,7 @@ fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_de )) } } -fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse( +fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_struct_for_rust_call_dart_twin_sse_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( crate::api::pseudo_manual::dart_fn_twin_sse::DemoStructForRustCallDartTwinSse, @@ -41385,7 +41630,17 @@ fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_sse_Output_demo_stru let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - ::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err(::sse_decode(&mut deserializer)), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: crate::api::pseudo_manual::dart_fn_twin_sse::DemoStructForRustCallDartTwinSse| { @@ -41961,7 +42216,8 @@ impl CstDecode Self { - unreachable!(""); + let mut inner = ::sse_decode(deserializer); + return anyhow::anyhow!("{}", inner); } } diff --git a/frb_example/pure_dart/rust/src/frb_generated.web.rs b/frb_example/pure_dart/rust/src/frb_generated.web.rs index dbfad3c285..cfc40a8d32 100644 --- a/frb_example/pure_dart/rust/src/frb_generated.web.rs +++ b/frb_example/pure_dart/rust/src/frb_generated.web.rs @@ -13463,6 +13463,19 @@ pub fn wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal( wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal_impl(port_, callback) } +#[wasm_bindgen] +pub fn wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal( + port_: flutter_rust_bridge::for_generated::MessagePort, + callback: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + expect_output: Option, +) { + wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal_impl( + port_, + callback, + expect_output, + ) +} + #[wasm_bindgen] pub fn wire__crate__api__dart_fn__rust_call_dart_return_twin_normal( port_: flutter_rust_bridge::for_generated::MessagePort, @@ -21247,6 +21260,15 @@ pub fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_ wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_async_impl(port_, callback) } +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async( + port_: flutter_rust_bridge::for_generated::MessagePort, + callback: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + expect_output: Option, +) { + wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async_impl(port_, callback, expect_output) +} + #[wasm_bindgen] pub fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async( port_: flutter_rust_bridge::for_generated::MessagePort, @@ -21318,6 +21340,16 @@ pub fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_d wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_one_arg_twin_rust_async_sse_impl(port_, ptr_, rust_vec_len_, data_len_) } +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_result_twin_rust_async_sse_impl(port_, ptr_, rust_vec_len_, data_len_) +} + #[wasm_bindgen] pub fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async_sse__rust_call_dart_return_twin_rust_async_sse( port_: flutter_rust_bridge::for_generated::MessagePort, @@ -21413,6 +21445,21 @@ pub fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_one_arg ) } +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_result_twin_sse_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + #[wasm_bindgen] pub fn wire__crate__api__pseudo_manual__dart_fn_twin_sse__rust_call_dart_return_twin_sse( port_: flutter_rust_bridge::for_generated::MessagePort, diff --git a/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_rust_async_sse_test.dart b/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_rust_async_sse_test.dart index 29af0374b5..900f0bda05 100644 --- a/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_rust_async_sse_test.dart +++ b/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_rust_async_sse_test.dart @@ -87,4 +87,17 @@ Future main({bool skipRustLibInit = false}) async { callback: () => callCount++, numTimes: 10); expect(callCount, 10); }); + + group('rustCallDartReturnResultTwinRustAsyncSse', () { + test('when normal', () async { + await rustCallDartReturnResultTwinRustAsyncSse( + callback: (s) => s * 2, expectOutput: "hihi"); + }); + + test('when error', () async { + await rustCallDartReturnResultTwinRustAsyncSse( + callback: (s) => throw Exception('dummy exception'), + expectOutput: null); + }); + }); } diff --git a/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_rust_async_test.dart b/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_rust_async_test.dart index 673d1fd7da..89575845f3 100644 --- a/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_rust_async_test.dart +++ b/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_rust_async_test.dart @@ -85,4 +85,17 @@ Future main({bool skipRustLibInit = false}) async { callback: () => callCount++, numTimes: 10); expect(callCount, 10); }); + + group('rustCallDartReturnResultTwinRustAsync', () { + test('when normal', () async { + await rustCallDartReturnResultTwinRustAsync( + callback: (s) => s * 2, expectOutput: "hihi"); + }); + + test('when error', () async { + await rustCallDartReturnResultTwinRustAsync( + callback: (s) => throw Exception('dummy exception'), + expectOutput: null); + }); + }); } diff --git a/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_sse_test.dart b/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_sse_test.dart index 82e618dc2b..c60fce643a 100644 --- a/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_sse_test.dart +++ b/frb_example/pure_dart/test/api/pseudo_manual/dart_fn_twin_sse_test.dart @@ -82,4 +82,17 @@ Future main({bool skipRustLibInit = false}) async { callback: () => callCount++, numTimes: 10); expect(callCount, 10); }); + + group('rustCallDartReturnResultTwinSse', () { + test('when normal', () async { + await rustCallDartReturnResultTwinSse( + callback: (s) => s * 2, expectOutput: "hihi"); + }); + + test('when error', () async { + await rustCallDartReturnResultTwinSse( + callback: (s) => throw Exception('dummy exception'), + expectOutput: null); + }); + }); } diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/dart_fn.dart b/frb_example/pure_dart_pde/lib/src/rust/api/dart_fn.dart index e7628efe6e..0be5cfee39 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/dart_fn.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/dart_fn.dart @@ -57,6 +57,13 @@ Future rustCallDartMultiTimesTwinNormal( RustLib.instance.api.crateApiDartFnRustCallDartMultiTimesTwinNormal( callback: callback, numTimes: numTimes, hint: hint); +Future rustCallDartReturnResultTwinNormal( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) => + RustLib.instance.api.crateApiDartFnRustCallDartReturnResultTwinNormal( + callback: callback, expectOutput: expectOutput, hint: hint); + class DemoStructForRustCallDartTwinNormal { final String name; diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async.dart b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async.dart index f72e56e515..6f244815a9 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/dart_fn_twin_rust_async.dart @@ -64,6 +64,14 @@ Future rustCallDartMultiTimesTwinRustAsync( .crateApiPseudoManualDartFnTwinRustAsyncRustCallDartMultiTimesTwinRustAsync( callback: callback, numTimes: numTimes, hint: hint); +Future rustCallDartReturnResultTwinRustAsync( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) => + RustLib.instance.api + .crateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnResultTwinRustAsync( + callback: callback, expectOutput: expectOutput, hint: hint); + class DemoStructForRustCallDartTwinRustAsync { final String name; diff --git a/frb_example/pure_dart_pde/lib/src/rust/frb_generated.dart b/frb_example/pure_dart_pde/lib/src/rust/frb_generated.dart index 9017261c3c..6cd8028528 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/frb_generated.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/frb_generated.dart @@ -182,7 +182,7 @@ class RustLib extends BaseEntrypoint { String get codegenVersion => '2.0.0-dev.34'; @override - int get rustContentHash => 571456469; + int get rustContentHash => -1044428238; static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig( @@ -352,6 +352,11 @@ abstract class RustLibApi extends BaseApi { Future crateApiDartFnRustCallDartOneArgTwinNormal( {required FutureOr Function(String) callback, dynamic hint}); + Future crateApiDartFnRustCallDartReturnResultTwinNormal( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}); + Future crateApiDartFnRustCallDartReturnTwinNormal( {required FutureOr Function() callback, dynamic hint}); @@ -2147,6 +2152,12 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualDartFnTwinRustAsyncRustCallDartOneArgTwinRustAsync( {required FutureOr Function(String) callback, dynamic hint}); + Future + crateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnResultTwinRustAsync( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}); + Future crateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnTwinRustAsync( {required FutureOr Function() callback, dynamic hint}); @@ -6194,7 +6205,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 54, port: port_); @@ -6224,7 +6235,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_unit(callback, serializer); + sse_encode_DartFn_Inputs__Output_unit_AnyhowException( + callback, serializer); sse_encode_i_32(numTimes, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 57, port: port_); @@ -6252,7 +6264,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_unit(callback, serializer); + sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( + callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 51, port: port_); }, @@ -6273,13 +6286,46 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["callback"], ); + @override + Future crateApiDartFnRustCallDartReturnResultTwinNormal( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + callback, serializer); + sse_encode_opt_String(expectOutput, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 58, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: kCrateApiDartFnRustCallDartReturnResultTwinNormalConstMeta, + argValues: [callback, expectOutput], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiDartFnRustCallDartReturnResultTwinNormalConstMeta => + const TaskConstMeta( + debugName: "rust_call_dart_return_result_twin_normal", + argNames: ["callback", "expectOutput"], + ); + @override Future crateApiDartFnRustCallDartReturnTwinNormal( {required FutureOr Function() callback, dynamic hint}) { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_String(callback, serializer); + sse_encode_DartFn_Inputs__Output_String_AnyhowException( + callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 53, port: port_); }, @@ -6306,7 +6352,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_unit(callback, serializer); + sse_encode_DartFn_Inputs__Output_unit_AnyhowException( + callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 50, port: port_); }, @@ -6336,7 +6383,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 52, port: port_); @@ -6367,7 +6414,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(input, serializer); - sse_encode_DartFn_Inputs_DartOpaque_Output_unit(callback, serializer); + sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 55, port: port_); }, @@ -6396,7 +6444,8 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_DartOpaque(callback, serializer); + sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( + callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 56, port: port_); }, @@ -6427,7 +6476,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 58, port: port_); + funcId: 59, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -6455,7 +6504,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 73, port: port_); + funcId: 74, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -6483,7 +6532,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 69, port: port_); + funcId: 70, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_dart_opaque_twin_normal, @@ -6513,7 +6562,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartOpaque(opaque1, serializer); sse_encode_DartOpaque(opaque2, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 67, port: port_); + funcId: 68, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_dart_opaque_nested_twin_normal, @@ -6541,7 +6590,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 72, port: port_); + funcId: 73, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6569,7 +6618,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_dart_opaque_twin_normal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 70, port: port_); + funcId: 71, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6597,7 +6646,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_dart_opaque_nested_twin_normal( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 68, port: port_); + funcId: 69, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6624,7 +6673,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque_array_1(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 64, port: port_); + funcId: 65, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6651,7 +6700,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 61, port: port_); + funcId: 62, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque_array_1, @@ -6678,7 +6727,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 63, port: port_); + funcId: 64, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6705,7 +6754,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 60, port: port_); + funcId: 61, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -6732,7 +6781,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 59, port: port_); + funcId: 60, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -6759,7 +6808,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 65, port: port_); + funcId: 66, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6786,7 +6835,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 62, port: port_); + funcId: 63, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -6813,7 +6862,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 66, port: port_); + funcId: 67, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6842,7 +6891,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(id, serializer); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 71, port: port_); + funcId: 72, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6868,7 +6917,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 76)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 77)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -6895,7 +6944,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 74)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 75)!; }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -6921,7 +6970,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 78)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 79)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -6948,7 +6997,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 75)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 76)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -6975,7 +7024,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 77)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 78)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -7004,7 +7053,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_in_lower_level(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 79, port: port_); + funcId: 80, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_in_upper_level, @@ -7036,7 +7085,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_StreamSink_i_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 82, port: port_); + funcId: 83, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7063,7 +7112,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 83, port: port_); + funcId: 84, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -7091,7 +7140,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 80, port: port_); + funcId: 81, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -7121,7 +7170,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDroppableTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 81, port: port_); + funcId: 82, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7150,7 +7199,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_simple_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 84, port: port_); + funcId: 85, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_simple_twin_normal, @@ -7178,7 +7227,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_with_discriminant_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 88, port: port_); + funcId: 89, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_discriminant_twin_normal, @@ -7209,7 +7258,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_mixed_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 85, port: port_); + funcId: 86, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_mixed_twin_normal, @@ -7239,7 +7288,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_struct_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 87, port: port_); + funcId: 88, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_struct_twin_normal, @@ -7269,7 +7318,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_tuple_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 86, port: port_); + funcId: 87, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_tuple_twin_normal, @@ -7297,7 +7346,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_weekdays_twin_normal(weekday, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 91, port: port_); + funcId: 92, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_weekdays_twin_normal, @@ -7325,7 +7374,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_kitchen_sink_twin_normal(val, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 93, port: port_); + funcId: 94, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_kitchen_sink_twin_normal, @@ -7352,7 +7401,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 90, port: port_); + funcId: 91, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_weekdays_twin_normal, @@ -7379,7 +7428,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_measure_twin_normal(measure, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 92, port: port_); + funcId: 93, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_measure_twin_normal, @@ -7406,7 +7455,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_note_twin_normal(note, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 89, port: port_); + funcId: 90, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -7432,7 +7481,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 95, port: port_); + funcId: 96, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7460,7 +7509,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(address, serializer); sse_encode_String(payload, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 97)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 98)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7488,7 +7537,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(address, serializer); sse_encode_String(payload, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 96, port: port_); + funcId: 97, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7515,7 +7564,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_event_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 98, port: port_); + funcId: 99, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -7546,7 +7595,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_event_twin_normal_Sse(listener, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 94, port: port_); + funcId: 95, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7573,7 +7622,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 103, port: port_); + funcId: 104, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7599,7 +7648,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 104, port: port_); + funcId: 105, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -7628,7 +7677,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 102, port: port_); + funcId: 103, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -7657,7 +7706,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_custom_nested_error_outer_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 105, port: port_); + funcId: 106, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7686,7 +7735,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_error_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 106, port: port_); + funcId: 107, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7716,7 +7765,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(message, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 123, port: port_); + funcId: 124, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_custom_struct_twin_normal, @@ -7745,7 +7794,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 126, port: port_); + funcId: 127, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7776,7 +7825,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 127, port: port_); + funcId: 128, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -7806,7 +7855,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 124, port: port_); + funcId: 125, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7836,7 +7885,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 125, port: port_); + funcId: 126, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -7864,7 +7913,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 99, port: port_); + funcId: 100, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -7889,7 +7938,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 100, port: port_); + funcId: 101, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -7916,7 +7965,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 101, port: port_); + funcId: 102, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -7943,7 +7992,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 116, port: port_); + funcId: 117, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7970,7 +8019,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 110, port: port_); + funcId: 111, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7997,7 +8046,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 111, port: port_); + funcId: 112, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8025,7 +8074,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 112, port: port_); + funcId: 113, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8052,7 +8101,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 113, port: port_); + funcId: 114, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8078,7 +8127,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 114, port: port_); + funcId: 115, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8103,7 +8152,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 107, port: port_); + funcId: 108, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8130,7 +8179,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(variant, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 109, port: port_); + funcId: 110, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8155,7 +8204,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 108, port: port_); + funcId: 109, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8183,7 +8232,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 118, port: port_); + funcId: 119, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_some_struct_twin_normal, @@ -8212,7 +8261,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_some_struct_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 121, port: port_); + funcId: 122, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8243,7 +8292,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_some_struct_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 122, port: port_); + funcId: 123, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8273,7 +8322,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 119, port: port_); + funcId: 120, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8303,7 +8352,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 120, port: port_); + funcId: 121, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8334,7 +8383,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 117, port: port_); + funcId: 118, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8361,7 +8410,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 115, port: port_); + funcId: 116, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8388,7 +8437,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(a, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 129)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 130)!; }, codec: SseCodec( decodeSuccessData: @@ -8420,7 +8469,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 130, port: port_); + funcId: 131, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -8453,7 +8502,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_simple_translatable_external_struct_with_method( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 128, port: port_); + funcId: 129, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -8482,7 +8531,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 134, port: port_); + funcId: 135, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_new_simple_struct, @@ -8510,7 +8559,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 133, port: port_); + funcId: 134, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_old_simple_struct, @@ -8539,7 +8588,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_my_enum(myEnum, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 132, port: port_); + funcId: 133, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -8567,7 +8616,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_struct(myStruct, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 131, port: port_); + funcId: 132, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -8595,7 +8644,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 136, port: port_); + funcId: 137, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_another_macro_struct_twin_normal, @@ -8622,7 +8671,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_macro_struct(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 135, port: port_); + funcId: 136, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_macro_struct, @@ -8649,7 +8698,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 137, port: port_); + funcId: 138, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -8677,7 +8726,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 141, port: port_); + funcId: 142, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_list_prim_u_8_strict, @@ -8706,7 +8755,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_kitchen_sink_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 144, port: port_); + funcId: 145, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_kitchen_sink_twin_normal, @@ -8736,7 +8785,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_enum_simple_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 143, port: port_); + funcId: 144, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_enum_simple_twin_normal, @@ -8766,7 +8815,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 139, port: port_); + funcId: 140, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_String, @@ -8795,7 +8844,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_my_size(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 142, port: port_); + funcId: 143, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_my_size, @@ -8823,7 +8872,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 138, port: port_); + funcId: 139, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Set_i_32, @@ -8850,7 +8899,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 140, port: port_); + funcId: 141, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Set_String, @@ -8876,7 +8925,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 166, port: port_); + funcId: 167, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -8907,7 +8956,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(a, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 149, port: port_); + funcId: 150, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -8940,7 +8989,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_concatenate_with_twin_normal(that, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 148, port: port_); + funcId: 149, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -8971,7 +9020,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_u_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 154, port: port_); + funcId: 155, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9006,7 +9055,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_2_twin_normal_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 153, port: port_); + funcId: 154, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9040,7 +9089,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_concatenate_with_twin_normal(that, serializer); sse_encode_StreamSink_u_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 152, port: port_); + funcId: 153, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9079,7 +9128,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_2_twin_normal_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 151, port: port_); + funcId: 152, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9111,7 +9160,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(a, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 147, port: port_); + funcId: 148, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_concatenate_with_twin_normal, @@ -9139,7 +9188,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_concatenate_with_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 150, port: port_); + funcId: 151, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9170,7 +9219,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(b, serializer); sse_encode_u_32(c, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 146, port: port_); + funcId: 147, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_normal_array_3, @@ -9196,7 +9245,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 145, port: port_); + funcId: 146, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_normal, @@ -9224,7 +9273,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_callable_twin_normal(that, serializer); sse_encode_String(two, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 156, port: port_); + funcId: 157, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9252,7 +9301,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 162, port: port_); + funcId: 163, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_enum_twin_normal, @@ -9281,7 +9330,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_enum_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 163, port: port_); + funcId: 164, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9310,7 +9359,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_simple_primitive_enum_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 164, port: port_); + funcId: 165, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -9343,7 +9392,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_simple_struct_twin_normal(a, serializer); sse_encode_box_autoadd_simple_struct_twin_normal(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 160, port: port_); + funcId: 161, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9372,7 +9421,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 158, port: port_); + funcId: 159, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9401,7 +9450,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 159, port: port_); + funcId: 160, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9431,7 +9480,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 157, port: port_); + funcId: 158, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_twin_normal, @@ -9460,7 +9509,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_simple_struct_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 161, port: port_); + funcId: 162, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -9489,7 +9538,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(a, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 165, port: port_); + funcId: 166, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -9523,7 +9572,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(y, serializer); sse_encode_u_32(z, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 155, port: port_); + funcId: 156, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -9551,7 +9600,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_settings_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 170, port: port_); + funcId: 171, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9580,7 +9629,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_settings_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 171, port: port_); + funcId: 172, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9608,7 +9657,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_numbers(nums, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 177, port: port_); + funcId: 178, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -9635,7 +9684,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_sequences(seqs, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 178, port: port_); + funcId: 179, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -9661,7 +9710,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 167, port: port_); + funcId: 168, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -9687,7 +9736,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 168, port: port_); + funcId: 169, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -9713,7 +9762,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 174, port: port_); + funcId: 175, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_message, @@ -9740,7 +9789,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_application_settings(appSettings, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 169, port: port_); + funcId: 170, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -9768,7 +9817,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_array_2_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 192, port: port_); + funcId: 193, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9797,7 +9846,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 187, port: port_); + funcId: 188, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9826,7 +9875,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Map_u_8_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 190, port: port_); + funcId: 191, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9856,7 +9905,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_opt_box_autoadd_application_mode_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 188, port: port_); + funcId: 189, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9885,7 +9934,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Set_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 191, port: port_); + funcId: 192, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9914,7 +9963,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_mirror_struct_twin_normal_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 172, port: port_); + funcId: 173, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9944,7 +9993,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_record_application_settings_raw_string_enum_mirrored_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 173, port: port_); + funcId: 174, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9973,7 +10022,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 189, port: port_); + funcId: 190, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10002,7 +10051,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(num, serializer); sse_encode_usize(times, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 175, port: port_); + funcId: 176, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_numbers, @@ -10030,7 +10079,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(seq, serializer); sse_encode_usize(times, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 176, port: port_); + funcId: 177, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sequences, @@ -10056,7 +10105,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 185, port: port_); + funcId: 186, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_contains_mirrored_sub_struct_twin_normal, @@ -10084,7 +10133,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 183, port: port_); + funcId: 184, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_mirrored, @@ -10112,7 +10161,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 186, port: port_); + funcId: 187, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_hash_map, @@ -10139,7 +10188,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 184, port: port_); + funcId: 185, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_enum_mirrored, @@ -10168,7 +10217,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 182, port: port_); + funcId: 183, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_of_nested_raw_string_mirrored, @@ -10196,7 +10245,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 180, port: port_); + funcId: 181, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_nested_raw_string_mirrored, @@ -10225,7 +10274,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(nested, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 181, port: port_); + funcId: 182, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_enum_mirrored, @@ -10252,7 +10301,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 179, port: port_); + funcId: 180, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_mirrored, @@ -10278,7 +10327,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 196, port: port_); + funcId: 197, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_big_buffers_twin_normal, @@ -10305,7 +10354,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_tree_node_twin_normal(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 193, port: port_); + funcId: 194, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_tree_node_twin_normal, @@ -10334,7 +10383,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_nested_struct_twin_normal(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 195, port: port_); + funcId: 196, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_nested_struct_twin_normal, @@ -10361,7 +10410,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 199, port: port_); + funcId: 200, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -10389,7 +10438,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_size(arg, serializer); sse_encode_box_my_size(boxed, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 201, port: port_); + funcId: 202, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_size, @@ -10416,7 +10465,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(v, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 200, port: port_); + funcId: 201, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -10444,7 +10493,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_weekdays_twin_normal(weekdays, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 194, port: port_); + funcId: 195, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_weekdays_twin_normal, @@ -10472,7 +10521,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_abc_twin_normal(abc, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 197, port: port_); + funcId: 198, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_abc_twin_normal, @@ -10500,7 +10549,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_enum_twin_normal(se, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 198, port: port_); + funcId: 199, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_enum_twin_normal, @@ -10529,7 +10578,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 203, port: port_); + funcId: 204, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10560,7 +10609,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithImplBlockInMultiFile( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 204, port: port_); + funcId: 205, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10588,7 +10637,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 202, port: port_); + funcId: 203, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10618,7 +10667,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_impl_block_in_another_file_dependency( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 209, port: port_); + funcId: 210, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10649,7 +10698,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleB( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 206, port: port_); + funcId: 207, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -10682,7 +10731,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleB( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 207, port: port_); + funcId: 208, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10713,7 +10762,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithImplBlockInMultiFile( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 208, port: port_); + funcId: 209, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10741,7 +10790,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 205, port: port_); + funcId: 206, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10770,7 +10819,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_empty_twin_normal(empty, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 213, port: port_); + funcId: 214, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_empty_twin_normal, @@ -10795,7 +10844,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 210, port: port_); + funcId: 211, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10822,7 +10871,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_my_size(l, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 211, port: port_); + funcId: 212, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_my_size, @@ -10849,7 +10898,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(names, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 212, port: port_); + funcId: 213, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -10876,7 +10925,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_new_type_int_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 214, port: port_); + funcId: 215, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_new_type_int_twin_normal, @@ -10903,7 +10952,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_f_64(opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 218, port: port_); + funcId: 219, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -10945,7 +10994,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_bool(boolbox, serializer); sse_encode_opt_box_exotic_optionals_twin_normal(structbox, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 220, port: port_); + funcId: 221, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -10983,7 +11032,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_exotic_optionals_twin_normal( opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 217, port: port_); + funcId: 218, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -11013,7 +11062,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(left, serializer); sse_encode_f_64(right, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 215, port: port_); + funcId: 216, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -11040,7 +11089,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(document, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 216, port: port_); + funcId: 217, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_element_twin_normal, @@ -11067,7 +11116,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_opt_vecs_twin_normal(opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 219, port: port_); + funcId: 220, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_vecs_twin_normal, @@ -11097,7 +11146,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_f_64(myF64, serializer); sse_encode_opt_box_autoadd_bool(myBool, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 221, port: port_); + funcId: 222, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -11126,7 +11175,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 224, port: port_); + funcId: 225, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -11153,7 +11202,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 223, port: port_); + funcId: 224, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -11180,7 +11229,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 222, port: port_); + funcId: 223, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -11209,7 +11258,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_simple_struct_for_borrow_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 225, port: port_); + funcId: 226, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_for_borrow_twin_normal, @@ -11237,7 +11286,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(n, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 226, port: port_); + funcId: 227, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_vec_of_primitive_pack_twin_normal, @@ -11273,7 +11322,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(myF64, serializer); sse_encode_bool(myBool, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 227, port: port_); + funcId: 228, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -11300,7 +11349,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(myU32, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 228, port: port_); + funcId: 229, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -11328,7 +11377,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_u_8_array_1600(blob, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 233, port: port_); + funcId: 234, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_blob_twin_rust_async, @@ -11358,7 +11407,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_test_id_twin_rust_async(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 237, port: port_); + funcId: 238, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_rust_async, @@ -11386,7 +11435,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 229, port: port_); + funcId: 230, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_5, @@ -11415,7 +11464,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 230, port: port_); + funcId: 231, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_point_twin_rust_async_array_2, @@ -11444,7 +11493,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64_array_16(array, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 238, port: port_); + funcId: 239, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -11474,7 +11523,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_test_id_twin_rust_async_array_4(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 239, port: port_); + funcId: 240, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_rust_async_array_2, @@ -11504,7 +11553,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8_array_32(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 231, port: port_); + funcId: 232, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_message_id_twin_rust_async, @@ -11534,7 +11583,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8_array_8(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 235, port: port_); + funcId: 236, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_box_feed_id_twin_rust_async, @@ -11564,7 +11613,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feed_id_twin_rust_async(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 236, port: port_); + funcId: 237, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_box_u_8_array_8, @@ -11594,7 +11643,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_blob_twin_rust_async(blob, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 234, port: port_); + funcId: 235, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_1600, @@ -11623,7 +11672,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_message_id_twin_rust_async(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 232, port: port_); + funcId: 233, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_32, @@ -11651,7 +11700,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_u_8_array_1600(blob, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 244)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 245)!; }, codec: SseCodec( decodeSuccessData: sse_decode_blob_twin_sync, @@ -11678,7 +11727,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_test_id_twin_sync(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 248)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 249)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_sync, @@ -11703,7 +11752,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 240)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 241)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_5, @@ -11729,7 +11778,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 241)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 242)!; }, codec: SseCodec( decodeSuccessData: sse_decode_point_twin_sync_array_2, @@ -11757,7 +11806,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64_array_16(array, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 249)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 250)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -11784,7 +11833,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_test_id_twin_sync_array_4(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 250)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 251)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_sync_array_2, @@ -11811,7 +11860,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8_array_32(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 242)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 243)!; }, codec: SseCodec( decodeSuccessData: sse_decode_message_id_twin_sync, @@ -11838,7 +11887,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8_array_8(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 246)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 247)!; }, codec: SseCodec( decodeSuccessData: sse_decode_box_feed_id_twin_sync, @@ -11866,7 +11915,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feed_id_twin_sync(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 247)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 248)!; }, codec: SseCodec( decodeSuccessData: sse_decode_box_u_8_array_8, @@ -11894,7 +11943,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_blob_twin_sync(blob, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 245)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 246)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_1600, @@ -11922,7 +11971,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_message_id_twin_sync(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 243)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 244)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_32, @@ -11951,7 +12000,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_customized_twin_rust_async(val, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 252, port: port_); + funcId: 253, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11982,7 +12031,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_user_id_twin_rust_async(userId, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 253, port: port_); + funcId: 254, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_user_id_twin_rust_async, @@ -12010,7 +12059,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_customized_twin_sync(val, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 257)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 258)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -12038,7 +12087,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_user_id_twin_sync(userId, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 258)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 259)!; }, codec: SseCodec( decodeSuccessData: sse_decode_user_id_twin_sync, @@ -12068,7 +12117,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_basic_general_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 277, port: port_); + funcId: 278, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_general_enum_twin_normal, @@ -12099,7 +12148,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_basic_primitive_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 276, port: port_); + funcId: 277, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_primitive_enum_twin_normal, @@ -12130,7 +12179,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_basic_struct_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 278, port: port_); + funcId: 279, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_struct_twin_normal, @@ -12160,7 +12209,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 273, port: port_); + funcId: 274, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -12189,7 +12238,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 275, port: port_); + funcId: 276, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -12218,7 +12267,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 271, port: port_); + funcId: 272, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_32, @@ -12247,7 +12296,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 272, port: port_); + funcId: 273, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -12276,7 +12325,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 262, port: port_); + funcId: 263, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_16, @@ -12305,7 +12354,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 263, port: port_); + funcId: 264, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -12334,7 +12383,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 264, port: port_); + funcId: 265, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_64, @@ -12363,7 +12412,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 261, port: port_); + funcId: 262, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_8, @@ -12392,7 +12441,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 269, port: port_); + funcId: 270, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_isize, @@ -12421,7 +12470,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 274, port: port_); + funcId: 275, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -12450,7 +12499,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 266, port: port_); + funcId: 267, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_16, @@ -12479,7 +12528,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 267, port: port_); + funcId: 268, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -12508,7 +12557,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 268, port: port_); + funcId: 269, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -12537,7 +12586,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 265, port: port_); + funcId: 266, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8, @@ -12566,7 +12615,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 270, port: port_); + funcId: 271, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_usize, @@ -12596,7 +12645,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_general_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 293, port: port_); + funcId: 294, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_general_enum_twin_normal, @@ -12627,7 +12676,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_primitive_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 292, port: port_); + funcId: 293, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_primitive_enum_twin_normal, @@ -12658,7 +12707,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_struct_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 294, port: port_); + funcId: 295, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_struct_twin_normal, @@ -12689,7 +12738,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 289, port: port_); + funcId: 290, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_bool, @@ -12719,7 +12768,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 291, port: port_); + funcId: 292, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_list_prim_u_8_strict, @@ -12749,7 +12798,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 287, port: port_); + funcId: 288, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_32_strict, @@ -12779,7 +12828,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_64_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 288, port: port_); + funcId: 289, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_64_strict, @@ -12809,7 +12858,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 280, port: port_); + funcId: 281, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_16_strict, @@ -12839,7 +12888,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 281, port: port_); + funcId: 282, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_32_strict, @@ -12869,7 +12918,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 282, port: port_); + funcId: 283, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_64_strict, @@ -12899,7 +12948,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 279, port: port_); + funcId: 280, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_8_strict, @@ -12929,7 +12978,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 290, port: port_); + funcId: 291, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -12959,7 +13008,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 284, port: port_); + funcId: 285, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_16_strict, @@ -12989,7 +13038,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 285, port: port_); + funcId: 286, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_32_strict, @@ -13019,7 +13068,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 286, port: port_); + funcId: 287, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_64_strict, @@ -13049,7 +13098,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 283, port: port_); + funcId: 284, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -13079,7 +13128,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_general_enum_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 309, port: port_); + funcId: 310, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_general_enum_twin_rust_async, @@ -13110,7 +13159,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_primitive_enum_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 308, port: port_); + funcId: 309, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_primitive_enum_twin_rust_async, @@ -13141,7 +13190,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_struct_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 310, port: port_); + funcId: 311, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_struct_twin_rust_async, @@ -13172,7 +13221,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 305, port: port_); + funcId: 306, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_bool, @@ -13202,7 +13251,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 307, port: port_); + funcId: 308, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_list_prim_u_8_strict, @@ -13232,7 +13281,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 303, port: port_); + funcId: 304, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_32_strict, @@ -13262,7 +13311,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_64_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 304, port: port_); + funcId: 305, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_64_strict, @@ -13292,7 +13341,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 296, port: port_); + funcId: 297, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_16_strict, @@ -13322,7 +13371,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 297, port: port_); + funcId: 298, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_32_strict, @@ -13352,7 +13401,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 298, port: port_); + funcId: 299, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_64_strict, @@ -13382,7 +13431,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 295, port: port_); + funcId: 296, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_8_strict, @@ -13412,7 +13461,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 306, port: port_); + funcId: 307, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -13442,7 +13491,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 300, port: port_); + funcId: 301, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_16_strict, @@ -13472,7 +13521,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 301, port: port_); + funcId: 302, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_32_strict, @@ -13502,7 +13551,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 302, port: port_); + funcId: 303, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_64_strict, @@ -13532,7 +13581,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 299, port: port_); + funcId: 300, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -13561,7 +13610,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_general_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 325)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 326)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_general_enum_twin_sync, @@ -13591,7 +13640,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_primitive_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 324)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 325)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_primitive_enum_twin_sync, @@ -13621,7 +13670,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 326)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 327)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_struct_twin_sync, @@ -13651,7 +13700,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_bool(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 321)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 322)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_bool, @@ -13680,7 +13729,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_list_prim_u_8_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 323)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 324)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_list_prim_u_8_strict, @@ -13709,7 +13758,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_32_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 319)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 320)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_32_strict, @@ -13738,7 +13787,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_64_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 320)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 321)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_64_strict, @@ -13767,7 +13816,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_16_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 312)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 313)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_16_strict, @@ -13796,7 +13845,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_32_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 313)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 314)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_32_strict, @@ -13825,7 +13874,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_64_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 314)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 315)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_64_strict, @@ -13853,7 +13902,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_8_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 311)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 312)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_8_strict, @@ -13882,7 +13931,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 322)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 323)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -13911,7 +13960,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_16_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 316)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 317)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_16_strict, @@ -13940,7 +13989,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_32_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 317)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 318)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_32_strict, @@ -13969,7 +14018,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_64_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 318)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 319)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_64_strict, @@ -13997,7 +14046,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 315)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 316)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -14027,7 +14076,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_general_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 343, port: port_); + funcId: 344, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_general_enum_twin_normal, @@ -14058,7 +14107,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_primitive_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 342, port: port_); + funcId: 343, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_primitive_enum_twin_normal, @@ -14089,7 +14138,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_struct_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 344, port: port_); + funcId: 345, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_struct_twin_normal, @@ -14120,7 +14169,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 339, port: port_); + funcId: 340, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_bool, @@ -14150,7 +14199,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 341, port: port_); + funcId: 342, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_list_prim_u_8_strict, @@ -14180,7 +14229,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 337, port: port_); + funcId: 338, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_32, @@ -14210,7 +14259,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 338, port: port_); + funcId: 339, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_64, @@ -14240,7 +14289,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 328, port: port_); + funcId: 329, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_16, @@ -14270,7 +14319,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 329, port: port_); + funcId: 330, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -14300,7 +14349,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 330, port: port_); + funcId: 331, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_64, @@ -14330,7 +14379,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 327, port: port_); + funcId: 328, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_8, @@ -14360,7 +14409,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 335, port: port_); + funcId: 336, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_isize, @@ -14390,7 +14439,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 340, port: port_); + funcId: 341, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_String, @@ -14420,7 +14469,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 332, port: port_); + funcId: 333, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_16, @@ -14450,7 +14499,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 333, port: port_); + funcId: 334, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_32, @@ -14480,7 +14529,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 334, port: port_); + funcId: 335, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_64, @@ -14510,7 +14559,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 331, port: port_); + funcId: 332, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_8, @@ -14540,7 +14589,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 336, port: port_); + funcId: 337, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_usize, @@ -14571,7 +14620,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_general_enum_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 361, port: port_); + funcId: 362, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -14605,7 +14654,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Map_i_32_basic_primitive_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 360, port: port_); + funcId: 361, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -14637,7 +14686,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_struct_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 362, port: port_); + funcId: 363, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_struct_twin_rust_async, @@ -14668,7 +14717,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 357, port: port_); + funcId: 358, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_bool, @@ -14698,7 +14747,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 359, port: port_); + funcId: 360, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_list_prim_u_8_strict, @@ -14728,7 +14777,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 355, port: port_); + funcId: 356, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_32, @@ -14758,7 +14807,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 356, port: port_); + funcId: 357, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_64, @@ -14788,7 +14837,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 346, port: port_); + funcId: 347, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_16, @@ -14818,7 +14867,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 347, port: port_); + funcId: 348, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -14848,7 +14897,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 348, port: port_); + funcId: 349, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_64, @@ -14878,7 +14927,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 345, port: port_); + funcId: 346, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_8, @@ -14908,7 +14957,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 353, port: port_); + funcId: 354, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_isize, @@ -14938,7 +14987,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 358, port: port_); + funcId: 359, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_String, @@ -14968,7 +15017,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 350, port: port_); + funcId: 351, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_16, @@ -14998,7 +15047,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 351, port: port_); + funcId: 352, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_32, @@ -15028,7 +15077,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 352, port: port_); + funcId: 353, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_64, @@ -15058,7 +15107,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 349, port: port_); + funcId: 350, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_8, @@ -15088,7 +15137,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 354, port: port_); + funcId: 355, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_usize, @@ -15117,7 +15166,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_general_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 379)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 380)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_general_enum_twin_sync, @@ -15147,7 +15196,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_primitive_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 378)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 379)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_primitive_enum_twin_sync, @@ -15177,7 +15226,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 380)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 381)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_struct_twin_sync, @@ -15207,7 +15256,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_bool(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 375)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 376)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_bool, @@ -15236,7 +15285,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_list_prim_u_8_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 377)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 378)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_list_prim_u_8_strict, @@ -15265,7 +15314,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 373)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 374)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_32, @@ -15294,7 +15343,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 374)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 375)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_64, @@ -15323,7 +15372,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 364)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 365)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_16, @@ -15352,7 +15401,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 365)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 366)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -15381,7 +15430,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 366)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 367)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_64, @@ -15410,7 +15459,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 363)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 364)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_8, @@ -15439,7 +15488,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_isize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 371)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 372)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_isize, @@ -15468,7 +15517,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 376)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 377)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_String, @@ -15497,7 +15546,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 368)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 369)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_16, @@ -15526,7 +15575,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 369)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 370)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_32, @@ -15555,7 +15604,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 370)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 371)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_64, @@ -15584,7 +15633,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 367)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 368)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_8, @@ -15613,7 +15662,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_usize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 372)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 373)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_usize, @@ -15644,7 +15693,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_general_enum_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 397, port: port_); + funcId: 398, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -15677,7 +15726,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_primitive_enum_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 396, port: port_); + funcId: 397, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -15709,7 +15758,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_basic_struct_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 398, port: port_); + funcId: 399, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_basic_struct_twin_normal, @@ -15740,7 +15789,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 393, port: port_); + funcId: 394, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_bool, @@ -15770,7 +15819,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 395, port: port_); + funcId: 396, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_list_prim_u_8_strict, @@ -15800,7 +15849,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 391, port: port_); + funcId: 392, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_32, @@ -15830,7 +15879,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 392, port: port_); + funcId: 393, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -15860,7 +15909,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 382, port: port_); + funcId: 383, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_16, @@ -15890,7 +15939,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 383, port: port_); + funcId: 384, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -15920,7 +15969,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 384, port: port_); + funcId: 385, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_64, @@ -15950,7 +15999,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 381, port: port_); + funcId: 382, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_8, @@ -15980,7 +16029,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 389, port: port_); + funcId: 390, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_isize, @@ -16010,7 +16059,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 394, port: port_); + funcId: 395, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_String, @@ -16040,7 +16089,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 386, port: port_); + funcId: 387, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_16, @@ -16070,7 +16119,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 387, port: port_); + funcId: 388, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_32, @@ -16100,7 +16149,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 388, port: port_); + funcId: 389, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_64, @@ -16130,7 +16179,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 385, port: port_); + funcId: 386, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_8, @@ -16160,7 +16209,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 390, port: port_); + funcId: 391, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_usize, @@ -16191,7 +16240,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_general_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 415, port: port_); + funcId: 416, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -16224,7 +16273,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_primitive_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 414, port: port_); + funcId: 415, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -16257,7 +16306,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_struct_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 416, port: port_); + funcId: 417, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -16289,7 +16338,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 411, port: port_); + funcId: 412, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_bool, @@ -16319,7 +16368,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 413, port: port_); + funcId: 414, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_list_prim_u_8_strict, @@ -16349,7 +16398,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 409, port: port_); + funcId: 410, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_32, @@ -16379,7 +16428,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 410, port: port_); + funcId: 411, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -16409,7 +16458,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 400, port: port_); + funcId: 401, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_16, @@ -16439,7 +16488,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 401, port: port_); + funcId: 402, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -16469,7 +16518,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 402, port: port_); + funcId: 403, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_64, @@ -16499,7 +16548,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 399, port: port_); + funcId: 400, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_8, @@ -16529,7 +16578,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 407, port: port_); + funcId: 408, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_isize, @@ -16559,7 +16608,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 412, port: port_); + funcId: 413, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_String, @@ -16589,7 +16638,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 404, port: port_); + funcId: 405, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_16, @@ -16619,7 +16668,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 405, port: port_); + funcId: 406, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_32, @@ -16649,7 +16698,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 406, port: port_); + funcId: 407, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_64, @@ -16679,7 +16728,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 403, port: port_); + funcId: 404, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_8, @@ -16709,7 +16758,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 408, port: port_); + funcId: 409, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_usize, @@ -16739,7 +16788,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_basic_general_enum_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 433)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 434)!; }, codec: SseCodec( decodeSuccessData: @@ -16771,7 +16820,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_basic_primitive_enum_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 432)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 433)!; }, codec: SseCodec( decodeSuccessData: @@ -16802,7 +16851,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_basic_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 434)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 435)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_basic_struct_twin_sync, @@ -16832,7 +16881,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_bool(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 429)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 430)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_bool, @@ -16861,7 +16910,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_list_prim_u_8_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 431)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 432)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_list_prim_u_8_strict, @@ -16890,7 +16939,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 427)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 428)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_32, @@ -16919,7 +16968,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 428)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 429)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -16948,7 +16997,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 418)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 419)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_16, @@ -16977,7 +17026,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 419)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 420)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -17006,7 +17055,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 420)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 421)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_64, @@ -17035,7 +17084,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 417)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 418)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_8, @@ -17064,7 +17113,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_isize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 425)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 426)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_isize, @@ -17093,7 +17142,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 430)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 431)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_String, @@ -17122,7 +17171,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 422)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 423)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_16, @@ -17151,7 +17200,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 423)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 424)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_32, @@ -17180,7 +17229,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 424)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 425)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_64, @@ -17209,7 +17258,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 421)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 422)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_8, @@ -17238,7 +17287,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_usize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 426)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 427)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_usize, @@ -17269,7 +17318,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_basic_general_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 451, port: port_); + funcId: 452, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_general_enum_twin_rust_async, @@ -17300,7 +17349,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_basic_primitive_enum_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 450, port: port_); + funcId: 451, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_primitive_enum_twin_rust_async, @@ -17331,7 +17380,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_basic_struct_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 452, port: port_); + funcId: 453, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_struct_twin_rust_async, @@ -17362,7 +17411,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 447, port: port_); + funcId: 448, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -17392,7 +17441,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 449, port: port_); + funcId: 450, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -17422,7 +17471,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 445, port: port_); + funcId: 446, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_32, @@ -17452,7 +17501,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 446, port: port_); + funcId: 447, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -17482,7 +17531,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 436, port: port_); + funcId: 437, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_16, @@ -17512,7 +17561,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 437, port: port_); + funcId: 438, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -17542,7 +17591,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 438, port: port_); + funcId: 439, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_64, @@ -17572,7 +17621,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 435, port: port_); + funcId: 436, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_8, @@ -17602,7 +17651,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 443, port: port_); + funcId: 444, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_isize, @@ -17632,7 +17681,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 448, port: port_); + funcId: 449, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -17662,7 +17711,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 440, port: port_); + funcId: 441, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_16, @@ -17692,7 +17741,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 441, port: port_); + funcId: 442, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -17722,7 +17771,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 442, port: port_); + funcId: 443, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -17752,7 +17801,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 439, port: port_); + funcId: 440, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8, @@ -17782,7 +17831,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 444, port: port_); + funcId: 445, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_usize, @@ -17811,7 +17860,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_basic_general_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 469)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 470)!; }, codec: SseCodec( decodeSuccessData: sse_decode_basic_general_enum_twin_sync, @@ -17841,7 +17890,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_basic_primitive_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 468)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 469)!; }, codec: SseCodec( decodeSuccessData: sse_decode_basic_primitive_enum_twin_sync, @@ -17871,7 +17920,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_basic_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 470)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 471)!; }, codec: SseCodec( decodeSuccessData: sse_decode_basic_struct_twin_sync, @@ -17899,7 +17948,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 465)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 466)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -17927,7 +17976,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 467)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 468)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -17955,7 +18004,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 463)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 464)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_32, @@ -17983,7 +18032,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 464)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 465)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -18011,7 +18060,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 454)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 455)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_16, @@ -18039,7 +18088,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 455)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 456)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -18067,7 +18116,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 456)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 457)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_64, @@ -18095,7 +18144,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 453)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 454)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_8, @@ -18123,7 +18172,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_isize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 461)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 462)!; }, codec: SseCodec( decodeSuccessData: sse_decode_isize, @@ -18151,7 +18200,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 466)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 467)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -18179,7 +18228,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 458)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 459)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_16, @@ -18207,7 +18256,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 459)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 460)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -18235,7 +18284,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 460)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 461)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -18263,7 +18312,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 457)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 458)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8, @@ -18291,7 +18340,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_usize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 462)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 463)!; }, codec: SseCodec( decodeSuccessData: sse_decode_usize, @@ -18321,7 +18370,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 478, port: port_); + funcId: 479, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18351,7 +18400,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 476, port: port_); + funcId: 477, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18382,7 +18431,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_benchmark_binary_tree_twin_normal( tree, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 474, port: port_); + funcId: 475, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18412,7 +18461,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 479, port: port_); + funcId: 480, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -18442,7 +18491,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 477, port: port_); + funcId: 478, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -18472,7 +18521,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 475, port: port_); + funcId: 476, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_binary_tree_twin_normal, @@ -18501,7 +18550,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 484, port: port_); + funcId: 485, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18531,7 +18580,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 482, port: port_); + funcId: 483, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18560,7 +18609,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_benchmark_blob_twin_normal(blob, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 480, port: port_); + funcId: 481, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18590,7 +18639,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 485, port: port_); + funcId: 486, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -18620,7 +18669,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 483, port: port_); + funcId: 484, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -18650,7 +18699,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 481, port: port_); + funcId: 482, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_blob_twin_normal, @@ -18679,7 +18728,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(bytes, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 472, port: port_); + funcId: 473, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -18709,7 +18758,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 473, port: port_); + funcId: 474, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -18737,7 +18786,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 471, port: port_); + funcId: 472, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18767,7 +18816,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 493, port: port_); + funcId: 494, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18797,7 +18846,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 491, port: port_); + funcId: 492, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18828,7 +18877,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_benchmark_binary_tree_twin_rust_async( tree, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 489, port: port_); + funcId: 490, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18858,7 +18907,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 494, port: port_); + funcId: 495, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -18888,7 +18937,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 492, port: port_); + funcId: 493, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -18918,7 +18967,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 490, port: port_); + funcId: 491, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_binary_tree_twin_rust_async, @@ -18948,7 +18997,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 499, port: port_); + funcId: 500, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18978,7 +19027,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 497, port: port_); + funcId: 498, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19008,7 +19057,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_benchmark_blob_twin_rust_async(blob, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 495, port: port_); + funcId: 496, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19038,7 +19087,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 500, port: port_); + funcId: 501, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -19068,7 +19117,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 498, port: port_); + funcId: 499, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19098,7 +19147,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 496, port: port_); + funcId: 497, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_blob_twin_rust_async, @@ -19128,7 +19177,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(bytes, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 487, port: port_); + funcId: 488, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -19158,7 +19207,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 488, port: port_); + funcId: 489, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19187,7 +19236,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 486, port: port_); + funcId: 487, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19216,7 +19265,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 508)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 509)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19245,7 +19294,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 506)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 507)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19274,7 +19323,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_benchmark_binary_tree_twin_sync( tree, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 504)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 505)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19303,7 +19352,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 509)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 510)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -19332,7 +19381,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 507)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 508)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19361,7 +19410,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 505)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 506)!; }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_binary_tree_twin_sync, @@ -19389,7 +19438,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 514)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 515)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19418,7 +19467,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 512)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 513)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19446,7 +19495,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_benchmark_blob_twin_sync(blob, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 510)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 511)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19475,7 +19524,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 515)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 516)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -19504,7 +19553,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 513)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 514)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19533,7 +19582,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 511)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 512)!; }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_blob_twin_sync, @@ -19561,7 +19610,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(bytes, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 502)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 503)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -19590,7 +19639,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 503)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 504)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19617,7 +19666,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 501)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 502)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19647,7 +19696,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Local(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 517, port: port_); + funcId: 518, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Local, @@ -19677,7 +19726,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Utc(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 516, port: port_); + funcId: 517, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Utc, @@ -19707,7 +19756,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Duration(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 520, port: port_); + funcId: 521, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -19740,7 +19789,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_Chrono_Duration(durations, serializer); sse_encode_Chrono_Local(since, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 522, port: port_); + funcId: 523, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Local, @@ -19773,7 +19822,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_Chrono_Naive(timestamps, serializer); sse_encode_Chrono_Naive(epoch, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 521, port: port_); + funcId: 522, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Duration, @@ -19803,7 +19852,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feature_chrono_twin_rust_async(mine, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 525, port: port_); + funcId: 526, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -19833,7 +19882,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Naive(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 518, port: port_); + funcId: 519, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Naive, @@ -19863,7 +19912,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_Chrono_Utc(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 519, port: port_); + funcId: 520, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_Chrono_Utc, @@ -19892,7 +19941,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 523, port: port_); + funcId: 524, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_rust_async, @@ -19921,7 +19970,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 524, port: port_); + funcId: 525, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_rust_async, @@ -19949,7 +19998,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Local(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 527)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 528)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Local, @@ -19977,7 +20026,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Utc(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 526)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 527)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Utc, @@ -20005,7 +20054,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Duration(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 530)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 531)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -20036,7 +20085,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Chrono_Duration(durations, serializer); sse_encode_Chrono_Local(since, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 532)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 533)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Local, @@ -20067,7 +20116,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Chrono_Naive(timestamps, serializer); sse_encode_Chrono_Naive(epoch, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 531)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 532)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Duration, @@ -20095,7 +20144,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feature_chrono_twin_sync(mine, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 535)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 536)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -20123,7 +20172,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Naive(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 528)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 529)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Naive, @@ -20152,7 +20201,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_Chrono_Utc(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 529)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 530)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_Chrono_Utc, @@ -20179,7 +20228,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 533)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 534)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_sync, @@ -20207,7 +20256,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 534)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 535)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_sync, @@ -20236,7 +20285,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 538, port: port_); + funcId: 539, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20265,7 +20314,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 537, port: port_); + funcId: 538, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20295,7 +20344,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 536, port: port_); + funcId: 537, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20327,7 +20376,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_comments_twin_rust_async( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 540, port: port_); + funcId: 541, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20357,7 +20406,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 539, port: port_); + funcId: 540, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20386,7 +20435,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 543)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 544)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20414,7 +20463,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 542)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 543)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20443,7 +20492,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 541)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 542)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20473,7 +20522,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_comments_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 545)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 546)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20502,7 +20551,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 544)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 545)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20533,10 +20582,10 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 550, port: port_); + funcId: 551, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20566,10 +20615,11 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_unit(callback, serializer); + sse_encode_DartFn_Inputs__Output_unit_AnyhowException( + callback, serializer); sse_encode_i_32(numTimes, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 553, port: port_); + funcId: 554, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20597,9 +20647,10 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_Output_unit(callback, serializer); + sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( + callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 547, port: port_); + funcId: 548, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20620,6 +20671,40 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["callback"], ); + @override + Future + crateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnResultTwinRustAsync( + {required FutureOr Function(String) callback, + String? expectOutput, + dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + callback, serializer); + sse_encode_opt_String(expectOutput, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 555, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnResultTwinRustAsyncConstMeta, + argValues: [callback, expectOutput], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnResultTwinRustAsyncConstMeta => + const TaskConstMeta( + debugName: "rust_call_dart_return_result_twin_rust_async", + argNames: ["callback", "expectOutput"], + ); + @override Future crateApiPseudoManualDartFnTwinRustAsyncRustCallDartReturnTwinRustAsync( @@ -20627,9 +20712,10 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_String(callback, serializer); + sse_encode_DartFn_Inputs__Output_String_AnyhowException( + callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 549, port: port_); + funcId: 550, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20657,9 +20743,10 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_unit(callback, serializer); + sse_encode_DartFn_Inputs__Output_unit_AnyhowException( + callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 546, port: port_); + funcId: 547, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20690,10 +20777,10 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 548, port: port_); + funcId: 549, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20724,9 +20811,10 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(input, serializer); - sse_encode_DartFn_Inputs_DartOpaque_Output_unit(callback, serializer); + sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 551, port: port_); + funcId: 552, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20754,9 +20842,10 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartFn_Inputs__Output_DartOpaque(callback, serializer); + sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( + callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 552, port: port_); + funcId: 553, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -20786,7 +20875,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 554, port: port_); + funcId: 556, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -20816,7 +20905,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 569, port: port_); + funcId: 571, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -20846,7 +20935,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 565, port: port_); + funcId: 567, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_dart_opaque_twin_rust_async, @@ -20877,7 +20966,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartOpaque(opaque1, serializer); sse_encode_DartOpaque(opaque2, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 563, port: port_); + funcId: 565, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_dart_opaque_nested_twin_rust_async, @@ -20907,7 +20996,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 568, port: port_); + funcId: 570, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20938,7 +21027,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_dart_opaque_twin_rust_async( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 566, port: port_); + funcId: 568, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20969,7 +21058,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_dart_opaque_nested_twin_rust_async( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 564, port: port_); + funcId: 566, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20999,7 +21088,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque_array_1(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 560, port: port_); + funcId: 562, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21029,7 +21118,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 557, port: port_); + funcId: 559, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque_array_1, @@ -21059,7 +21148,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 559, port: port_); + funcId: 561, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21089,7 +21178,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 556, port: port_); + funcId: 558, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -21119,7 +21208,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 555, port: port_); + funcId: 557, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -21149,7 +21238,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 561, port: port_); + funcId: 563, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21179,7 +21268,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 558, port: port_); + funcId: 560, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -21209,7 +21298,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 562, port: port_); + funcId: 564, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21240,7 +21329,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(id, serializer); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 567, port: port_); + funcId: 569, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21268,7 +21357,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 570)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 572)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -21296,7 +21385,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 585)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 587)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -21325,7 +21414,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 581)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 583)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_dart_opaque_twin_sync, @@ -21355,7 +21444,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque1, serializer); sse_encode_DartOpaque(opaque2, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 579)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 581)!; }, codec: SseCodec( decodeSuccessData: sse_decode_dart_opaque_nested_twin_sync, @@ -21383,7 +21472,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 584)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 586)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21411,7 +21500,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_dart_opaque_twin_sync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 582)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 584)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21439,7 +21528,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_dart_opaque_nested_twin_sync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 580)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 582)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21467,7 +21556,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque_array_1(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 576)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 578)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21495,7 +21584,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 573)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 575)!; }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque_array_1, @@ -21523,7 +21612,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 575)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 577)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21551,7 +21640,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 572)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 574)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -21579,7 +21668,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 571)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 573)!; }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -21607,7 +21696,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 577)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 579)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21635,7 +21724,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 574)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 576)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -21663,7 +21752,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 578)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 580)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21692,7 +21781,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(id, serializer); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 583)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 585)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21725,7 +21814,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_StreamSink_i_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 588, port: port_); + funcId: 590, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21755,7 +21844,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 589, port: port_); + funcId: 591, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -21784,7 +21873,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 586, port: port_); + funcId: 588, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -21816,7 +21905,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDroppableTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 587, port: port_); + funcId: 589, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21848,7 +21937,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDroppableTwinSync( that, serializer); sse_encode_StreamSink_i_32_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 592)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 594)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21876,7 +21965,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 593)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 595)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -21904,7 +21993,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 590)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 592)!; }, codec: SseCodec( decodeSuccessData: @@ -21935,7 +22024,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDroppableTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 591)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 593)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21965,7 +22054,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_simple_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 594, port: port_); + funcId: 596, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_simple_twin_rust_async, @@ -21995,7 +22084,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_with_discriminant_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 598, port: port_); + funcId: 600, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_discriminant_twin_rust_async, @@ -22026,7 +22115,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_mixed_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 595, port: port_); + funcId: 597, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_mixed_twin_rust_async, @@ -22057,7 +22146,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_struct_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 597, port: port_); + funcId: 599, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_struct_twin_rust_async, @@ -22088,7 +22177,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_tuple_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 596, port: port_); + funcId: 598, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_tuple_twin_rust_async, @@ -22118,7 +22207,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_weekdays_twin_rust_async(weekday, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 601, port: port_); + funcId: 603, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_weekdays_twin_rust_async, @@ -22148,7 +22237,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_kitchen_sink_twin_rust_async(val, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 603, port: port_); + funcId: 605, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_kitchen_sink_twin_rust_async, @@ -22178,7 +22267,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 600, port: port_); + funcId: 602, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_weekdays_twin_rust_async, @@ -22208,7 +22297,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_measure_twin_rust_async(measure, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 602, port: port_); + funcId: 604, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_measure_twin_rust_async, @@ -22238,7 +22327,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_note_twin_rust_async(note, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 599, port: port_); + funcId: 601, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -22267,7 +22356,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_simple_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 604)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 606)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_simple_twin_sync, @@ -22296,7 +22385,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_with_discriminant_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 608)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 610)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_discriminant_twin_sync, @@ -22325,7 +22414,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_with_item_mixed_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 605)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 607)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_mixed_twin_sync, @@ -22354,7 +22443,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_with_item_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 607)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 609)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_struct_twin_sync, @@ -22383,7 +22472,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_with_item_tuple_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 606)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 608)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_tuple_twin_sync, @@ -22412,7 +22501,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_weekdays_twin_sync(weekday, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 611)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 613)!; }, codec: SseCodec( decodeSuccessData: sse_decode_weekdays_twin_sync, @@ -22441,7 +22530,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_kitchen_sink_twin_sync(val, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 613)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 615)!; }, codec: SseCodec( decodeSuccessData: sse_decode_kitchen_sink_twin_sync, @@ -22470,7 +22559,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 610)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 612)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_weekdays_twin_sync, @@ -22498,7 +22587,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_measure_twin_sync(measure, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 612)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 614)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_measure_twin_sync, @@ -22526,7 +22615,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_note_twin_sync(note, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 609)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 611)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -22555,7 +22644,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 615, port: port_); + funcId: 617, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22586,7 +22675,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(address, serializer); sse_encode_String(payload, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 616, port: port_); + funcId: 618, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22616,7 +22705,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_event_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 617, port: port_); + funcId: 619, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -22647,7 +22736,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_event_twin_rust_async_Sse(listener, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 614, port: port_); + funcId: 616, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22677,7 +22766,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 622, port: port_); + funcId: 624, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22706,7 +22795,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 623, port: port_); + funcId: 625, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -22736,7 +22825,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 621, port: port_); + funcId: 623, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -22767,7 +22856,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_custom_nested_error_outer_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 624, port: port_); + funcId: 626, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22798,7 +22887,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_custom_struct_error_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 625, port: port_); + funcId: 627, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22828,7 +22917,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(message, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 642, port: port_); + funcId: 644, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_custom_struct_twin_rust_async, @@ -22858,7 +22947,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 645, port: port_); + funcId: 647, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22889,7 +22978,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 646, port: port_); + funcId: 648, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -22919,7 +23008,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 643, port: port_); + funcId: 645, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22949,7 +23038,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 644, port: port_); + funcId: 646, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -22979,7 +23068,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 618, port: port_); + funcId: 620, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23008,7 +23097,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 619, port: port_); + funcId: 621, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23037,7 +23126,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 620, port: port_); + funcId: 622, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23066,7 +23155,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 635, port: port_); + funcId: 637, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23095,7 +23184,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 629, port: port_); + funcId: 631, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23124,7 +23213,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 630, port: port_); + funcId: 632, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23153,7 +23242,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 631, port: port_); + funcId: 633, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23182,7 +23271,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 632, port: port_); + funcId: 634, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23211,7 +23300,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 633, port: port_); + funcId: 635, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23240,7 +23329,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 626, port: port_); + funcId: 628, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23270,7 +23359,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(variant, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 628, port: port_); + funcId: 630, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23299,7 +23388,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 627, port: port_); + funcId: 629, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23329,7 +23418,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 637, port: port_); + funcId: 639, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_some_struct_twin_rust_async, @@ -23359,7 +23448,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_some_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 640, port: port_); + funcId: 642, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23390,7 +23479,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_some_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 641, port: port_); + funcId: 643, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23420,7 +23509,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 638, port: port_); + funcId: 640, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23450,7 +23539,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 639, port: port_); + funcId: 641, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23482,7 +23571,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 636, port: port_); + funcId: 638, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23512,7 +23601,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 634, port: port_); + funcId: 636, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23539,7 +23628,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 651)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 653)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23566,7 +23655,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 652)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 654)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23594,7 +23683,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 650)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 652)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23624,7 +23713,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_nested_error_outer_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 653)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 655)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23653,7 +23742,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_error_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 654)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 656)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23682,7 +23771,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(message, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 671)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 673)!; }, codec: SseCodec( decodeSuccessData: sse_decode_custom_struct_twin_sync, @@ -23711,7 +23800,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 674)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 676)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23740,7 +23829,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 675)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 677)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23769,7 +23858,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 672)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 674)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23797,7 +23886,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 673)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 675)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23825,7 +23914,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 647)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 649)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23852,7 +23941,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 648)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 650)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23879,7 +23968,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 649)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 651)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23906,7 +23995,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 664)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 666)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23933,7 +24022,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 658)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 660)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23961,7 +24050,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 659)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 661)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23988,7 +24077,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 660)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 662)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24015,7 +24104,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 661)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 663)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24042,7 +24131,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 662)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 664)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24069,7 +24158,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 655)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 657)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24097,7 +24186,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(variant, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 657)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 659)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24124,7 +24213,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 656)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 658)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24153,7 +24242,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(value, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 666)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 668)!; }, codec: SseCodec( decodeSuccessData: sse_decode_some_struct_twin_sync, @@ -24181,7 +24270,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_some_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 669)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 671)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24210,7 +24299,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_some_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 670)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 672)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24238,7 +24327,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 667)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 669)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24266,7 +24355,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 668)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 670)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24297,7 +24386,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 665)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 667)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24325,7 +24414,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 663)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 665)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24354,7 +24443,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 679, port: port_); + funcId: 681, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_new_simple_struct, @@ -24383,7 +24472,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 678, port: port_); + funcId: 680, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_old_simple_struct, @@ -24413,7 +24502,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_my_enum(myEnum, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 677, port: port_); + funcId: 679, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -24443,7 +24532,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_struct(myStruct, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 676, port: port_); + funcId: 678, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -24471,7 +24560,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 683)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 685)!; }, codec: SseCodec( decodeSuccessData: sse_decode_new_simple_struct, @@ -24499,7 +24588,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 682)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 684)!; }, codec: SseCodec( decodeSuccessData: sse_decode_old_simple_struct, @@ -24527,7 +24616,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_my_enum(myEnum, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 681)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 683)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -24555,7 +24644,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_struct(myStruct, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 680)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 682)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -24585,7 +24674,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 684, port: port_); + funcId: 686, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -24615,7 +24704,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 688, port: port_); + funcId: 690, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_list_prim_u_8_strict, @@ -24645,7 +24734,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_kitchen_sink_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 691, port: port_); + funcId: 693, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_kitchen_sink_twin_rust_async, @@ -24675,7 +24764,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_enum_simple_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 690, port: port_); + funcId: 692, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_enum_simple_twin_rust_async, @@ -24705,7 +24794,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 686, port: port_); + funcId: 688, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_String, @@ -24735,7 +24824,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_my_size(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 689, port: port_); + funcId: 691, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_my_size, @@ -24765,7 +24854,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 685, port: port_); + funcId: 687, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Set_i_32, @@ -24795,7 +24884,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 687, port: port_); + funcId: 689, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Set_String, @@ -24823,7 +24912,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 692)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 694)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -24852,7 +24941,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_list_prim_u_8_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 696)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 698)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_list_prim_u_8_strict, @@ -24881,7 +24970,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_kitchen_sink_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 699)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 701)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_kitchen_sink_twin_sync, @@ -24910,7 +24999,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_enum_simple_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 698)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 700)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_enum_simple_twin_sync, @@ -24939,7 +25028,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 694)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 696)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_String, @@ -24968,7 +25057,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_my_size(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 697)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 699)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_my_size, @@ -24996,7 +25085,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 693)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 695)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Set_i_32, @@ -25024,7 +25113,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 695)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 697)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Set_String, @@ -25053,7 +25142,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 721, port: port_); + funcId: 723, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -25085,7 +25174,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(a, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 704, port: port_); + funcId: 706, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25120,7 +25209,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 703, port: port_); + funcId: 705, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25152,7 +25241,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_u_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 709, port: port_); + funcId: 711, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25187,7 +25276,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_2_twin_rust_async_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 708, port: port_); + funcId: 710, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25222,7 +25311,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_StreamSink_u_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 707, port: port_); + funcId: 709, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25262,7 +25351,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_2_twin_rust_async_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 706, port: port_); + funcId: 708, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25294,7 +25383,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(a, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 702, port: port_); + funcId: 704, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_concatenate_with_twin_rust_async, @@ -25325,7 +25414,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_concatenate_with_twin_rust_async( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 705, port: port_); + funcId: 707, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25358,7 +25447,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(b, serializer); sse_encode_u_32(c, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 701, port: port_); + funcId: 703, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_rust_async_array_3, @@ -25387,7 +25476,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 700, port: port_); + funcId: 702, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_rust_async, @@ -25420,7 +25509,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_callable_twin_rust_async(that, serializer); sse_encode_String(two, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 711, port: port_); + funcId: 713, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25450,7 +25539,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 717, port: port_); + funcId: 719, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_enum_twin_rust_async, @@ -25481,7 +25570,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_enum_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 718, port: port_); + funcId: 720, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25512,7 +25601,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_simple_primitive_enum_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 719, port: port_); + funcId: 721, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -25546,7 +25635,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_simple_struct_twin_rust_async(a, serializer); sse_encode_box_autoadd_simple_struct_twin_rust_async(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 715, port: port_); + funcId: 717, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25576,7 +25665,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 713, port: port_); + funcId: 715, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25607,7 +25696,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 714, port: port_); + funcId: 716, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25638,7 +25727,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 712, port: port_); + funcId: 714, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_twin_rust_async, @@ -25669,7 +25758,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_simple_struct_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 716, port: port_); + funcId: 718, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -25699,7 +25788,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(a, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 720, port: port_); + funcId: 722, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -25735,7 +25824,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(y, serializer); sse_encode_u_32(z, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 710, port: port_); + funcId: 712, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25762,7 +25851,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 743)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 745)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -25792,7 +25881,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(a, serializer); sse_encode_String(b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 726)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 728)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25825,7 +25914,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_concatenate_with_twin_sync(that, serializer); sse_encode_String(b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 725)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 727)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25855,7 +25944,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_u_32_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 731)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 733)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25889,7 +25978,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(key, serializer); sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_2_twin_sync_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 730)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 732)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25922,7 +26011,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_concatenate_with_twin_sync(that, serializer); sse_encode_StreamSink_u_32_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 729)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 731)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25960,7 +26049,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(key, serializer); sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_2_twin_sync_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 728)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 730)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25991,7 +26080,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(a, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 724)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 726)!; }, codec: SseCodec( decodeSuccessData: sse_decode_concatenate_with_twin_sync, @@ -26020,7 +26109,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_concatenate_with_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 727)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 729)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26050,7 +26139,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(a, serializer); sse_encode_u_32(b, serializer); sse_encode_u_32(c, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 723)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 725)!; }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_sync_array_3, @@ -26077,7 +26166,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 722)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 724)!; }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_sync, @@ -26106,7 +26195,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_callable_twin_sync(that, serializer); sse_encode_String(two, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 733)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 735)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26135,7 +26224,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 739)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 741)!; }, codec: SseCodec( decodeSuccessData: sse_decode_simple_enum_twin_sync, @@ -26164,7 +26253,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_enum_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 740)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 742)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26192,7 +26281,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_simple_primitive_enum_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 741)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 743)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -26224,7 +26313,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_sync(a, serializer); sse_encode_box_autoadd_simple_struct_twin_sync(b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 737)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 739)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26253,7 +26342,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 735)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 737)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26282,7 +26371,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 736)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 738)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26311,7 +26400,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 734)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 736)!; }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_twin_sync, @@ -26340,7 +26429,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_simple_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 738)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 740)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -26368,7 +26457,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(a, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 742)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 744)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -26401,7 +26490,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_sum_with_twin_sync(that, serializer); sse_encode_u_32(y, serializer); sse_encode_u_32(z, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 732)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 734)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -26432,7 +26521,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_settings_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 747, port: port_); + funcId: 749, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26464,7 +26553,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_settings_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 748, port: port_); + funcId: 750, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26494,7 +26583,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_numbers(nums, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 754, port: port_); + funcId: 756, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -26524,7 +26613,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_sequences(seqs, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 755, port: port_); + funcId: 757, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -26553,7 +26642,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 744, port: port_); + funcId: 746, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -26582,7 +26671,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 745, port: port_); + funcId: 747, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -26611,7 +26700,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 751, port: port_); + funcId: 753, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_message, @@ -26641,7 +26730,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_application_settings(appSettings, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 746, port: port_); + funcId: 748, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -26672,7 +26761,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_array_2_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 769, port: port_); + funcId: 771, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26704,7 +26793,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 764, port: port_); + funcId: 766, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26736,7 +26825,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Map_u_8_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 767, port: port_); + funcId: 769, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26769,7 +26858,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_opt_box_autoadd_application_mode_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 765, port: port_); + funcId: 767, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26801,7 +26890,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Set_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 768, port: port_); + funcId: 770, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26834,7 +26923,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_mirror_struct_twin_rust_async_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 749, port: port_); + funcId: 751, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26867,7 +26956,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_record_application_settings_raw_string_enum_mirrored_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 750, port: port_); + funcId: 752, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26899,7 +26988,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 766, port: port_); + funcId: 768, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26931,7 +27020,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(num, serializer); sse_encode_usize(times, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 752, port: port_); + funcId: 754, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_numbers, @@ -26962,7 +27051,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(seq, serializer); sse_encode_usize(times, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 753, port: port_); + funcId: 755, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sequences, @@ -26991,7 +27080,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 762, port: port_); + funcId: 764, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -27021,7 +27110,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 760, port: port_); + funcId: 762, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_mirrored, @@ -27050,7 +27139,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 763, port: port_); + funcId: 765, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_hash_map, @@ -27079,7 +27168,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 761, port: port_); + funcId: 763, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_enum_mirrored, @@ -27108,7 +27197,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 759, port: port_); + funcId: 761, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_of_nested_raw_string_mirrored, @@ -27138,7 +27227,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 757, port: port_); + funcId: 759, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_nested_raw_string_mirrored, @@ -27168,7 +27257,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(nested, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 758, port: port_); + funcId: 760, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_enum_mirrored, @@ -27197,7 +27286,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 756, port: port_); + funcId: 758, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_mirrored, @@ -27227,7 +27316,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_settings_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 773)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 775)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27258,7 +27347,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_settings_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 774)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 776)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27287,7 +27376,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_numbers(nums, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 780)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 782)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -27315,7 +27404,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_sequences(seqs, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 781)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 783)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -27342,7 +27431,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 770)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 772)!; }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -27370,7 +27459,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 771)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 773)!; }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -27397,7 +27486,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 777)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 779)!; }, codec: SseCodec( decodeSuccessData: sse_decode_application_message, @@ -27424,7 +27513,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_application_settings(appSettings, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 772)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 774)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -27454,7 +27543,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_array_2_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 795)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 797)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27485,7 +27574,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 790)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 792)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27516,7 +27605,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Map_u_8_application_mode_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 793)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 795)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27548,7 +27637,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_opt_box_autoadd_application_mode_Sse( sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 791)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 793)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27579,7 +27668,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Set_application_mode_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 794)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 796)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27610,7 +27699,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_mirror_struct_twin_sync_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 775)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 777)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27642,7 +27731,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_record_application_settings_raw_string_enum_mirrored_Sse( sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 776)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 778)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27673,7 +27762,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_mode_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 792)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 794)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27703,7 +27792,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(num, serializer); sse_encode_usize(times, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 778)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 780)!; }, codec: SseCodec( decodeSuccessData: sse_decode_numbers, @@ -27732,7 +27821,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(seq, serializer); sse_encode_usize(times, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 779)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 781)!; }, codec: SseCodec( decodeSuccessData: sse_decode_sequences, @@ -27760,7 +27849,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 788)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 790)!; }, codec: SseCodec( decodeSuccessData: sse_decode_contains_mirrored_sub_struct_twin_sync, @@ -27788,7 +27877,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 786)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 788)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_mirrored, @@ -27816,7 +27905,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 789)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 791)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_hash_map, @@ -27844,7 +27933,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 787)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 789)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_enum_mirrored, @@ -27872,7 +27961,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 785)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 787)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_of_nested_raw_string_mirrored, @@ -27900,7 +27989,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 783)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 785)!; }, codec: SseCodec( decodeSuccessData: sse_decode_nested_raw_string_mirrored, @@ -27929,7 +28018,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(nested, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 784)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 786)!; }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_enum_mirrored, @@ -27957,7 +28046,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 782)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 784)!; }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_mirrored, @@ -27986,7 +28075,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 799, port: port_); + funcId: 801, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_big_buffers_twin_rust_async, @@ -28016,7 +28105,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_tree_node_twin_rust_async(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 796, port: port_); + funcId: 798, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_tree_node_twin_rust_async, @@ -28046,7 +28135,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_nested_struct_twin_rust_async(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 798, port: port_); + funcId: 800, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_nested_struct_twin_rust_async, @@ -28076,7 +28165,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 802, port: port_); + funcId: 804, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -28107,7 +28196,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_size(arg, serializer); sse_encode_box_my_size(boxed, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 804, port: port_); + funcId: 806, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_size, @@ -28137,7 +28226,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(v, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 803, port: port_); + funcId: 805, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -28167,7 +28256,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_weekdays_twin_rust_async(weekdays, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 797, port: port_); + funcId: 799, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_weekdays_twin_rust_async, @@ -28197,7 +28286,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_abc_twin_rust_async(abc, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 800, port: port_); + funcId: 802, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_abc_twin_rust_async, @@ -28227,7 +28316,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_enum_twin_rust_async(se, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 801, port: port_); + funcId: 803, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_enum_twin_rust_async, @@ -28255,7 +28344,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 808)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 810)!; }, codec: SseCodec( decodeSuccessData: sse_decode_big_buffers_twin_sync, @@ -28284,7 +28373,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_tree_node_twin_sync(s, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 805)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 807)!; }, codec: SseCodec( decodeSuccessData: sse_decode_my_tree_node_twin_sync, @@ -28313,7 +28402,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_nested_struct_twin_sync(s, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 807)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 809)!; }, codec: SseCodec( decodeSuccessData: sse_decode_my_nested_struct_twin_sync, @@ -28341,7 +28430,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(s, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 811)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 813)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -28370,7 +28459,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_size(arg, serializer); sse_encode_box_my_size(boxed, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 813)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 815)!; }, codec: SseCodec( decodeSuccessData: sse_decode_my_size, @@ -28398,7 +28487,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(v, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 812)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 814)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -28427,7 +28516,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_weekdays_twin_sync(weekdays, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 806)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 808)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_weekdays_twin_sync, @@ -28455,7 +28544,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_abc_twin_sync(abc, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 809)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 811)!; }, codec: SseCodec( decodeSuccessData: sse_decode_abc_twin_sync, @@ -28484,7 +28573,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_enum_twin_sync(se, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 810)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 812)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_enum_twin_sync, @@ -28514,7 +28603,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_empty_twin_rust_async(empty, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 817, port: port_); + funcId: 819, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_empty_twin_rust_async, @@ -28543,7 +28632,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 814, port: port_); + funcId: 816, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28573,7 +28662,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_my_size(l, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 815, port: port_); + funcId: 817, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_my_size, @@ -28603,7 +28692,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(names, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 816, port: port_); + funcId: 818, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -28631,7 +28720,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_empty_twin_sync(empty, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 821)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 823)!; }, codec: SseCodec( decodeSuccessData: sse_decode_empty_twin_sync, @@ -28658,7 +28747,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 818)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 820)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28686,7 +28775,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_my_size(l, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 819)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 821)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_my_size, @@ -28714,7 +28803,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(names, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 820)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 822)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -28744,7 +28833,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_new_type_int_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 822, port: port_); + funcId: 824, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_new_type_int_twin_rust_async, @@ -28773,7 +28862,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_new_type_int_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 823)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 825)!; }, codec: SseCodec( decodeSuccessData: sse_decode_new_type_int_twin_sync, @@ -28806,7 +28895,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_f_64(myF64, serializer); sse_encode_opt_box_autoadd_bool(myBool, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 824, port: port_); + funcId: 826, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -28838,7 +28927,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_i_64(myI64, serializer); sse_encode_opt_box_autoadd_f_64(myF64, serializer); sse_encode_opt_box_autoadd_bool(myBool, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 825)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 827)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -28868,7 +28957,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_f_64(opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 829, port: port_); + funcId: 831, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -28912,7 +29001,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_exotic_optionals_twin_rust_async( structbox, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 831, port: port_); + funcId: 833, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -28951,7 +29040,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_exotic_optionals_twin_rust_async( opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 828, port: port_); + funcId: 830, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -28983,7 +29072,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(left, serializer); sse_encode_f_64(right, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 826, port: port_); + funcId: 828, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -29013,7 +29102,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(document, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 827, port: port_); + funcId: 829, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_element_twin_rust_async, @@ -29043,7 +29132,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_opt_vecs_twin_rust_async(opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 830, port: port_); + funcId: 832, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_vecs_twin_rust_async, @@ -29072,7 +29161,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_f_64(opt, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 835)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 837)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -29113,7 +29202,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_f_64(f64Box, serializer); sse_encode_opt_box_bool(boolbox, serializer); sse_encode_opt_box_exotic_optionals_twin_sync(structbox, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 837)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 839)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29150,7 +29239,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_exotic_optionals_twin_sync(opt, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 834)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 836)!; }, codec: SseCodec( decodeSuccessData: @@ -29180,7 +29269,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64(left, serializer); sse_encode_f_64(right, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 832)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 834)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -29209,7 +29298,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(document, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 833)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 835)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_element_twin_sync, @@ -29237,7 +29326,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_opt_vecs_twin_sync(opt, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 836)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 838)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_vecs_twin_sync, @@ -29266,7 +29355,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 840, port: port_); + funcId: 842, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -29296,7 +29385,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 839, port: port_); + funcId: 841, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29326,7 +29415,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 838, port: port_); + funcId: 840, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29357,7 +29446,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_simple_struct_for_borrow_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 841, port: port_); + funcId: 843, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_for_borrow_twin_rust_async, @@ -29385,7 +29474,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 844)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 846)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -29413,7 +29502,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 843)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 845)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29441,7 +29530,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 842)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 844)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29471,7 +29560,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_for_borrow_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 845)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 847)!; }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_for_borrow_twin_sync, @@ -29501,7 +29590,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(n, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 846, port: port_); + funcId: 848, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_vec_of_primitive_pack_twin_rust_async, @@ -29530,7 +29619,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(n, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 847)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 849)!; }, codec: SseCodec( decodeSuccessData: sse_decode_vec_of_primitive_pack_twin_sync, @@ -29567,7 +29656,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(myF64, serializer); sse_encode_bool(myBool, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 848, port: port_); + funcId: 850, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -29597,7 +29686,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(myU32, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 849, port: port_); + funcId: 851, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -29632,7 +29721,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_64(myI64, serializer); sse_encode_f_64(myF64, serializer); sse_encode_bool(myBool, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 850)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 852)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -29660,7 +29749,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(myU32, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 851)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 853)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -29689,7 +29778,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 853, port: port_); + funcId: 855, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -29720,7 +29809,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 852, port: port_); + funcId: 854, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_item_struct_twin_rust_async, @@ -29748,7 +29837,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 855)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 857)!; }, codec: SseCodec( decodeSuccessData: @@ -29777,7 +29866,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 854)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 856)!; }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_item_struct_twin_sync, @@ -29808,7 +29897,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 899, port: port_); + funcId: 901, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29840,7 +29929,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 900, port: port_); + funcId: 902, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29872,7 +29961,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 898, port: port_); + funcId: 900, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29904,7 +29993,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 902, port: port_); + funcId: 904, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -29936,7 +30025,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 901, port: port_); + funcId: 903, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -29967,7 +30056,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 896, port: port_); + funcId: 898, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -29998,7 +30087,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 895, port: port_); + funcId: 897, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30028,7 +30117,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 897, port: port_); + funcId: 899, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30061,7 +30150,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 892, port: port_); + funcId: 894, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30093,7 +30182,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 893, port: port_); + funcId: 895, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30125,7 +30214,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 891, port: port_); + funcId: 893, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30155,7 +30244,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 894, port: port_); + funcId: 896, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30191,7 +30280,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 857, port: port_); + funcId: 859, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30227,7 +30316,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(expect, serializer); sse_encode_i_32(adder, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 858, port: port_); + funcId: 860, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30258,7 +30347,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 860, port: port_); + funcId: 862, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30294,7 +30383,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 856, port: port_); + funcId: 858, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30328,7 +30417,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_list_prim_i_32_loose(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 881, port: port_); + funcId: 883, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30363,7 +30452,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 890, port: port_); + funcId: 892, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -30398,7 +30487,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( mutBorrow, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 889, port: port_); + funcId: 891, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -30429,7 +30518,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynFnStringStringSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 865, port: port_); + funcId: 867, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30458,7 +30547,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 866, port: port_); + funcId: 868, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30494,7 +30583,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerEnumWithGoodAndOpaqueWithoutOptionTwinRustAsync( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 877, port: port_); + funcId: 879, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30525,7 +30614,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleEnumTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 878, port: port_); + funcId: 880, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30554,7 +30643,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 879, port: port_); + funcId: 881, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30586,7 +30675,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_good_and_opaque_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 874, port: port_); + funcId: 876, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30616,7 +30705,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 875, port: port_); + funcId: 877, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_rust_async, @@ -30646,7 +30735,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 876, port: port_); + funcId: 878, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_rust_async, @@ -30681,7 +30770,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 883, port: port_); + funcId: 885, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30711,7 +30800,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 885, port: port_); + funcId: 887, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30744,7 +30833,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 884, port: port_); + funcId: 886, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30778,7 +30867,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 862, port: port_); + funcId: 864, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30809,7 +30898,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynMyTraitTwinRustAsyncSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 863, port: port_); + funcId: 865, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30838,7 +30927,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 864, port: port_); + funcId: 866, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30868,7 +30957,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 887, port: port_); + funcId: 889, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30899,7 +30988,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 888, port: port_); + funcId: 890, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30930,7 +31019,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 859, port: port_); + funcId: 861, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30960,7 +31049,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 882, port: port_); + funcId: 884, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30996,7 +31085,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( orange, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 886, port: port_); + funcId: 888, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -31028,7 +31117,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 880, port: port_); + funcId: 882, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31061,7 +31150,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 872, port: port_); + funcId: 874, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31091,7 +31180,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 873, port: port_); + funcId: 875, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31127,7 +31216,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 868, port: port_); + funcId: 870, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31162,7 +31251,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 869, port: port_); + funcId: 871, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31197,7 +31286,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 867, port: port_); + funcId: 869, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31226,7 +31315,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 870, port: port_); + funcId: 872, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31257,7 +31346,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 871, port: port_); + funcId: 873, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31294,7 +31383,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 861, port: port_); + funcId: 863, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31324,7 +31413,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 946)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 948)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31355,7 +31444,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 947)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 949)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31386,7 +31475,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 945)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 947)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31416,7 +31505,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 949)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 951)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -31447,7 +31536,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 948)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 950)!; }, codec: SseCodec( decodeSuccessData: @@ -31477,7 +31566,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 943)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 945)!; }, codec: SseCodec( decodeSuccessData: @@ -31506,7 +31595,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 942)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 944)!; }, codec: SseCodec( decodeSuccessData: @@ -31535,7 +31624,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 944)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 946)!; }, codec: SseCodec( decodeSuccessData: @@ -31566,7 +31655,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 939)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 941)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31597,7 +31686,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 940)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 942)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31628,7 +31717,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 938)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 940)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31656,7 +31745,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 941)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 943)!; }, codec: SseCodec( decodeSuccessData: @@ -31691,7 +31780,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); sse_encode_i_32(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 904)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 906)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31726,7 +31815,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); sse_encode_i_32(adder, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 905)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 907)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31756,7 +31845,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 907)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 909)!; }, codec: SseCodec( decodeSuccessData: @@ -31789,7 +31878,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); sse_encode_i_32(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 903)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 905)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31822,7 +31911,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); sse_encode_list_prim_i_32_loose(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 928)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 930)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31855,7 +31944,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 937)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 939)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -31888,7 +31977,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { borrow, serializer); sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( mutBorrow, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 936)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 938)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -31918,7 +32007,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynFnStringStringSendSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 912)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 914)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31946,7 +32035,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 913)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 915)!; }, codec: SseCodec( decodeSuccessData: @@ -31980,7 +32069,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerEnumWithGoodAndOpaqueWithoutOptionTwinSync( b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 924)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 926)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32010,7 +32099,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleEnumTwinSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 925)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 927)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32038,7 +32127,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 926)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 928)!; }, codec: SseCodec( decodeSuccessData: @@ -32069,7 +32158,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_with_good_and_opaque_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 921)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 923)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32098,7 +32187,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 922)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 924)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_sync, @@ -32127,7 +32216,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 923)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 925)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_sync, @@ -32161,7 +32250,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); sse_encode_i_32(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 930)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 932)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32190,7 +32279,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 932)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 934)!; }, codec: SseCodec( decodeSuccessData: @@ -32222,7 +32311,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 931)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 933)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32255,7 +32344,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( a, serializer); sse_encode_String(b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 909)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 911)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32285,7 +32374,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynMyTraitTwinSyncSendSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 910)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 912)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32313,7 +32402,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 911)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 913)!; }, codec: SseCodec( decodeSuccessData: @@ -32344,7 +32433,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 934)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 936)!; }, codec: SseCodec( decodeSuccessData: @@ -32373,7 +32462,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 935)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 937)!; }, codec: SseCodec( decodeSuccessData: @@ -32403,7 +32492,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 906)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 908)!; }, codec: SseCodec( decodeSuccessData: @@ -32432,7 +32521,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 929)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 931)!; }, codec: SseCodec( decodeSuccessData: @@ -32466,7 +32555,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { apple, serializer); sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( orange, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 933)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 935)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -32497,7 +32586,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync_Sse( sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 927)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 929)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32528,7 +32617,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 919)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 921)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32557,7 +32646,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 920)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 922)!; }, codec: SseCodec( decodeSuccessData: @@ -32592,7 +32681,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynHelloTraitTwinSync( arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 915)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 917)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32625,7 +32714,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynHelloTraitTwinSync( arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 916)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 918)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32658,7 +32747,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynHelloTraitTwinSync( arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 914)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 916)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32686,7 +32775,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 917)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 919)!; }, codec: SseCodec( decodeSuccessData: @@ -32715,7 +32804,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 918)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 920)!; }, codec: SseCodec( decodeSuccessData: @@ -32749,7 +32838,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 908)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 910)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32778,7 +32867,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 952, port: port_); + funcId: 954, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_opaque_twin_rust_async_array_5, @@ -32807,7 +32896,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 961, port: port_); + funcId: 963, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opaque_nested_twin_rust_async, @@ -32836,7 +32925,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 950, port: port_); + funcId: 952, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinRustAsync, @@ -32867,7 +32956,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_RustOpaque_HideDataTwinRustAsync( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 951, port: port_); + funcId: 953, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32897,7 +32986,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 964, port: port_); + funcId: 966, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueReturnTwinRustAsync, @@ -32927,7 +33016,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync_array_2(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 958, port: port_); + funcId: 960, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32956,7 +33045,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 956, port: port_); + funcId: 958, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinRustAsync_array_2, @@ -32986,7 +33075,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_RustOpaque_HideDataTwinRustAsync(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 960, port: port_); + funcId: 962, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33015,7 +33104,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 959, port: port_); + funcId: 961, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_RustOpaque_HideDataTwinRustAsync, @@ -33045,7 +33134,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_opaque_twin_rust_async(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 953, port: port_); + funcId: 955, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33076,7 +33165,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_opaque_nested_twin_rust_async( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 962, port: port_); + funcId: 964, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33106,7 +33195,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_NonCloneDataTwinRustAsync(clone, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 957, port: port_); + funcId: 959, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33136,7 +33225,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 954, port: port_); + funcId: 956, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33166,7 +33255,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 955, port: port_); + funcId: 957, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33196,7 +33285,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 963, port: port_); + funcId: 965, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33224,7 +33313,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 967)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 969)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_opaque_twin_sync_array_5, @@ -33252,7 +33341,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 976)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 978)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opaque_nested_twin_sync, @@ -33279,7 +33368,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 965)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 967)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinSync, @@ -33309,7 +33398,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_RustOpaque_HideDataTwinSync( opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 966)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 968)!; }, codec: SseCodec( decodeSuccessData: @@ -33338,7 +33427,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 979)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 981)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueReturnTwinSync, @@ -33366,7 +33455,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinSync_array_2(data, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 973)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 975)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33394,7 +33483,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 971)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 973)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinSync_array_2, @@ -33422,7 +33511,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_RustOpaque_HideDataTwinSync(data, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 975)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 977)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33449,7 +33538,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 974)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 976)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_RustOpaque_HideDataTwinSync, @@ -33477,7 +33566,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_opaque_twin_sync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 968)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 970)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33505,7 +33594,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_opaque_nested_twin_sync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 977)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 979)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33533,7 +33622,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_NonCloneDataTwinSync(clone, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 972)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 974)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33561,7 +33650,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinSync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 969)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 971)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33589,7 +33678,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinSync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 970)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 972)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33617,7 +33706,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinSync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 978)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 980)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33647,7 +33736,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(a, serializer); sse_encode_i_32(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 980, port: port_); + funcId: 982, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -33676,7 +33765,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(a, serializer); sse_encode_i_32(b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 981)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 983)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -33707,7 +33796,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 982, port: port_); + funcId: 984, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33739,7 +33828,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 983, port: port_); + funcId: 985, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33773,7 +33862,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(b, serializer); sse_encode_StreamSink_u_32_Sse(c, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 984, port: port_); + funcId: 986, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33806,7 +33895,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_my_stream_entry_twin_rust_async_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 985, port: port_); + funcId: 987, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33840,7 +33929,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_twin_rust_async_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 986, port: port_); + funcId: 988, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33874,7 +33963,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_log_twin_rust_async_Sse(sink, serializer); sse_encode_u_32(max, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 987, port: port_); + funcId: 989, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33908,7 +33997,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(key, serializer); sse_encode_u_32(max, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 988, port: port_); + funcId: 990, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33940,7 +34029,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_u_8_array_2_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 989, port: port_); + funcId: 991, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33974,7 +34063,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_struct_containing_stream_sink_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 991, port: port_); + funcId: 993, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34004,7 +34093,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_StreamSink_i_32_Sse(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 990, port: port_); + funcId: 992, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34035,7 +34124,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_one_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 993, port: port_); + funcId: 995, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_one_field_twin_rust_async, @@ -34066,7 +34155,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_two_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 994, port: port_); + funcId: 996, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_two_field_twin_rust_async, @@ -34097,7 +34186,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_zero_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 992, port: port_); + funcId: 994, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_zero_field_twin_rust_async, @@ -34128,7 +34217,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_tuple_struct_with_one_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 995, port: port_); + funcId: 997, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -34160,7 +34249,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_tuple_struct_with_two_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 996, port: port_); + funcId: 998, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -34190,7 +34279,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_one_field_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 998)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1000)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_one_field_twin_sync, @@ -34219,7 +34308,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_two_field_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 999)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1001)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_two_field_twin_sync, @@ -34249,7 +34338,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_zero_field_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 997)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 999)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_zero_field_twin_sync, @@ -34279,7 +34368,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_tuple_struct_with_one_field_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1000)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1002)!; }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_one_field_twin_sync, @@ -34309,7 +34398,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_tuple_struct_with_two_field_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1001)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1003)!; }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_two_field_twin_sync, @@ -34338,7 +34427,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_record_string_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1003, port: port_); + funcId: 1005, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34368,7 +34457,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_record_string_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1002, port: port_); + funcId: 1004, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_record_string_i_32, @@ -34396,7 +34485,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_record_string_i_32(value, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1005)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1007)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34423,7 +34512,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_record_string_i_32(value, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1004)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1006)!; }, codec: SseCodec( decodeSuccessData: sse_decode_record_string_i_32, @@ -34452,7 +34541,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1006, port: port_); + funcId: 1008, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -34482,7 +34571,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1008, port: port_); + funcId: 1010, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_model_twin_rust_async, @@ -34512,7 +34601,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1007, port: port_); + funcId: 1009, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -34540,7 +34629,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1009)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1011)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -34569,7 +34658,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1011)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1013)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_model_twin_sync, @@ -34597,7 +34686,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1010)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1012)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -34627,7 +34716,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feature_uuid_twin_rust_async(ids, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1014, port: port_); + funcId: 1016, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_feature_uuid_twin_rust_async, @@ -34657,7 +34746,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Uuid(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1012, port: port_); + funcId: 1014, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Uuid, @@ -34687,7 +34776,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Uuid(ids, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1013, port: port_); + funcId: 1015, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Uuid, @@ -34716,7 +34805,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feature_uuid_twin_sync(ids, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1017)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1019)!; }, codec: SseCodec( decodeSuccessData: sse_decode_feature_uuid_twin_sync, @@ -34744,7 +34833,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Uuid(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1015)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1017)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Uuid, @@ -34772,7 +34861,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Uuid(ids, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1016)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1018)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_Uuid, @@ -34801,7 +34890,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1019, port: port_); + funcId: 1021, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -34830,7 +34919,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1018, port: port_); + funcId: 1020, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_item_struct_twin_normal, @@ -34860,7 +34949,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1063, port: port_); + funcId: 1065, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34892,7 +34981,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1064, port: port_); + funcId: 1066, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34924,7 +35013,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1062, port: port_); + funcId: 1064, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34956,7 +35045,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1066, port: port_); + funcId: 1068, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -34988,7 +35077,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1065, port: port_); + funcId: 1067, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35019,7 +35108,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1060, port: port_); + funcId: 1062, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35049,7 +35138,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1059, port: port_); + funcId: 1061, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35079,7 +35168,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1061, port: port_); + funcId: 1063, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35111,7 +35200,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1056, port: port_); + funcId: 1058, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35143,7 +35232,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1057, port: port_); + funcId: 1059, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35175,7 +35264,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1055, port: port_); + funcId: 1057, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35205,7 +35294,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1058, port: port_); + funcId: 1060, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35240,7 +35329,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1021, port: port_); + funcId: 1023, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35275,7 +35364,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(expect, serializer); sse_encode_i_32(adder, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1022, port: port_); + funcId: 1024, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35306,7 +35395,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1024, port: port_); + funcId: 1026, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35340,7 +35429,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1020, port: port_); + funcId: 1022, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35372,7 +35461,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_list_prim_i_32_loose(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1045, port: port_); + funcId: 1047, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35406,7 +35495,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1054, port: port_); + funcId: 1056, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -35440,7 +35529,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( mutBorrow, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1053, port: port_); + funcId: 1055, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -35470,7 +35559,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynFnStringStringSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1029, port: port_); + funcId: 1031, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35499,7 +35588,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1030, port: port_); + funcId: 1032, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35534,7 +35623,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerEnumWithGoodAndOpaqueWithoutOptionTwinNormal( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1041, port: port_); + funcId: 1043, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35563,7 +35652,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleEnumTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1042, port: port_); + funcId: 1044, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35592,7 +35681,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1043, port: port_); + funcId: 1045, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35624,7 +35713,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_good_and_opaque_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1038, port: port_); + funcId: 1040, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35654,7 +35743,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1039, port: port_); + funcId: 1041, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_normal, @@ -35684,7 +35773,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1040, port: port_); + funcId: 1042, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_normal, @@ -35718,7 +35807,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1047, port: port_); + funcId: 1049, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35748,7 +35837,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1049, port: port_); + funcId: 1051, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35780,7 +35869,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1048, port: port_); + funcId: 1050, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35811,7 +35900,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1026, port: port_); + funcId: 1028, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35841,7 +35930,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynMyTraitTwinNormalSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1027, port: port_); + funcId: 1029, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35870,7 +35959,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1028, port: port_); + funcId: 1030, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35900,7 +35989,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1051, port: port_); + funcId: 1053, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35930,7 +36019,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1052, port: port_); + funcId: 1054, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35961,7 +36050,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1023, port: port_); + funcId: 1025, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35991,7 +36080,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1046, port: port_); + funcId: 1048, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36026,7 +36115,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( orange, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1050, port: port_); + funcId: 1052, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -36056,7 +36145,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1044, port: port_); + funcId: 1046, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36088,7 +36177,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1036, port: port_); + funcId: 1038, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36118,7 +36207,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1037, port: port_); + funcId: 1039, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36154,7 +36243,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1032, port: port_); + funcId: 1034, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36188,7 +36277,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1033, port: port_); + funcId: 1035, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36222,7 +36311,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1031, port: port_); + funcId: 1033, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36251,7 +36340,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1034, port: port_); + funcId: 1036, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36282,7 +36371,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1035, port: port_); + funcId: 1037, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36318,7 +36407,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1025, port: port_); + funcId: 1027, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36346,7 +36435,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1069, port: port_); + funcId: 1071, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_opaque_twin_normal_array_5, @@ -36373,7 +36462,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1078, port: port_); + funcId: 1080, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opaque_nested_twin_normal, @@ -36399,7 +36488,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1067, port: port_); + funcId: 1069, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinNormal, @@ -36427,7 +36516,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_RustOpaque_HideDataTwinNormal( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1068, port: port_); + funcId: 1070, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36454,7 +36543,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1081, port: port_); + funcId: 1083, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueReturnTwinNormal, @@ -36481,7 +36570,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal_array_2(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1075, port: port_); + funcId: 1077, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36507,7 +36596,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1073, port: port_); + funcId: 1075, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinNormal_array_2, @@ -36534,7 +36623,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_RustOpaque_HideDataTwinNormal(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1077, port: port_); + funcId: 1079, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36560,7 +36649,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1076, port: port_); + funcId: 1078, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_RustOpaque_HideDataTwinNormal, @@ -36587,7 +36676,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_opaque_twin_normal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1070, port: port_); + funcId: 1072, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -36614,7 +36703,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_opaque_nested_twin_normal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1079, port: port_); + funcId: 1081, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36641,7 +36730,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_NonCloneDataTwinNormal(clone, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1074, port: port_); + funcId: 1076, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -36668,7 +36757,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1071, port: port_); + funcId: 1073, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -36695,7 +36784,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1072, port: port_); + funcId: 1074, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -36722,7 +36811,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1080, port: port_); + funcId: 1082, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -36747,7 +36836,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1085)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1087)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueSyncReturnTwinNormal, @@ -36773,7 +36862,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1084)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1086)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_NonCloneDataTwinNormal, @@ -36799,7 +36888,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1083)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1085)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataAnotherTwinNormal, @@ -36825,7 +36914,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1082)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1084)!; }, codec: SseCodec( decodeSuccessData: @@ -36855,7 +36944,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(a, serializer); sse_encode_i_32(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1086, port: port_); + funcId: 1088, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -36883,7 +36972,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1087, port: port_); + funcId: 1089, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36912,7 +37001,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1088, port: port_); + funcId: 1090, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36943,7 +37032,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(b, serializer); sse_encode_StreamSink_u_32_Sse(c, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1089, port: port_); + funcId: 1091, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36973,7 +37062,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_my_stream_entry_twin_normal_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1090, port: port_); + funcId: 1092, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37004,7 +37093,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_twin_normal_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1091, port: port_); + funcId: 1093, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37035,7 +37124,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_log_twin_normal_Sse(sink, serializer); sse_encode_u_32(max, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1092, port: port_); + funcId: 1094, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37066,7 +37155,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(key, serializer); sse_encode_u_32(max, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1093, port: port_); + funcId: 1095, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37095,7 +37184,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_u_8_array_2_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1094, port: port_); + funcId: 1096, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37126,7 +37215,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_struct_containing_stream_sink_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1096, port: port_); + funcId: 1098, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37153,7 +37242,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_StreamSink_i_32_Sse(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1095, port: port_); + funcId: 1097, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37182,7 +37271,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_String_Sse(sink, serializer); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1097, port: port_); + funcId: 1099, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37211,7 +37300,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_i_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1098, port: port_); + funcId: 1100, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37241,7 +37330,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_one_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1100, port: port_); + funcId: 1102, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_one_field_twin_normal, @@ -37271,7 +37360,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_two_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1101, port: port_); + funcId: 1103, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_two_field_twin_normal, @@ -37301,7 +37390,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_zero_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1099, port: port_); + funcId: 1101, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_zero_field_twin_normal, @@ -37331,7 +37420,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_tuple_struct_with_one_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1102, port: port_); + funcId: 1104, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_one_field_twin_normal, @@ -37362,7 +37451,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_tuple_struct_with_two_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1103, port: port_); + funcId: 1105, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_two_field_twin_normal, @@ -37391,7 +37480,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_record_string_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1105, port: port_); + funcId: 1107, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37418,7 +37507,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_record_string_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1104, port: port_); + funcId: 1106, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_record_string_i_32, @@ -37445,7 +37534,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1106, port: port_); + funcId: 1108, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -37472,7 +37561,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1108, port: port_); + funcId: 1110, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_model_twin_normal, @@ -37499,7 +37588,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1107, port: port_); + funcId: 1109, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -37527,7 +37616,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feature_uuid_twin_normal(ids, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1111, port: port_); + funcId: 1113, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_feature_uuid_twin_normal, @@ -37554,7 +37643,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Uuid(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1109, port: port_); + funcId: 1111, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Uuid, @@ -37581,7 +37670,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Uuid(ids, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1110, port: port_); + funcId: 1112, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Uuid, @@ -37601,15 +37690,61 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); Future Function(int, dynamic) - encode_DartFn_Inputs_DartOpaque_Output_unit( + encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_DartOpaque(rawArg0); - final rawOutput = await raw(arg0); + Box? rawOutput; + Box? 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 Function(int, dynamic) + encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) raw) { + return (callId, rawArg0) async { + final arg0 = dco_decode_String(rawArg0); + + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_String(rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_AnyhowException(rawError!.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -37620,15 +37755,29 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { }; } - Future Function(int, dynamic) encode_DartFn_Inputs_String_Output_unit( - FutureOr Function(String) raw) { + Future Function(int, dynamic) + encode_DartFn_Inputs_String_Output_unit_AnyhowException( + FutureOr Function(String) raw) { return (callId, rawArg0) async { final arg0 = dco_decode_String(rawArg0); - final rawOutput = await raw(arg0); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + 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( @@ -37640,7 +37789,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic, dynamic) - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinNormal) raw) { return (callId, rawArg0, rawArg1) async { @@ -37648,10 +37797,23 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final arg1 = dco_decode_demo_struct_for_rust_call_dart_twin_normal(rawArg1); - final rawOutput = await raw(arg0, arg1); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0, arg1)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + 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( @@ -37663,7 +37825,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic, dynamic) - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsync) raw) { @@ -37672,10 +37834,23 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final arg1 = dco_decode_demo_struct_for_rust_call_dart_twin_rust_async(rawArg1); - final rawOutput = await raw(arg0, arg1); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0, arg1)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + 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( @@ -37688,14 +37863,28 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { Future Function( int, - ) encode_DartFn_Inputs__Output_DartOpaque(FutureOr Function() raw) { + ) encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( + FutureOr Function() raw) { return ( callId, ) async { - final rawOutput = await raw(); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw()); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_DartOpaque(rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_DartOpaque(rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_AnyhowException(rawError!.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -37708,14 +37897,28 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { Future Function( int, - ) encode_DartFn_Inputs__Output_String(FutureOr Function() raw) { + ) encode_DartFn_Inputs__Output_String_AnyhowException( + FutureOr Function() raw) { return ( callId, ) async { - final rawOutput = await raw(); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw()); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_String(rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_String(rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_AnyhowException(rawError!.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -37728,14 +37931,28 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { Future Function( int, - ) encode_DartFn_Inputs__Output_unit(FutureOr Function() raw) { + ) encode_DartFn_Inputs__Output_unit_AnyhowException( + FutureOr Function() raw) { return ( callId, ) async { - final rawOutput = await raw(); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw()); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_unit(rawOutput, serializer); + 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( @@ -37747,7 +37964,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic) - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinNormal) raw) { @@ -37755,11 +37972,24 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final arg0 = dco_decode_demo_struct_for_rust_call_dart_twin_normal(rawArg0); - final rawOutput = await raw(arg0); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_demo_struct_for_rust_call_dart_twin_normal( - rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_demo_struct_for_rust_call_dart_twin_normal( + rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_AnyhowException(rawError!.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -37771,7 +38001,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } Future Function(int, dynamic) - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsync) raw) { @@ -37779,11 +38009,24 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final arg0 = dco_decode_demo_struct_for_rust_call_dart_twin_rust_async(rawArg0); - final rawOutput = await raw(arg0); + Box? rawOutput; + Box? rawError; + try { + rawOutput = Box(await raw(arg0)); + } catch (e, s) { + rawError = Box(AnyhowException("$e\n\n$s")); + } final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_demo_struct_for_rust_call_dart_twin_rust_async( - rawOutput, serializer); + assert((rawOutput != null) ^ (rawError != null)); + if (rawOutput != null) { + serializer.buffer.putUint8(0); + sse_encode_demo_struct_for_rust_call_dart_twin_rust_async( + rawOutput.value, serializer); + } else { + serializer.buffer.putUint8(1); + sse_encode_AnyhowException(rawError!.value, serializer); + } final output = serializer.intoRaw(); generalizedFrbRustBinding.dartFnDeliverOutput( @@ -38838,21 +39081,30 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function(Object) - dco_decode_DartFn_Inputs_DartOpaque_Output_unit(dynamic raw) { + dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @protected - FutureOr Function(String) dco_decode_DartFn_Inputs_String_Output_unit( - dynamic raw) { + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError(''); + } + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_unit_AnyhowException(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @protected FutureOr Function(String, DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -38860,28 +39112,29 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function(String, DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_DartOpaque( - dynamic raw) { + FutureOr Function() + dco_decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_String( - dynamic raw) { + FutureOr Function() + dco_decode_DartFn_Inputs__Output_String_AnyhowException(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_unit(dynamic raw) { + FutureOr Function() + dco_decode_DartFn_Inputs__Output_unit_AnyhowException(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); } @@ -38889,7 +39142,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function( DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -38898,7 +39151,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { @protected FutureOr Function( DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(''); @@ -57755,7 +58008,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { void sse_encode_AnyhowException( AnyhowException self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs - throw UnimplementedError('Unreachable ()'); + sse_encode_String(self.message, serializer); } @protected @@ -58325,95 +58578,108 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void sse_encode_DartFn_Inputs_DartOpaque_Output_unit( + void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_DartOpaque_Output_unit(self), serializer); + encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException(self), + serializer); + } + + @protected + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_DartOpaque( + encode_DartFn_Inputs_String_Output_String_AnyhowException(self), + serializer); } @protected - void sse_encode_DartFn_Inputs_String_Output_unit( + void sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( FutureOr Function(String) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_Output_unit(self), serializer); + encode_DartFn_Inputs_String_Output_unit_AnyhowException(self), + serializer); } @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinNormal) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( self), serializer); } @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsync) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( self), serializer); } @protected - void sse_encode_DartFn_Inputs__Output_DartOpaque( + void sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( FutureOr Function() self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs__Output_DartOpaque(self), serializer); + encode_DartFn_Inputs__Output_DartOpaque_AnyhowException(self), + serializer); } @protected - void sse_encode_DartFn_Inputs__Output_String( + void sse_encode_DartFn_Inputs__Output_String_AnyhowException( FutureOr Function() self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs__Output_String(self), serializer); + encode_DartFn_Inputs__Output_String_AnyhowException(self), serializer); } @protected - void sse_encode_DartFn_Inputs__Output_unit( + void sse_encode_DartFn_Inputs__Output_unit_AnyhowException( FutureOr Function() self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs - sse_encode_DartOpaque(encode_DartFn_Inputs__Output_unit(self), serializer); + sse_encode_DartOpaque( + encode_DartFn_Inputs__Output_unit_AnyhowException(self), serializer); } @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinNormal) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( self), serializer); } @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsync) self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_DartOpaque( - encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( self), serializer); } diff --git a/frb_example/pure_dart_pde/lib/src/rust/frb_generated.io.dart b/frb_example/pure_dart_pde/lib/src/rust/frb_generated.io.dart index b779f0b961..04e4b515e4 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/frb_generated.io.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/frb_generated.io.dart @@ -727,43 +727,50 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected FutureOr Function(Object) - dco_decode_DartFn_Inputs_DartOpaque_Output_unit(dynamic raw); + dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + dynamic raw); @protected - FutureOr Function(String) dco_decode_DartFn_Inputs_String_Output_unit( - dynamic raw); + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + dynamic raw); + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_unit_AnyhowException(dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_DartOpaque( - dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_String( - dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_String_AnyhowException(dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_unit(dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_unit_AnyhowException(dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( dynamic raw); @protected @@ -8672,43 +8679,47 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_Chrono_Utc(DateTime self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_DartOpaque_Output_unit( + void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_String_Output_unit( + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer); + + @protected + void sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( FutureOr Function(String) self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinNormal) self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsync) self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_DartOpaque( + void sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_String( + void sse_encode_DartFn_Inputs__Output_String_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_unit( + void sse_encode_DartFn_Inputs__Output_unit_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinNormal) self, @@ -8716,7 +8727,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsync) self, diff --git a/frb_example/pure_dart_pde/lib/src/rust/frb_generated.web.dart b/frb_example/pure_dart_pde/lib/src/rust/frb_generated.web.dart index f955bdfef7..146429e155 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/frb_generated.web.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/frb_generated.web.dart @@ -726,43 +726,50 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected FutureOr Function(Object) - dco_decode_DartFn_Inputs_DartOpaque_Output_unit(dynamic raw); + dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( + dynamic raw); @protected - FutureOr Function(String) dco_decode_DartFn_Inputs_String_Output_unit( - dynamic raw); + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_String_AnyhowException( + dynamic raw); + + @protected + FutureOr Function(String) + dco_decode_DartFn_Inputs_String_Output_unit_AnyhowException(dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( dynamic raw); @protected FutureOr Function(String, DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + dco_decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_DartOpaque( - dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_String( - dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_String_AnyhowException(dynamic raw); @protected - FutureOr Function() dco_decode_DartFn_Inputs__Output_unit(dynamic raw); + FutureOr Function() + dco_decode_DartFn_Inputs__Output_unit_AnyhowException(dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinNormal) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( dynamic raw); @protected FutureOr Function( DemoStructForRustCallDartTwinRustAsync) - dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + dco_decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( dynamic raw); @protected @@ -8671,43 +8678,47 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_Chrono_Utc(DateTime self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_DartOpaque_Output_unit( + void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs_String_Output_unit( + void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException( + FutureOr Function(String) self, SseSerializer serializer); + + @protected + void sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( FutureOr Function(String) self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( FutureOr Function(String, DemoStructForRustCallDartTwinNormal) self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( + sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( FutureOr Function( String, DemoStructForRustCallDartTwinRustAsync) self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_DartOpaque( + void sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_String( + void sse_encode_DartFn_Inputs__Output_String_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected - void sse_encode_DartFn_Inputs__Output_unit( + void sse_encode_DartFn_Inputs__Output_unit_AnyhowException( FutureOr Function() self, SseSerializer serializer); @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinNormal) self, @@ -8715,7 +8726,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void - sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( + sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( FutureOr Function( DemoStructForRustCallDartTwinRustAsync) self, diff --git a/frb_example/pure_dart_pde/rust/src/api/dart_fn.rs b/frb_example/pure_dart_pde/rust/src/api/dart_fn.rs index 3eae715d46..a9e7bff0b1 100644 --- a/frb_example/pure_dart_pde/rust/src/api/dart_fn.rs +++ b/frb_example/pure_dart_pde/rust/src/api/dart_fn.rs @@ -65,3 +65,10 @@ pub async fn rust_call_dart_multi_times_twin_normal( callback().await; } } + +pub async fn rust_call_dart_return_result_twin_normal( + callback: impl Fn(String) -> DartFnFuture>, + expect_output: Option, +) { + assert_eq!(callback("hi".to_owned()).await.ok(), expect_output); +} diff --git a/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/dart_fn_twin_rust_async.rs b/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/dart_fn_twin_rust_async.rs index 8f80f1768a..644fed682a 100644 --- a/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/dart_fn_twin_rust_async.rs +++ b/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/dart_fn_twin_rust_async.rs @@ -69,3 +69,10 @@ pub async fn rust_call_dart_multi_times_twin_rust_async( callback().await; } } + +pub async fn rust_call_dart_return_result_twin_rust_async( + callback: impl Fn(String) -> DartFnFuture>, + expect_output: Option, +) { + assert_eq!(callback("hi".to_owned()).await.ok(), expect_output); +} diff --git a/frb_example/pure_dart_pde/rust/src/frb_generated.rs b/frb_example/pure_dart_pde/rust/src/frb_generated.rs index 9f187fcec3..4e787523b9 100644 --- a/frb_example/pure_dart_pde/rust/src/frb_generated.rs +++ b/frb_example/pure_dart_pde/rust/src/frb_generated.rs @@ -49,7 +49,7 @@ flutter_rust_bridge::frb_generated_boilerplate!( default_rust_auto_opaque = RustAutoOpaqueMoi, ); pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.34"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 571456469; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1044428238; // Section: executor @@ -1500,7 +1500,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_loopback_twin_normal_impl( FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_loopback_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::dart_fn::rust_call_dart_loopback_twin_normal(api_callback).await) })().await) @@ -1528,7 +1528,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_multi_times_twin_normal_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_unit( + let api_callback = decode_DartFn_Inputs__Output_unit_AnyhowException( ::sse_decode(&mut deserializer), ); let api_num_times = ::sse_decode(&mut deserializer); @@ -1572,7 +1572,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_String_Output_unit( + let api_callback = decode_DartFn_Inputs_String_Output_unit_AnyhowException( ::sse_decode(&mut deserializer), ); deserializer.end(); @@ -1590,7 +1590,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal_impl( }, ) } -fn wire__crate__api__dart_fn__rust_call_dart_return_twin_normal_impl( +fn wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, @@ -1598,7 +1598,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_return_twin_normal_impl( ) { FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( flutter_rust_bridge::for_generated::TaskInfo { - debug_name: "rust_call_dart_return_twin_normal", + debug_name: "rust_call_dart_return_result_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, @@ -1612,16 +1612,20 @@ fn wire__crate__api__dart_fn__rust_call_dart_return_twin_normal_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_String( + let api_callback = decode_DartFn_Inputs_String_Output_String_AnyhowException( ::sse_decode(&mut deserializer), ); + let api_expect_output = >::sse_decode(&mut deserializer); deserializer.end(); move |context| async move { transform_result_sse( (move || async move { Result::<_, ()>::Ok( - crate::api::dart_fn::rust_call_dart_return_twin_normal(api_callback) - .await, + crate::api::dart_fn::rust_call_dart_return_result_twin_normal( + api_callback, + api_expect_output, + ) + .await, ) })() .await, @@ -1630,7 +1634,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_return_twin_normal_impl( }, ) } -fn wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl( +fn wire__crate__api__dart_fn__rust_call_dart_return_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, @@ -1638,7 +1642,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl( ) { FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( flutter_rust_bridge::for_generated::TaskInfo { - debug_name: "rust_call_dart_simple_twin_normal", + debug_name: "rust_call_dart_return_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, @@ -1652,7 +1656,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_unit( + let api_callback = decode_DartFn_Inputs__Output_String_AnyhowException( ::sse_decode(&mut deserializer), ); deserializer.end(); @@ -1660,7 +1664,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl( transform_result_sse( (move || async move { Result::<_, ()>::Ok( - crate::api::dart_fn::rust_call_dart_simple_twin_normal(api_callback) + crate::api::dart_fn::rust_call_dart_return_twin_normal(api_callback) .await, ) })() @@ -1670,7 +1674,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl( }, ) } -fn wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal_impl( +fn wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, @@ -1678,7 +1682,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal_impl( ) { FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::( flutter_rust_bridge::for_generated::TaskInfo { - debug_name: "rust_call_dart_two_args_twin_normal", + debug_name: "rust_call_dart_simple_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, @@ -1692,16 +1696,15 @@ fn wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = - decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( - ::sse_decode(&mut deserializer), - ); + let api_callback = decode_DartFn_Inputs__Output_unit_AnyhowException( + ::sse_decode(&mut deserializer), + ); deserializer.end(); move |context| async move { transform_result_sse( (move || async move { Result::<_, ()>::Ok( - crate::api::dart_fn::rust_call_dart_two_args_twin_normal(api_callback) + crate::api::dart_fn::rust_call_dart_simple_twin_normal(api_callback) .await, ) })() @@ -1711,6 +1714,21 @@ fn wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal_impl( }, ) } +fn wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_two_args_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { + let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_callback = decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + transform_result_sse((move || async move { + Result::<_,()>::Ok(crate::api::dart_fn::rust_call_dart_two_args_twin_normal(api_callback).await) + })().await) + } }) +} fn wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_arg_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -1734,7 +1752,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_arg_twin_normal_im let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); let api_input = ::sse_decode(&mut deserializer); - let api_callback = decode_DartFn_Inputs_DartOpaque_Output_unit( + let api_callback = decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( ::sse_decode(&mut deserializer), ); deserializer.end(); @@ -1764,7 +1782,7 @@ fn wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_result_twin_normal FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_with_dart_opaque_result_twin_normal", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_DartOpaque(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::dart_fn::rust_call_dart_with_dart_opaque_result_twin_normal(api_callback).await) })().await) @@ -12853,7 +12871,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_loop FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_loopback_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_loopback_twin_rust_async(api_callback).await) })().await) @@ -12868,7 +12886,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_mult FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_multi_times_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_unit(::sse_decode(&mut deserializer)); + let api_callback = decode_DartFn_Inputs__Output_unit_AnyhowException(::sse_decode(&mut deserializer)); let api_num_times = ::sse_decode(&mut deserializer);deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_multi_times_twin_rust_async(api_callback, api_num_times).await) @@ -12884,12 +12902,28 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_ FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_one_arg_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_String_Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs_String_Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_one_arg_twin_rust_async(api_callback).await) })().await) } }) } +fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_return_result_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { + let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_callback = decode_DartFn_Inputs_String_Output_String_AnyhowException(::sse_decode(&mut deserializer)); +let api_expect_output = >::sse_decode(&mut deserializer);deserializer.end(); move |context| async move { + transform_result_sse((move || async move { + Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_return_result_twin_rust_async(api_callback, api_expect_output).await) + })().await) + } }) +} fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -12899,7 +12933,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_retu FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_return_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_String(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs__Output_String_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_return_twin_rust_async(api_callback).await) })().await) @@ -12914,7 +12948,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_simp FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_simple_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs__Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_simple_twin_rust_async(api_callback).await) })().await) @@ -12929,7 +12963,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_two_ FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_two_args_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_two_args_twin_rust_async(api_callback).await) })().await) @@ -12945,7 +12979,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); let api_input = ::sse_decode(&mut deserializer); -let api_callback = decode_DartFn_Inputs_DartOpaque_Output_unit(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { +let api_callback = decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_with_dart_opaque_arg_twin_rust_async(api_input, api_callback).await) })().await) @@ -12960,7 +12994,7 @@ fn wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "rust_call_dart_with_dart_opaque_result_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_callback = decode_DartFn_Inputs__Output_DartOpaque(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { + let api_callback = decode_DartFn_Inputs__Output_DartOpaque_AnyhowException(::sse_decode(&mut deserializer));deserializer.end(); move |context| async move { transform_result_sse((move || async move { Result::<_,()>::Ok(crate::api::pseudo_manual::dart_fn_twin_rust_async::rust_call_dart_with_dart_opaque_result_twin_rust_async(api_callback).await) })().await) @@ -24449,7 +24483,7 @@ const _: fn() = || { // Section: related_funcs -fn decode_DartFn_Inputs_DartOpaque_Output_unit( +fn decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn(flutter_rust_bridge::DartOpaque) -> flutter_rust_bridge::DartFnFuture<()> { use flutter_rust_bridge::IntoDart; @@ -24462,7 +24496,19 @@ fn decode_DartFn_Inputs_DartOpaque_Output_unit( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: flutter_rust_bridge::DartOpaque| { @@ -24472,7 +24518,45 @@ fn decode_DartFn_Inputs_DartOpaque_Output_unit( )) } } -fn decode_DartFn_Inputs_String_Output_unit( +fn decode_DartFn_Inputs_String_Output_String_AnyhowException( + dart_opaque: flutter_rust_bridge::DartOpaque, +) -> impl Fn( + String, +) -> flutter_rust_bridge::DartFnFuture< + std::result::Result, +> { + use flutter_rust_bridge::IntoDart; + + async fn body( + dart_opaque: flutter_rust_bridge::DartOpaque, + arg0: String, + ) -> std::result::Result { + let args = vec![arg0.into_into_dart().into_dart()]; + let message = FLUTTER_RUST_BRIDGE_HANDLER + .dart_fn_invoke(dart_opaque, args) + .await; + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + ans + } + + move |arg0: String| { + flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body( + dart_opaque.clone(), + arg0, + )) + } +} +fn decode_DartFn_Inputs_String_Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn(String) -> flutter_rust_bridge::DartFnFuture<()> { use flutter_rust_bridge::IntoDart; @@ -24482,7 +24566,19 @@ fn decode_DartFn_Inputs_String_Output_unit( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: String| { @@ -24492,7 +24588,7 @@ fn decode_DartFn_Inputs_String_Output_unit( )) } } -fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit( +fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( String, @@ -24512,7 +24608,19 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: String, arg1: crate::api::dart_fn::DemoStructForRustCallDartTwinNormal| { @@ -24523,7 +24631,7 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output )) } } -fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit( +fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( String, @@ -24543,7 +24651,19 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Ou let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: String, arg1: crate::api::pseudo_manual::dart_fn_twin_rust_async::DemoStructForRustCallDartTwinRustAsync| { @@ -24552,7 +24672,7 @@ fn decode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Ou )) } } -fn decode_DartFn_Inputs__Output_DartOpaque( +fn decode_DartFn_Inputs__Output_DartOpaque_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn() -> flutter_rust_bridge::DartFnFuture { use flutter_rust_bridge::IntoDart; @@ -24562,14 +24682,28 @@ fn decode_DartFn_Inputs__Output_DartOpaque( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - ::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode( + &mut deserializer, + )), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move || { flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body(dart_opaque.clone())) } } -fn decode_DartFn_Inputs__Output_String( +fn decode_DartFn_Inputs__Output_String_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn() -> flutter_rust_bridge::DartFnFuture { use flutter_rust_bridge::IntoDart; @@ -24579,14 +24713,26 @@ fn decode_DartFn_Inputs__Output_String( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - ::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move || { flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body(dart_opaque.clone())) } } -fn decode_DartFn_Inputs__Output_unit( +fn decode_DartFn_Inputs__Output_unit_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn() -> flutter_rust_bridge::DartFnFuture<()> { use flutter_rust_bridge::IntoDart; @@ -24596,14 +24742,26 @@ fn decode_DartFn_Inputs__Output_unit( let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - <()>::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(<()>::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move || { flutter_rust_bridge::for_generated::convert_into_dart_fn_future(body(dart_opaque.clone())) } } -fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal( +fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_struct_for_rust_call_dart_twin_normal_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( crate::api::dart_fn::DemoStructForRustCallDartTwinNormal, @@ -24620,7 +24778,23 @@ fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_s let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - ::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok( + ::sse_decode( + &mut deserializer, + ), + ), + 1 => std::result::Result::Err( + ::sse_decode(&mut deserializer), + ), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: crate::api::dart_fn::DemoStructForRustCallDartTwinNormal| { @@ -24630,7 +24804,7 @@ fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_normal_Output_demo_s )) } } -fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async( +fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( dart_opaque: flutter_rust_bridge::DartOpaque, ) -> impl Fn( crate::api::pseudo_manual::dart_fn_twin_rust_async::DemoStructForRustCallDartTwinRustAsync, @@ -24648,7 +24822,17 @@ fn decode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_de let message = FLUTTER_RUST_BRIDGE_HANDLER .dart_fn_invoke(dart_opaque, args) .await; - ::sse_decode_single(message) + + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let action = deserializer.cursor.read_u8().unwrap(); + let ans = match action { + 0 => std::result::Result::Ok(::sse_decode(&mut deserializer)), + 1 => std::result::Result::Err(::sse_decode(&mut deserializer)), + _ => unreachable!(), + }; + deserializer.end(); + let ans = ans.expect("Dart throws exception but Rust side assume it is not failable"); + ans } move |arg0: crate::api::pseudo_manual::dart_fn_twin_rust_async::DemoStructForRustCallDartTwinRustAsync| { @@ -24816,7 +25000,8 @@ flutter_rust_bridge::frb_generated_moi_arc_impl_value!(i32); impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - unreachable!(""); + let mut inner = ::sse_decode(deserializer); + return anyhow::anyhow!("{}", inner); } } @@ -34557,710 +34742,712 @@ fn pde_ffi_dispatcher_primary_impl( 54 => wire__crate__api__dart_fn__rust_call_dart_loopback_twin_normal_impl(port, ptr, rust_vec_len, data_len), 57 => wire__crate__api__dart_fn__rust_call_dart_multi_times_twin_normal_impl(port, ptr, rust_vec_len, data_len), 51 => wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +58 => wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), 53 => wire__crate__api__dart_fn__rust_call_dart_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), 50 => wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl(port, ptr, rust_vec_len, data_len), 52 => wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal_impl(port, ptr, rust_vec_len, data_len), 55 => wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), 56 => wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), -58 => wire__crate__api__dart_opaque__async_accept_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -73 => wire__crate__api__dart_opaque__clone_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -69 => wire__crate__api__dart_opaque__create_enum_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -67 => wire__crate__api__dart_opaque__create_nested_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -72 => wire__crate__api__dart_opaque__drop_static_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -70 => wire__crate__api__dart_opaque__get_enum_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -68 => wire__crate__api__dart_opaque__get_nested_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -64 => wire__crate__api__dart_opaque__loop_back_array_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), -61 => wire__crate__api__dart_opaque__loop_back_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), -63 => wire__crate__api__dart_opaque__loop_back_option_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), -60 => wire__crate__api__dart_opaque__loop_back_option_twin_normal_impl(port, ptr, rust_vec_len, data_len), -59 => wire__crate__api__dart_opaque__loop_back_twin_normal_impl(port, ptr, rust_vec_len, data_len), -65 => wire__crate__api__dart_opaque__loop_back_vec_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), -62 => wire__crate__api__dart_opaque__loop_back_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), -66 => wire__crate__api__dart_opaque__panic_unwrap_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -71 => wire__crate__api__dart_opaque__set_static_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -79 => wire__crate__api__deliberate_name_conflict__test_duplicated_module_names_impl(port, ptr, rust_vec_len, data_len), -82 => wire__crate__api__dropping__DroppableTwinNormal_create_stream_impl(port, ptr, rust_vec_len, data_len), -83 => wire__crate__api__dropping__DroppableTwinNormal_get_drop_count_twin_normal_impl(port, ptr, rust_vec_len, data_len), -80 => wire__crate__api__dropping__DroppableTwinNormal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), -81 => wire__crate__api__dropping__DroppableTwinNormal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -84 => wire__crate__api__enumeration__func_enum_simple_twin_normal_impl(port, ptr, rust_vec_len, data_len), -88 => wire__crate__api__enumeration__func_enum_with_discriminant_twin_normal_impl(port, ptr, rust_vec_len, data_len), -85 => wire__crate__api__enumeration__func_enum_with_item_mixed_twin_normal_impl(port, ptr, rust_vec_len, data_len), -87 => wire__crate__api__enumeration__func_enum_with_item_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -86 => wire__crate__api__enumeration__func_enum_with_item_tuple_twin_normal_impl(port, ptr, rust_vec_len, data_len), -91 => wire__crate__api__enumeration__handle_enum_parameter_twin_normal_impl(port, ptr, rust_vec_len, data_len), -93 => wire__crate__api__enumeration__handle_enum_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -90 => wire__crate__api__enumeration__handle_return_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -92 => wire__crate__api__enumeration__multiply_by_ten_twin_normal_impl(port, ptr, rust_vec_len, data_len), -89 => wire__crate__api__enumeration__print_note_twin_normal_impl(port, ptr, rust_vec_len, data_len), -95 => wire__crate__api__event_listener__close_event_listener_twin_normal_impl(port, ptr, rust_vec_len, data_len), -96 => wire__crate__api__event_listener__create_event_twin_normal_impl(port, ptr, rust_vec_len, data_len), -98 => wire__crate__api__event_listener__event_twin_normal_as_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -94 => wire__crate__api__event_listener__register_event_listener_twin_normal_impl(port, ptr, rust_vec_len, data_len), -103 => wire__crate__api__exception__custom_enum_error_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -104 => wire__crate__api__exception__custom_enum_error_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -102 => wire__crate__api__exception__custom_enum_error_return_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), -105 => wire__crate__api__exception__custom_nested_error_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -106 => wire__crate__api__exception__custom_struct_error_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -123 => wire__crate__api__exception__custom_struct_twin_normal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), -126 => wire__crate__api__exception__custom_struct_twin_normal_nonstatic_return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -127 => wire__crate__api__exception__custom_struct_twin_normal_nonstatic_return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), -124 => wire__crate__api__exception__custom_struct_twin_normal_static_return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -125 => wire__crate__api__exception__custom_struct_twin_normal_static_return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), -99 => wire__crate__api__exception__func_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -100 => wire__crate__api__exception__func_type_fallible_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -101 => wire__crate__api__exception__func_type_infallible_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -116 => wire__crate__api__exception__panic_with_custom_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), -110 => wire__crate__api__exception__return_custom_nested_error_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), -111 => wire__crate__api__exception__return_custom_nested_error_1_variant1_twin_normal_impl(port, ptr, rust_vec_len, data_len), -112 => wire__crate__api__exception__return_custom_nested_error_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), -113 => wire__crate__api__exception__return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -114 => wire__crate__api__exception__return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), -107 => wire__crate__api__exception__return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -109 => wire__crate__api__exception__return_error_variant_twin_normal_impl(port, ptr, rust_vec_len, data_len), -108 => wire__crate__api__exception__return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -118 => wire__crate__api__exception__some_struct_twin_normal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), -121 => wire__crate__api__exception__some_struct_twin_normal_non_static_return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -122 => wire__crate__api__exception__some_struct_twin_normal_non_static_return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -119 => wire__crate__api__exception__some_struct_twin_normal_static_return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -120 => wire__crate__api__exception__some_struct_twin_normal_static_return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -117 => wire__crate__api__exception__stream_sink_throw_anyhow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -115 => wire__crate__api__exception__throw_anyhow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -130 => wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method_impl(port, ptr, rust_vec_len, data_len), -128 => wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method_impl(port, ptr, rust_vec_len, data_len), -134 => wire__crate__api__external_type_in_crate__call_new_module_system_twin_normal_impl(port, ptr, rust_vec_len, data_len), -133 => wire__crate__api__external_type_in_crate__call_old_module_system_twin_normal_impl(port, ptr, rust_vec_len, data_len), -132 => wire__crate__api__external_type_in_crate__use_imported_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -131 => wire__crate__api__external_type_in_crate__use_imported_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -136 => wire__crate__api__inside_macro__another_macro_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -135 => wire__crate__api__inside_macro__func_macro_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -137 => wire__crate__api__map_and_set__func_hash_map_i32_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -141 => wire__crate__api__map_and_set__func_hash_map_string_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -144 => wire__crate__api__map_and_set__func_hash_map_string_complex_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -143 => wire__crate__api__map_and_set__func_hash_map_string_simple_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -139 => wire__crate__api__map_and_set__func_hash_map_string_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -142 => wire__crate__api__map_and_set__func_hash_map_string_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -138 => wire__crate__api__map_and_set__func_hash_set_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -140 => wire__crate__api__map_and_set__func_hash_set_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -166 => wire__crate__api__method__StaticGetterOnlyTwinNormal_static_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), -149 => wire__crate__api__method__concatenate_with_twin_normal_concatenate_static_twin_normal_impl(port, ptr, rust_vec_len, data_len), -148 => wire__crate__api__method__concatenate_with_twin_normal_concatenate_twin_normal_impl(port, ptr, rust_vec_len, data_len), -154 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_static_stream_sink_single_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -153 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_static_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), -152 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_stream_sink_at_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), -151 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), -147 => wire__crate__api__method__concatenate_with_twin_normal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), -150 => wire__crate__api__method__concatenate_with_twin_normal_simple_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), -146 => wire__crate__api__method__get_sum_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), -145 => wire__crate__api__method__get_sum_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -156 => wire__crate__api__method__my_callable_twin_normal_call_impl(port, ptr, rust_vec_len, data_len), -162 => wire__crate__api__method__simple_enum_twin_normal_return_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), -163 => wire__crate__api__method__simple_enum_twin_normal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -164 => wire__crate__api__method__simple_primitive_enum_twin_normal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -160 => wire__crate__api__method__simple_struct_twin_normal_arg_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), -158 => wire__crate__api__method__simple_struct_twin_normal_receiver_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -159 => wire__crate__api__method__simple_struct_twin_normal_receiver_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -157 => wire__crate__api__method__simple_struct_twin_normal_return_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), -161 => wire__crate__api__method__simple_struct_twin_normal_vec_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), -165 => wire__crate__api__method__static_only_twin_normal_static_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -155 => wire__crate__api__method__sum_with_twin_normal_sum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -170 => wire__crate__api__mirror__app_settings_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -171 => wire__crate__api__mirror__app_settings_vec_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -177 => wire__crate__api__mirror__first_number_twin_normal_impl(port, ptr, rust_vec_len, data_len), -178 => wire__crate__api__mirror__first_sequence_twin_normal_impl(port, ptr, rust_vec_len, data_len), -167 => wire__crate__api__mirror__get_app_settings_twin_normal_impl(port, ptr, rust_vec_len, data_len), -168 => wire__crate__api__mirror__get_fallible_app_settings_twin_normal_impl(port, ptr, rust_vec_len, data_len), -174 => wire__crate__api__mirror__get_message_twin_normal_impl(port, ptr, rust_vec_len, data_len), -169 => wire__crate__api__mirror__is_app_embedded_twin_normal_impl(port, ptr, rust_vec_len, data_len), -192 => wire__crate__api__mirror__mirror_array_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -187 => wire__crate__api__mirror__mirror_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -190 => wire__crate__api__mirror__mirror_map_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -188 => wire__crate__api__mirror__mirror_option_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -191 => wire__crate__api__mirror__mirror_set_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -172 => wire__crate__api__mirror__mirror_struct_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -173 => wire__crate__api__mirror__mirror_tuple_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -189 => wire__crate__api__mirror__mirror_vec_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -175 => wire__crate__api__mirror__repeat_number_twin_normal_impl(port, ptr, rust_vec_len, data_len), -176 => wire__crate__api__mirror__repeat_sequence_twin_normal_impl(port, ptr, rust_vec_len, data_len), -185 => wire__crate__api__mirror__test_contains_mirrored_sub_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -183 => wire__crate__api__mirror__test_fallible_of_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -186 => wire__crate__api__mirror__test_hashmap_with_mirrored_value_twin_normal_impl(port, ptr, rust_vec_len, data_len), -184 => wire__crate__api__mirror__test_list_of_nested_enums_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -182 => wire__crate__api__mirror__test_list_of_raw_nested_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -180 => wire__crate__api__mirror__test_nested_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -181 => wire__crate__api__mirror__test_raw_string_enum_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -179 => wire__crate__api__mirror__test_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -196 => wire__crate__api__misc_example__handle_big_buffers_twin_normal_impl(port, ptr, rust_vec_len, data_len), -193 => wire__crate__api__misc_example__handle_complex_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -195 => wire__crate__api__misc_example__handle_nested_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -199 => wire__crate__api__misc_example__handle_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -201 => wire__crate__api__misc_example__handle_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -200 => wire__crate__api__misc_example__handle_vec_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -194 => wire__crate__api__misc_example__list_of_primitive_enums_twin_normal_impl(port, ptr, rust_vec_len, data_len), -197 => wire__crate__api__misc_example__test_abc_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -198 => wire__crate__api__misc_example__test_struct_with_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -203 => wire__crate__api__misc_no_twin_example_a__StructInMiscNoTwinExampleA_sample_function_a_impl(port, ptr, rust_vec_len, data_len), -204 => wire__crate__api__misc_no_twin_example_a__StructWithImplBlockInMultiFile_method_in_a_impl(port, ptr, rust_vec_len, data_len), -202 => wire__crate__api__misc_no_twin_example_a__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), -209 => wire__crate__api__misc_no_twin_example_a__struct_with_impl_block_in_another_file_f_impl(port, ptr, rust_vec_len, data_len), -206 => wire__crate__api__misc_no_twin_example_b__StructInMiscNoTwinExampleB_get_struct_in_misc_no_twin_example_a_impl(port, ptr, rust_vec_len, data_len), -207 => wire__crate__api__misc_no_twin_example_b__StructInMiscNoTwinExampleB_sample_function_b_impl(port, ptr, rust_vec_len, data_len), -208 => wire__crate__api__misc_no_twin_example_b__StructWithImplBlockInMultiFile_method_in_b_impl(port, ptr, rust_vec_len, data_len), -205 => wire__crate__api__misc_no_twin_example_b__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), -213 => wire__crate__api__misc_type__empty_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -210 => wire__crate__api__misc_type__func_return_unit_twin_normal_impl(port, ptr, rust_vec_len, data_len), -211 => wire__crate__api__misc_type__handle_list_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -212 => wire__crate__api__misc_type__handle_string_list_twin_normal_impl(port, ptr, rust_vec_len, data_len), -214 => wire__crate__api__newtype_pattern__handle_newtype_twin_normal_impl(port, ptr, rust_vec_len, data_len), -218 => wire__crate__api__optional__handle_increment_boxed_optional_twin_normal_impl(port, ptr, rust_vec_len, data_len), -220 => wire__crate__api__optional__handle_option_box_arguments_twin_normal_impl(port, ptr, rust_vec_len, data_len), -217 => wire__crate__api__optional__handle_optional_increment_twin_normal_impl(port, ptr, rust_vec_len, data_len), -215 => wire__crate__api__optional__handle_optional_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -216 => wire__crate__api__optional__handle_optional_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -219 => wire__crate__api__optional__handle_vec_of_opts_twin_normal_impl(port, ptr, rust_vec_len, data_len), -221 => wire__crate__api__optional_primitive_misc__primitive_optional_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), -224 => wire__crate__api__ownership__borrow_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -223 => wire__crate__api__ownership__borrow_str_twin_normal_impl(port, ptr, rust_vec_len, data_len), -222 => wire__crate__api__ownership__borrow_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -225 => wire__crate__api__ownership__borrow_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -226 => wire__crate__api__primitive_list_misc__handle_vec_of_primitive_twin_normal_impl(port, ptr, rust_vec_len, data_len), -227 => wire__crate__api__primitive_misc__primitive_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), -228 => wire__crate__api__primitive_misc__primitive_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -233 => wire__crate__api__pseudo_manual__array_twin_rust_async__boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -237 => wire__crate__api__pseudo_manual__array_twin_rust_async__func_test_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -229 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -230 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_complex_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -238 => wire__crate__api__pseudo_manual__array_twin_rust_async__last_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -239 => wire__crate__api__pseudo_manual__array_twin_rust_async__nested_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -231 => wire__crate__api__pseudo_manual__array_twin_rust_async__new_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -235 => wire__crate__api__pseudo_manual__array_twin_rust_async__return_boxed_feed_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -236 => wire__crate__api__pseudo_manual__array_twin_rust_async__return_boxed_raw_feed_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -234 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -232 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -252 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__handle_customized_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -253 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__next_user_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -277 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -276 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -278 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -273 => wire__crate__api__pseudo_manual__basic__example_basic_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -275 => wire__crate__api__pseudo_manual__basic__example_basic_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -271 => wire__crate__api__pseudo_manual__basic__example_basic_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -272 => wire__crate__api__pseudo_manual__basic__example_basic_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -262 => wire__crate__api__pseudo_manual__basic__example_basic_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -263 => wire__crate__api__pseudo_manual__basic__example_basic_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -264 => wire__crate__api__pseudo_manual__basic__example_basic_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -261 => wire__crate__api__pseudo_manual__basic__example_basic_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -269 => wire__crate__api__pseudo_manual__basic__example_basic_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -274 => wire__crate__api__pseudo_manual__basic__example_basic_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -266 => wire__crate__api__pseudo_manual__basic__example_basic_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -267 => wire__crate__api__pseudo_manual__basic__example_basic_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -268 => wire__crate__api__pseudo_manual__basic__example_basic_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -265 => wire__crate__api__pseudo_manual__basic__example_basic_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -270 => wire__crate__api__pseudo_manual__basic__example_basic_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -293 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -292 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -294 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -289 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -291 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -287 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -288 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -280 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -281 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -282 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -279 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -290 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -284 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -285 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -286 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -283 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -309 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -308 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -310 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -305 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -307 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -303 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -304 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -296 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -297 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -298 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -295 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -306 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -300 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -301 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -302 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -299 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -343 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -342 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -344 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -339 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -341 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -337 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -338 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -328 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -329 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -330 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -327 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -335 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -340 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -332 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -333 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -334 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -331 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -336 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -361 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -360 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -362 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -357 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -359 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -355 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -356 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -346 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -347 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -348 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -345 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -353 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -358 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -350 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -351 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -352 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -349 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -354 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -397 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -396 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -398 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -393 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -395 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -391 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -392 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -382 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -383 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -384 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -381 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -389 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -394 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -386 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -387 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -388 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -385 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -390 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -415 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -414 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -416 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -411 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -413 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -409 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -410 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -400 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -401 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -402 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -399 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -407 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -412 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -404 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -405 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -406 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -403 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -408 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -451 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -450 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -452 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -447 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -449 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -445 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -446 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -436 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -437 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -438 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -435 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -443 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -448 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -440 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -441 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -442 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -439 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -444 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -478 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -476 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -474 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), -479 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -477 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -475 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), -484 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -482 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -480 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), -485 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -483 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -481 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), -472 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_input_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -473 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_output_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -471 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_void_twin_normal_impl(port, ptr, rust_vec_len, data_len), -493 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -491 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -489 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -494 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -492 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -490 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -499 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -497 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -495 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -500 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -498 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -496 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -487 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_input_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -488 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_output_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -486 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_void_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -517 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_local_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -516 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_utc_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -520 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__duration_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -522 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_durations_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -521 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_timestamps_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -525 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__how_long_does_it_take_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -518 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__naivedatetime_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -519 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__optional_empty_datetime_utc_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -523 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -524 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_precise_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -538 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_slash_star_star_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -537 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_triple_slash_multi_line_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -536 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_triple_slash_single_line_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -540 => wire__crate__api__pseudo_manual__comment_twin_rust_async__struct_with_comments_twin_rust_async_instance_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -539 => wire__crate__api__pseudo_manual__comment_twin_rust_async__struct_with_comments_twin_rust_async_static_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -550 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_loopback_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -553 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_multi_times_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -547 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -549 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -546 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_simple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -548 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_two_args_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -551 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with_dart_opaque_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -552 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with_dart_opaque_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -554 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__async_accept_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -569 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__clone_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -565 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__create_enum_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -563 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__create_nested_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -568 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__drop_static_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -566 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__get_enum_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -564 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__get_nested_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -560 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_array_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -557 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -559 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_option_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -556 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_option_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -555 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -561 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_vec_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -558 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -562 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__panic_unwrap_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -567 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__set_static_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -588 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_create_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -589 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_get_drop_count_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -586 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -587 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -594 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_simple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -598 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_discriminant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -595 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_mixed_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -597 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -596 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_tuple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -601 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_parameter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -603 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -600 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_return_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -602 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__multiply_by_ten_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -599 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__print_note_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -615 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__close_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -616 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__create_event_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -617 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__event_twin_rust_async_as_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -614 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__register_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -622 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -623 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -621 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_return_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -624 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_nested_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -625 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -642 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -645 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_nonstatic_return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -646 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_nonstatic_return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -643 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_static_return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -644 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_static_return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -618 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -619 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_fallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -620 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_infallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -635 => wire__crate__api__pseudo_manual__exception_twin_rust_async__panic_with_custom_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -629 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -630 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_1_variant1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -631 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -632 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -633 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -626 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -628 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_error_variant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -627 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -637 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -640 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_non_static_return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -641 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_non_static_return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -638 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_static_return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -639 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_static_return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -636 => wire__crate__api__pseudo_manual__exception_twin_rust_async__stream_sink_throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -634 => wire__crate__api__pseudo_manual__exception_twin_rust_async__throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -679 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__call_new_module_system_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -678 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__call_old_module_system_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -677 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__use_imported_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -676 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__use_imported_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -684 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_i32_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -688 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -691 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_complex_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -690 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_simple_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -686 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -689 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -685 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_set_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -687 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_set_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -721 => wire__crate__api__pseudo_manual__method_twin_rust_async__StaticGetterOnlyTwinRustAsync_static_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -704 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_concatenate_static_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -703 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_concatenate_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -709 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_static_stream_sink_single_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -708 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_static_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -707 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_stream_sink_at_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -706 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -702 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -705 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_simple_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -701 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -700 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -711 => wire__crate__api__pseudo_manual__method_twin_rust_async__my_callable_twin_rust_async_call_impl(port, ptr, rust_vec_len, data_len), -717 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_enum_twin_rust_async_return_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -718 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_enum_twin_rust_async_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -719 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_primitive_enum_twin_rust_async_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -715 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_arg_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -713 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_receiver_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -714 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_receiver_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -712 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_return_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -716 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_vec_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -720 => wire__crate__api__pseudo_manual__method_twin_rust_async__static_only_twin_rust_async_static_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -710 => wire__crate__api__pseudo_manual__method_twin_rust_async__sum_with_twin_rust_async_sum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -747 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -748 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_vec_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -754 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -755 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -744 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -745 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_fallible_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -751 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_message_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -746 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__is_app_embedded_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -769 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_array_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -764 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -767 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_map_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -765 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_option_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -768 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_set_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -749 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_struct_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -750 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_tuple_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -766 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_vec_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -752 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -753 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -762 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_contains_mirrored_sub_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -760 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_fallible_of_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -763 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_hashmap_with_mirrored_value_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -761 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_list_of_nested_enums_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -759 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_list_of_raw_nested_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -757 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_nested_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -758 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_raw_string_enum_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -756 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -799 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_big_buffers_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -796 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_complex_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -798 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_nested_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -802 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -804 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -803 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_vec_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -797 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__list_of_primitive_enums_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -800 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__test_abc_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -801 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__test_struct_with_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -817 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__empty_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -814 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__func_return_unit_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -815 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__handle_list_of_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -816 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__handle_string_list_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -822 => wire__crate__api__pseudo_manual__newtype_pattern_twin_rust_async__handle_newtype_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -824 => wire__crate__api__pseudo_manual__optional_primitive_misc_twin_rust_async__primitive_optional_types_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -829 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_increment_boxed_optional_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -831 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_option_box_arguments_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -828 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_increment_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -826 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -827 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -830 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_vec_of_opts_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -840 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -839 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_str_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -838 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -841 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -846 => wire__crate__api__pseudo_manual__primitive_list_misc_twin_rust_async__handle_vec_of_primitive_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -848 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_types_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -849 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -853 => wire__crate__api__pseudo_manual__raw_string_twin_rust_async__test_more_than_just_one_raw_string_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -852 => wire__crate__api__pseudo_manual__raw_string_twin_rust_async__test_raw_string_item_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -899 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -900 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -898 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -902 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -901 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -896 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_custom_name_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -895 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -897 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_with_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -892 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -893 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -891 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -894 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -857 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -858 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -860 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_own_and_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -856 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -881 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_vec_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -890 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_borrow_and_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -889 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_borrow_and_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -865 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_callable_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -866 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_callable_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -877 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_dummy_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -878 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -879 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -874 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -875 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -876 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -883 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -885 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -884 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -862 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_normal_and_opaque_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -863 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_plus_sign_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -864 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_plus_sign_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -887 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_opaque_one_and_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -888 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_opaque_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -859 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -882 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_vec_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -886 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_sleep_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -880 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -872 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -873 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -868 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -869 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -867 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -870 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_return_own_one_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -871 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_return_own_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -861 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_two_args_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -952 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_array_opaque_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -961 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -950 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -951 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_option_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -964 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__frb_generator_test_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -958 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -956 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -960 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -959 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -953 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_enum_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -962 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -957 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_non_clone_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -954 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -955 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_opaque_with_delay_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -963 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__unwrap_rust_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -980 => wire__crate__api__pseudo_manual__simple_twin_rust_async__simple_adder_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -982 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -983 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -984 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_sink_arg_position_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -985 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_of_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -986 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -987 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -988 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_3_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -989 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_fixed_sized_primitive_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -991 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -990 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -993 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -994 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_two_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -992 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_zero_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -995 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_one_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -996 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_two_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1003 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1002 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1006 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_alias_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1008 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_alias_model_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1007 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_nest_alias_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1014 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_nested_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1012 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1013 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1019 => wire__crate__api__raw_string__test_more_than_just_one_raw_string_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1018 => wire__crate__api__raw_string__test_raw_string_item_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1063 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1064 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1062 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1066 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1065 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1060 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_custom_name_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1059 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1061 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_with_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1056 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1057 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1055 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1058 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1021 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1022 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1024 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_and_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1020 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1045 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1054 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1053 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1029 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1030 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1041 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_dummy_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1042 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1043 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1038 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1039 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1040 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1047 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1049 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1048 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1026 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_normal_and_opaque_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1027 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1028 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1051 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_one_and_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1052 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1023 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1046 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1050 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_sleep_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1044 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1036 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1037 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1032 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1033 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1031 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1034 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_return_own_one_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1035 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_return_own_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1025 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_two_args_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1069 => wire__crate__api__rust_opaque__create_array_opaque_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1078 => wire__crate__api__rust_opaque__create_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1067 => wire__crate__api__rust_opaque__create_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1068 => wire__crate__api__rust_opaque__create_option_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1081 => wire__crate__api__rust_opaque__frb_generator_test_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1075 => wire__crate__api__rust_opaque__opaque_array_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1073 => wire__crate__api__rust_opaque__opaque_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1077 => wire__crate__api__rust_opaque__opaque_vec_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1076 => wire__crate__api__rust_opaque__opaque_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1070 => wire__crate__api__rust_opaque__run_enum_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1079 => wire__crate__api__rust_opaque__run_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1074 => wire__crate__api__rust_opaque__run_non_clone_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1071 => wire__crate__api__rust_opaque__run_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1072 => wire__crate__api__rust_opaque__run_opaque_with_delay_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1080 => wire__crate__api__rust_opaque__unwrap_rust_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1086 => wire__crate__api__simple__simple_adder_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1087 => wire__crate__api__stream__func_stream_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1088 => wire__crate__api__stream__func_stream_return_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1089 => wire__crate__api__stream__func_stream_sink_arg_position_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1090 => wire__crate__api__stream__handle_stream_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1091 => wire__crate__api__stream__handle_stream_sink_at_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1092 => wire__crate__api__stream__handle_stream_sink_at_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1093 => wire__crate__api__stream__handle_stream_sink_at_3_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1094 => wire__crate__api__stream__stream_sink_fixed_sized_primitive_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1096 => wire__crate__api__stream__stream_sink_inside_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1095 => wire__crate__api__stream__stream_sink_inside_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1097 => wire__crate__api__stream_misc__func_stream_realistic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1098 => wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1100 => wire__crate__api__structure__func_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1101 => wire__crate__api__structure__func_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1099 => wire__crate__api__structure__func_struct_with_zero_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1102 => wire__crate__api__structure__func_tuple_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1103 => wire__crate__api__structure__func_tuple_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1105 => wire__crate__api__tuple__test_tuple_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1104 => wire__crate__api__tuple__test_tuple_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1106 => wire__crate__api__type_alias__handle_type_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1108 => wire__crate__api__type_alias__handle_type_alias_model_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1107 => wire__crate__api__type_alias__handle_type_nest_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1111 => wire__crate__api__uuid_type__handle_nested_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1109 => wire__crate__api__uuid_type__handle_uuid_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1110 => wire__crate__api__uuid_type__handle_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), +59 => wire__crate__api__dart_opaque__async_accept_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +74 => wire__crate__api__dart_opaque__clone_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +70 => wire__crate__api__dart_opaque__create_enum_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +68 => wire__crate__api__dart_opaque__create_nested_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +73 => wire__crate__api__dart_opaque__drop_static_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +71 => wire__crate__api__dart_opaque__get_enum_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +69 => wire__crate__api__dart_opaque__get_nested_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +65 => wire__crate__api__dart_opaque__loop_back_array_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), +62 => wire__crate__api__dart_opaque__loop_back_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), +64 => wire__crate__api__dart_opaque__loop_back_option_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), +61 => wire__crate__api__dart_opaque__loop_back_option_twin_normal_impl(port, ptr, rust_vec_len, data_len), +60 => wire__crate__api__dart_opaque__loop_back_twin_normal_impl(port, ptr, rust_vec_len, data_len), +66 => wire__crate__api__dart_opaque__loop_back_vec_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), +63 => wire__crate__api__dart_opaque__loop_back_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), +67 => wire__crate__api__dart_opaque__panic_unwrap_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +72 => wire__crate__api__dart_opaque__set_static_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +80 => wire__crate__api__deliberate_name_conflict__test_duplicated_module_names_impl(port, ptr, rust_vec_len, data_len), +83 => wire__crate__api__dropping__DroppableTwinNormal_create_stream_impl(port, ptr, rust_vec_len, data_len), +84 => wire__crate__api__dropping__DroppableTwinNormal_get_drop_count_twin_normal_impl(port, ptr, rust_vec_len, data_len), +81 => wire__crate__api__dropping__DroppableTwinNormal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), +82 => wire__crate__api__dropping__DroppableTwinNormal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +85 => wire__crate__api__enumeration__func_enum_simple_twin_normal_impl(port, ptr, rust_vec_len, data_len), +89 => wire__crate__api__enumeration__func_enum_with_discriminant_twin_normal_impl(port, ptr, rust_vec_len, data_len), +86 => wire__crate__api__enumeration__func_enum_with_item_mixed_twin_normal_impl(port, ptr, rust_vec_len, data_len), +88 => wire__crate__api__enumeration__func_enum_with_item_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +87 => wire__crate__api__enumeration__func_enum_with_item_tuple_twin_normal_impl(port, ptr, rust_vec_len, data_len), +92 => wire__crate__api__enumeration__handle_enum_parameter_twin_normal_impl(port, ptr, rust_vec_len, data_len), +94 => wire__crate__api__enumeration__handle_enum_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +91 => wire__crate__api__enumeration__handle_return_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +93 => wire__crate__api__enumeration__multiply_by_ten_twin_normal_impl(port, ptr, rust_vec_len, data_len), +90 => wire__crate__api__enumeration__print_note_twin_normal_impl(port, ptr, rust_vec_len, data_len), +96 => wire__crate__api__event_listener__close_event_listener_twin_normal_impl(port, ptr, rust_vec_len, data_len), +97 => wire__crate__api__event_listener__create_event_twin_normal_impl(port, ptr, rust_vec_len, data_len), +99 => wire__crate__api__event_listener__event_twin_normal_as_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +95 => wire__crate__api__event_listener__register_event_listener_twin_normal_impl(port, ptr, rust_vec_len, data_len), +104 => wire__crate__api__exception__custom_enum_error_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +105 => wire__crate__api__exception__custom_enum_error_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +103 => wire__crate__api__exception__custom_enum_error_return_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), +106 => wire__crate__api__exception__custom_nested_error_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +107 => wire__crate__api__exception__custom_struct_error_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +124 => wire__crate__api__exception__custom_struct_twin_normal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), +127 => wire__crate__api__exception__custom_struct_twin_normal_nonstatic_return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +128 => wire__crate__api__exception__custom_struct_twin_normal_nonstatic_return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), +125 => wire__crate__api__exception__custom_struct_twin_normal_static_return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +126 => wire__crate__api__exception__custom_struct_twin_normal_static_return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), +100 => wire__crate__api__exception__func_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +101 => wire__crate__api__exception__func_type_fallible_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +102 => wire__crate__api__exception__func_type_infallible_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +117 => wire__crate__api__exception__panic_with_custom_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), +111 => wire__crate__api__exception__return_custom_nested_error_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), +112 => wire__crate__api__exception__return_custom_nested_error_1_variant1_twin_normal_impl(port, ptr, rust_vec_len, data_len), +113 => wire__crate__api__exception__return_custom_nested_error_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), +114 => wire__crate__api__exception__return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +115 => wire__crate__api__exception__return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), +108 => wire__crate__api__exception__return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +110 => wire__crate__api__exception__return_error_variant_twin_normal_impl(port, ptr, rust_vec_len, data_len), +109 => wire__crate__api__exception__return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +119 => wire__crate__api__exception__some_struct_twin_normal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), +122 => wire__crate__api__exception__some_struct_twin_normal_non_static_return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +123 => wire__crate__api__exception__some_struct_twin_normal_non_static_return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +120 => wire__crate__api__exception__some_struct_twin_normal_static_return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +121 => wire__crate__api__exception__some_struct_twin_normal_static_return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +118 => wire__crate__api__exception__stream_sink_throw_anyhow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +116 => wire__crate__api__exception__throw_anyhow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +131 => wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method_impl(port, ptr, rust_vec_len, data_len), +129 => wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method_impl(port, ptr, rust_vec_len, data_len), +135 => wire__crate__api__external_type_in_crate__call_new_module_system_twin_normal_impl(port, ptr, rust_vec_len, data_len), +134 => wire__crate__api__external_type_in_crate__call_old_module_system_twin_normal_impl(port, ptr, rust_vec_len, data_len), +133 => wire__crate__api__external_type_in_crate__use_imported_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +132 => wire__crate__api__external_type_in_crate__use_imported_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +137 => wire__crate__api__inside_macro__another_macro_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +136 => wire__crate__api__inside_macro__func_macro_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +138 => wire__crate__api__map_and_set__func_hash_map_i32_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +142 => wire__crate__api__map_and_set__func_hash_map_string_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +145 => wire__crate__api__map_and_set__func_hash_map_string_complex_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +144 => wire__crate__api__map_and_set__func_hash_map_string_simple_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +140 => wire__crate__api__map_and_set__func_hash_map_string_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +143 => wire__crate__api__map_and_set__func_hash_map_string_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +139 => wire__crate__api__map_and_set__func_hash_set_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +141 => wire__crate__api__map_and_set__func_hash_set_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +167 => wire__crate__api__method__StaticGetterOnlyTwinNormal_static_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), +150 => wire__crate__api__method__concatenate_with_twin_normal_concatenate_static_twin_normal_impl(port, ptr, rust_vec_len, data_len), +149 => wire__crate__api__method__concatenate_with_twin_normal_concatenate_twin_normal_impl(port, ptr, rust_vec_len, data_len), +155 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_static_stream_sink_single_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +154 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_static_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), +153 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_stream_sink_at_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), +152 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), +148 => wire__crate__api__method__concatenate_with_twin_normal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), +151 => wire__crate__api__method__concatenate_with_twin_normal_simple_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), +147 => wire__crate__api__method__get_sum_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), +146 => wire__crate__api__method__get_sum_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +157 => wire__crate__api__method__my_callable_twin_normal_call_impl(port, ptr, rust_vec_len, data_len), +163 => wire__crate__api__method__simple_enum_twin_normal_return_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), +164 => wire__crate__api__method__simple_enum_twin_normal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +165 => wire__crate__api__method__simple_primitive_enum_twin_normal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +161 => wire__crate__api__method__simple_struct_twin_normal_arg_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), +159 => wire__crate__api__method__simple_struct_twin_normal_receiver_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +160 => wire__crate__api__method__simple_struct_twin_normal_receiver_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +158 => wire__crate__api__method__simple_struct_twin_normal_return_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), +162 => wire__crate__api__method__simple_struct_twin_normal_vec_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), +166 => wire__crate__api__method__static_only_twin_normal_static_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +156 => wire__crate__api__method__sum_with_twin_normal_sum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +171 => wire__crate__api__mirror__app_settings_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +172 => wire__crate__api__mirror__app_settings_vec_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +178 => wire__crate__api__mirror__first_number_twin_normal_impl(port, ptr, rust_vec_len, data_len), +179 => wire__crate__api__mirror__first_sequence_twin_normal_impl(port, ptr, rust_vec_len, data_len), +168 => wire__crate__api__mirror__get_app_settings_twin_normal_impl(port, ptr, rust_vec_len, data_len), +169 => wire__crate__api__mirror__get_fallible_app_settings_twin_normal_impl(port, ptr, rust_vec_len, data_len), +175 => wire__crate__api__mirror__get_message_twin_normal_impl(port, ptr, rust_vec_len, data_len), +170 => wire__crate__api__mirror__is_app_embedded_twin_normal_impl(port, ptr, rust_vec_len, data_len), +193 => wire__crate__api__mirror__mirror_array_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +188 => wire__crate__api__mirror__mirror_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +191 => wire__crate__api__mirror__mirror_map_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +189 => wire__crate__api__mirror__mirror_option_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +192 => wire__crate__api__mirror__mirror_set_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +173 => wire__crate__api__mirror__mirror_struct_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +174 => wire__crate__api__mirror__mirror_tuple_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +190 => wire__crate__api__mirror__mirror_vec_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +176 => wire__crate__api__mirror__repeat_number_twin_normal_impl(port, ptr, rust_vec_len, data_len), +177 => wire__crate__api__mirror__repeat_sequence_twin_normal_impl(port, ptr, rust_vec_len, data_len), +186 => wire__crate__api__mirror__test_contains_mirrored_sub_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +184 => wire__crate__api__mirror__test_fallible_of_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +187 => wire__crate__api__mirror__test_hashmap_with_mirrored_value_twin_normal_impl(port, ptr, rust_vec_len, data_len), +185 => wire__crate__api__mirror__test_list_of_nested_enums_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +183 => wire__crate__api__mirror__test_list_of_raw_nested_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +181 => wire__crate__api__mirror__test_nested_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +182 => wire__crate__api__mirror__test_raw_string_enum_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +180 => wire__crate__api__mirror__test_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +197 => wire__crate__api__misc_example__handle_big_buffers_twin_normal_impl(port, ptr, rust_vec_len, data_len), +194 => wire__crate__api__misc_example__handle_complex_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +196 => wire__crate__api__misc_example__handle_nested_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +200 => wire__crate__api__misc_example__handle_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +202 => wire__crate__api__misc_example__handle_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +201 => wire__crate__api__misc_example__handle_vec_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +195 => wire__crate__api__misc_example__list_of_primitive_enums_twin_normal_impl(port, ptr, rust_vec_len, data_len), +198 => wire__crate__api__misc_example__test_abc_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +199 => wire__crate__api__misc_example__test_struct_with_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +204 => wire__crate__api__misc_no_twin_example_a__StructInMiscNoTwinExampleA_sample_function_a_impl(port, ptr, rust_vec_len, data_len), +205 => wire__crate__api__misc_no_twin_example_a__StructWithImplBlockInMultiFile_method_in_a_impl(port, ptr, rust_vec_len, data_len), +203 => wire__crate__api__misc_no_twin_example_a__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), +210 => wire__crate__api__misc_no_twin_example_a__struct_with_impl_block_in_another_file_f_impl(port, ptr, rust_vec_len, data_len), +207 => wire__crate__api__misc_no_twin_example_b__StructInMiscNoTwinExampleB_get_struct_in_misc_no_twin_example_a_impl(port, ptr, rust_vec_len, data_len), +208 => wire__crate__api__misc_no_twin_example_b__StructInMiscNoTwinExampleB_sample_function_b_impl(port, ptr, rust_vec_len, data_len), +209 => wire__crate__api__misc_no_twin_example_b__StructWithImplBlockInMultiFile_method_in_b_impl(port, ptr, rust_vec_len, data_len), +206 => wire__crate__api__misc_no_twin_example_b__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), +214 => wire__crate__api__misc_type__empty_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +211 => wire__crate__api__misc_type__func_return_unit_twin_normal_impl(port, ptr, rust_vec_len, data_len), +212 => wire__crate__api__misc_type__handle_list_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +213 => wire__crate__api__misc_type__handle_string_list_twin_normal_impl(port, ptr, rust_vec_len, data_len), +215 => wire__crate__api__newtype_pattern__handle_newtype_twin_normal_impl(port, ptr, rust_vec_len, data_len), +219 => wire__crate__api__optional__handle_increment_boxed_optional_twin_normal_impl(port, ptr, rust_vec_len, data_len), +221 => wire__crate__api__optional__handle_option_box_arguments_twin_normal_impl(port, ptr, rust_vec_len, data_len), +218 => wire__crate__api__optional__handle_optional_increment_twin_normal_impl(port, ptr, rust_vec_len, data_len), +216 => wire__crate__api__optional__handle_optional_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +217 => wire__crate__api__optional__handle_optional_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +220 => wire__crate__api__optional__handle_vec_of_opts_twin_normal_impl(port, ptr, rust_vec_len, data_len), +222 => wire__crate__api__optional_primitive_misc__primitive_optional_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), +225 => wire__crate__api__ownership__borrow_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +224 => wire__crate__api__ownership__borrow_str_twin_normal_impl(port, ptr, rust_vec_len, data_len), +223 => wire__crate__api__ownership__borrow_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +226 => wire__crate__api__ownership__borrow_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +227 => wire__crate__api__primitive_list_misc__handle_vec_of_primitive_twin_normal_impl(port, ptr, rust_vec_len, data_len), +228 => wire__crate__api__primitive_misc__primitive_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), +229 => wire__crate__api__primitive_misc__primitive_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +234 => wire__crate__api__pseudo_manual__array_twin_rust_async__boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +238 => wire__crate__api__pseudo_manual__array_twin_rust_async__func_test_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +230 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +231 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_complex_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +239 => wire__crate__api__pseudo_manual__array_twin_rust_async__last_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +240 => wire__crate__api__pseudo_manual__array_twin_rust_async__nested_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +232 => wire__crate__api__pseudo_manual__array_twin_rust_async__new_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +236 => wire__crate__api__pseudo_manual__array_twin_rust_async__return_boxed_feed_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +237 => wire__crate__api__pseudo_manual__array_twin_rust_async__return_boxed_raw_feed_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +235 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +233 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +253 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__handle_customized_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +254 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__next_user_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +278 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +277 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +279 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +274 => wire__crate__api__pseudo_manual__basic__example_basic_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +276 => wire__crate__api__pseudo_manual__basic__example_basic_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +272 => wire__crate__api__pseudo_manual__basic__example_basic_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +273 => wire__crate__api__pseudo_manual__basic__example_basic_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +263 => wire__crate__api__pseudo_manual__basic__example_basic_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +264 => wire__crate__api__pseudo_manual__basic__example_basic_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +265 => wire__crate__api__pseudo_manual__basic__example_basic_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +262 => wire__crate__api__pseudo_manual__basic__example_basic_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +270 => wire__crate__api__pseudo_manual__basic__example_basic_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +275 => wire__crate__api__pseudo_manual__basic__example_basic_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +267 => wire__crate__api__pseudo_manual__basic__example_basic_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +268 => wire__crate__api__pseudo_manual__basic__example_basic_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +269 => wire__crate__api__pseudo_manual__basic__example_basic_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +266 => wire__crate__api__pseudo_manual__basic__example_basic_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +271 => wire__crate__api__pseudo_manual__basic__example_basic_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +294 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +293 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +295 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +290 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +292 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +288 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +289 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +281 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +282 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +283 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +280 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +291 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +285 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +286 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +287 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +284 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +310 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +309 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +311 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +306 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +308 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +304 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +305 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +297 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +298 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +299 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +296 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +307 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +301 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +302 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +303 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +300 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +344 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +343 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +345 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +340 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +342 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +338 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +339 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +329 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +330 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +331 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +328 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +336 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +341 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +333 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +334 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +335 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +332 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +337 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +362 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +361 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +363 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +358 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +360 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +356 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +357 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +347 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +348 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +349 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +346 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +354 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +359 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +351 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +352 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +353 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +350 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +355 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +398 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +397 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +399 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +394 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +396 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +392 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +393 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +383 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +384 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +385 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +382 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +390 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +395 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +387 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +388 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +389 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +386 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +391 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +416 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +415 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +417 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +412 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +414 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +410 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +411 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +401 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +402 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +403 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +400 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +408 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +413 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +405 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +406 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +407 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +404 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +409 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +452 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +451 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +453 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +448 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +450 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +446 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +447 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +437 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +438 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +439 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +436 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +444 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +449 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +441 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +442 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +443 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +440 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +445 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +479 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +477 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +475 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), +480 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +478 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +476 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), +485 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +483 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +481 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), +486 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +484 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +482 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), +473 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_input_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +474 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_output_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +472 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_void_twin_normal_impl(port, ptr, rust_vec_len, data_len), +494 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +492 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +490 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +495 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +493 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +491 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +500 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +498 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +496 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +501 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +499 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +497 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +488 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_input_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +489 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_output_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +487 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_void_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +518 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_local_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +517 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_utc_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +521 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__duration_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +523 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_durations_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +522 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_timestamps_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +526 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__how_long_does_it_take_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +519 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__naivedatetime_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +520 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__optional_empty_datetime_utc_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +524 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +525 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_precise_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +539 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_slash_star_star_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +538 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_triple_slash_multi_line_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +537 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_triple_slash_single_line_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +541 => wire__crate__api__pseudo_manual__comment_twin_rust_async__struct_with_comments_twin_rust_async_instance_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +540 => wire__crate__api__pseudo_manual__comment_twin_rust_async__struct_with_comments_twin_rust_async_static_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +551 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_loopback_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +554 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_multi_times_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +548 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +555 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +550 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +547 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_simple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +549 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_two_args_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +552 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with_dart_opaque_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +553 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with_dart_opaque_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +556 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__async_accept_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +571 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__clone_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +567 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__create_enum_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +565 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__create_nested_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +570 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__drop_static_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +568 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__get_enum_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +566 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__get_nested_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +562 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_array_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +559 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +561 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_option_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +558 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_option_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +557 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +563 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_vec_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +560 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +564 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__panic_unwrap_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +569 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__set_static_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +590 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_create_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +591 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_get_drop_count_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +588 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +589 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +596 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_simple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +600 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_discriminant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +597 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_mixed_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +599 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +598 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_tuple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +603 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_parameter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +605 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +602 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_return_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +604 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__multiply_by_ten_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +601 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__print_note_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +617 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__close_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +618 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__create_event_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +619 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__event_twin_rust_async_as_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +616 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__register_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +624 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +625 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +623 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_return_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +626 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_nested_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +627 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +644 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +647 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_nonstatic_return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +648 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_nonstatic_return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +645 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_static_return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +646 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_static_return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +620 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +621 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_fallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +622 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_infallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +637 => wire__crate__api__pseudo_manual__exception_twin_rust_async__panic_with_custom_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +631 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +632 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_1_variant1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +633 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +634 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +635 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +628 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +630 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_error_variant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +629 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +639 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +642 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_non_static_return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +643 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_non_static_return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +640 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_static_return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +641 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_static_return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +638 => wire__crate__api__pseudo_manual__exception_twin_rust_async__stream_sink_throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +636 => wire__crate__api__pseudo_manual__exception_twin_rust_async__throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +681 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__call_new_module_system_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +680 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__call_old_module_system_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +679 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__use_imported_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +678 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__use_imported_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +686 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_i32_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +690 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +693 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_complex_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +692 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_simple_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +688 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +691 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +687 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_set_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +689 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_set_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +723 => wire__crate__api__pseudo_manual__method_twin_rust_async__StaticGetterOnlyTwinRustAsync_static_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +706 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_concatenate_static_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +705 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_concatenate_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +711 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_static_stream_sink_single_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +710 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_static_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +709 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_stream_sink_at_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +708 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +704 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +707 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_simple_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +703 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +702 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +713 => wire__crate__api__pseudo_manual__method_twin_rust_async__my_callable_twin_rust_async_call_impl(port, ptr, rust_vec_len, data_len), +719 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_enum_twin_rust_async_return_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +720 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_enum_twin_rust_async_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +721 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_primitive_enum_twin_rust_async_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +717 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_arg_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +715 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_receiver_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +716 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_receiver_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +714 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_return_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +718 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_vec_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +722 => wire__crate__api__pseudo_manual__method_twin_rust_async__static_only_twin_rust_async_static_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +712 => wire__crate__api__pseudo_manual__method_twin_rust_async__sum_with_twin_rust_async_sum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +749 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +750 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_vec_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +756 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +757 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +746 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +747 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_fallible_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +753 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_message_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +748 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__is_app_embedded_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +771 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_array_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +766 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +769 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_map_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +767 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_option_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +770 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_set_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +751 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_struct_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +752 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_tuple_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +768 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_vec_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +754 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +755 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +764 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_contains_mirrored_sub_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +762 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_fallible_of_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +765 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_hashmap_with_mirrored_value_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +763 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_list_of_nested_enums_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +761 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_list_of_raw_nested_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +759 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_nested_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +760 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_raw_string_enum_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +758 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +801 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_big_buffers_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +798 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_complex_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +800 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_nested_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +804 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +806 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +805 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_vec_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +799 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__list_of_primitive_enums_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +802 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__test_abc_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +803 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__test_struct_with_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +819 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__empty_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +816 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__func_return_unit_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +817 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__handle_list_of_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +818 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__handle_string_list_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +824 => wire__crate__api__pseudo_manual__newtype_pattern_twin_rust_async__handle_newtype_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +826 => wire__crate__api__pseudo_manual__optional_primitive_misc_twin_rust_async__primitive_optional_types_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +831 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_increment_boxed_optional_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +833 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_option_box_arguments_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +830 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_increment_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +828 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +829 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +832 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_vec_of_opts_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +842 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +841 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_str_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +840 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +843 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +848 => wire__crate__api__pseudo_manual__primitive_list_misc_twin_rust_async__handle_vec_of_primitive_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +850 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_types_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +851 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +855 => wire__crate__api__pseudo_manual__raw_string_twin_rust_async__test_more_than_just_one_raw_string_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +854 => wire__crate__api__pseudo_manual__raw_string_twin_rust_async__test_raw_string_item_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +901 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +902 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +900 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +904 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +903 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +898 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_custom_name_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +897 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +899 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_with_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +894 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +895 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +893 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +896 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +859 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +860 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +862 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_own_and_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +858 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +883 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_vec_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +892 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_borrow_and_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +891 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_borrow_and_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +867 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_callable_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +868 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_callable_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +879 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_dummy_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +880 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +881 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +876 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +877 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +878 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +885 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +887 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +886 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +864 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_normal_and_opaque_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +865 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_plus_sign_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +866 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_plus_sign_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +889 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_opaque_one_and_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +890 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_opaque_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +861 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +884 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_vec_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +888 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_sleep_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +882 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +874 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +875 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +870 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +871 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +869 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +872 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_return_own_one_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +873 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_return_own_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +863 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_two_args_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +954 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_array_opaque_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +963 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +952 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +953 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_option_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +966 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__frb_generator_test_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +960 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +958 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +962 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +961 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +955 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_enum_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +964 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +959 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_non_clone_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +956 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +957 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_opaque_with_delay_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +965 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__unwrap_rust_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +982 => wire__crate__api__pseudo_manual__simple_twin_rust_async__simple_adder_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +984 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +985 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +986 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_sink_arg_position_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +987 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_of_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +988 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +989 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +990 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_3_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +991 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_fixed_sized_primitive_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +993 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +992 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +995 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +996 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_two_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +994 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_zero_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +997 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_one_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +998 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_two_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1005 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1004 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1008 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_alias_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1010 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_alias_model_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1009 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_nest_alias_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1016 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_nested_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1014 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1015 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1021 => wire__crate__api__raw_string__test_more_than_just_one_raw_string_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1020 => wire__crate__api__raw_string__test_raw_string_item_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1065 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1066 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1064 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1068 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1067 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1062 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_custom_name_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1061 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1063 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_with_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1058 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1059 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1057 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1060 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1023 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1024 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1026 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_and_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1022 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1047 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1056 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1055 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1031 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1032 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1043 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_dummy_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1044 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1045 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1040 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1041 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1042 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1049 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1051 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1050 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1028 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_normal_and_opaque_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1029 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1030 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1053 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_one_and_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1054 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1025 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1048 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1052 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_sleep_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1046 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1038 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1039 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1034 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1035 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1033 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1036 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_return_own_one_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1037 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_return_own_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1027 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_two_args_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1071 => wire__crate__api__rust_opaque__create_array_opaque_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1080 => wire__crate__api__rust_opaque__create_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1069 => wire__crate__api__rust_opaque__create_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1070 => wire__crate__api__rust_opaque__create_option_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1083 => wire__crate__api__rust_opaque__frb_generator_test_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1077 => wire__crate__api__rust_opaque__opaque_array_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1075 => wire__crate__api__rust_opaque__opaque_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1079 => wire__crate__api__rust_opaque__opaque_vec_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1078 => wire__crate__api__rust_opaque__opaque_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1072 => wire__crate__api__rust_opaque__run_enum_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1081 => wire__crate__api__rust_opaque__run_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1076 => wire__crate__api__rust_opaque__run_non_clone_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1073 => wire__crate__api__rust_opaque__run_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1074 => wire__crate__api__rust_opaque__run_opaque_with_delay_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1082 => wire__crate__api__rust_opaque__unwrap_rust_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1088 => wire__crate__api__simple__simple_adder_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1089 => wire__crate__api__stream__func_stream_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1090 => wire__crate__api__stream__func_stream_return_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1091 => wire__crate__api__stream__func_stream_sink_arg_position_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1092 => wire__crate__api__stream__handle_stream_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1093 => wire__crate__api__stream__handle_stream_sink_at_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1094 => wire__crate__api__stream__handle_stream_sink_at_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1095 => wire__crate__api__stream__handle_stream_sink_at_3_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1096 => wire__crate__api__stream__stream_sink_fixed_sized_primitive_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1098 => wire__crate__api__stream__stream_sink_inside_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1097 => wire__crate__api__stream__stream_sink_inside_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1099 => wire__crate__api__stream_misc__func_stream_realistic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1100 => wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1102 => wire__crate__api__structure__func_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1103 => wire__crate__api__structure__func_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1101 => wire__crate__api__structure__func_struct_with_zero_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1104 => wire__crate__api__structure__func_tuple_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1105 => wire__crate__api__structure__func_tuple_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1107 => wire__crate__api__tuple__test_tuple_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1106 => wire__crate__api__tuple__test_tuple_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1108 => wire__crate__api__type_alias__handle_type_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1110 => wire__crate__api__type_alias__handle_type_alias_model_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1109 => wire__crate__api__type_alias__handle_type_nest_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1113 => wire__crate__api__uuid_type__handle_nested_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1111 => wire__crate__api__uuid_type__handle_uuid_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1112 => wire__crate__api__uuid_type__handle_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), _ => unreachable!(), } } @@ -35278,355 +35465,355 @@ fn pde_ffi_dispatcher_sync_impl( 43 => wire__crate__api__constructor__ConstructorOpaqueSyncStructTwinNormal_check_impl(ptr, rust_vec_len, data_len), 42 => wire__crate__api__constructor__ConstructorOpaqueSyncStructTwinNormal_new_impl(ptr, rust_vec_len, data_len), 41 => wire__crate__api__constructor__constructor_translatable_sync_struct_twin_normal_new_impl(ptr, rust_vec_len, data_len), -76 => wire__crate__api__dart_opaque_sync__sync_accept_dart_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), -74 => wire__crate__api__dart_opaque_sync__sync_loopback_twin_normal_impl(ptr, rust_vec_len, data_len), -78 => wire__crate__api__dart_opaque_sync__sync_option_dart_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), -75 => wire__crate__api__dart_opaque_sync__sync_option_loopback_twin_normal_impl(ptr, rust_vec_len, data_len), -77 => wire__crate__api__dart_opaque_sync__unwrap_dart_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), -97 => wire__crate__api__event_listener__create_event_sync_twin_normal_impl(ptr, rust_vec_len, data_len), -129 => wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new_impl(ptr, rust_vec_len, data_len), -244 => wire__crate__api__pseudo_manual__array_twin_sync__boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), -248 => wire__crate__api__pseudo_manual__array_twin_sync__func_test_id_twin_sync_impl(ptr, rust_vec_len, data_len), -240 => wire__crate__api__pseudo_manual__array_twin_sync__get_array_twin_sync_impl(ptr, rust_vec_len, data_len), -241 => wire__crate__api__pseudo_manual__array_twin_sync__get_complex_array_twin_sync_impl(ptr, rust_vec_len, data_len), -249 => wire__crate__api__pseudo_manual__array_twin_sync__last_number_twin_sync_impl(ptr, rust_vec_len, data_len), -250 => wire__crate__api__pseudo_manual__array_twin_sync__nested_id_twin_sync_impl(ptr, rust_vec_len, data_len), -242 => wire__crate__api__pseudo_manual__array_twin_sync__new_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), -246 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), -247 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_raw_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), -245 => wire__crate__api__pseudo_manual__array_twin_sync__use_boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), -243 => wire__crate__api__pseudo_manual__array_twin_sync__use_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), -257 => wire__crate__api__pseudo_manual__attribute_twin_sync__handle_customized_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -258 => wire__crate__api__pseudo_manual__attribute_twin_sync__next_user_id_twin_sync_impl(ptr, rust_vec_len, data_len), -325 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -324 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -326 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -321 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -323 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -319 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -320 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -312 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -313 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -314 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -311 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -322 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -316 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -317 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -318 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -315 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -379 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -378 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -380 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -375 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -377 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -373 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -374 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -364 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -365 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -366 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -363 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -371 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), -376 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -368 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -369 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -370 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -367 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -372 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), -433 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -432 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -434 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -429 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -431 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -427 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -428 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -418 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -419 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -420 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -417 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -425 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), -430 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -422 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -423 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -424 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -421 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -426 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), -469 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -468 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -470 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -465 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -467 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -463 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -464 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -454 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -455 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -456 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -453 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -461 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), -466 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -458 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -459 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -460 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -457 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -462 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), -508 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), -506 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -504 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_twin_sync_impl(ptr, rust_vec_len, data_len), -509 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), -507 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -505 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_twin_sync_impl(ptr, rust_vec_len, data_len), -514 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), -512 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -510 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_twin_sync_impl(ptr, rust_vec_len, data_len), -515 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), -513 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -511 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_twin_sync_impl(ptr, rust_vec_len, data_len), -502 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_input_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -503 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_output_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -501 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_void_twin_sync_impl(ptr, rust_vec_len, data_len), -527 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_local_twin_sync_impl(ptr, rust_vec_len, data_len), -526 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), -530 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__duration_twin_sync_impl(ptr, rust_vec_len, data_len), -532 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_durations_twin_sync_impl(ptr, rust_vec_len, data_len), -531 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_timestamps_twin_sync_impl(ptr, rust_vec_len, data_len), -535 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__how_long_does_it_take_twin_sync_impl(ptr, rust_vec_len, data_len), -528 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__naivedatetime_twin_sync_impl(ptr, rust_vec_len, data_len), -529 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__optional_empty_datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), -533 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), -534 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_precise_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), -543 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_slash_star_star_twin_sync_impl(ptr, rust_vec_len, data_len), -542 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_multi_line_twin_sync_impl(ptr, rust_vec_len, data_len), -541 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_single_line_twin_sync_impl(ptr, rust_vec_len, data_len), -545 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_instance_method_twin_sync_impl(ptr, rust_vec_len, data_len), -544 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), -570 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__async_accept_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -585 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__clone_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -581 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -579 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -584 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__drop_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -582 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -580 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -576 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_get_twin_sync_impl(ptr, rust_vec_len, data_len), -573 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_twin_sync_impl(ptr, rust_vec_len, data_len), -575 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_get_twin_sync_impl(ptr, rust_vec_len, data_len), -572 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_twin_sync_impl(ptr, rust_vec_len, data_len), -571 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_twin_sync_impl(ptr, rust_vec_len, data_len), -577 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_get_twin_sync_impl(ptr, rust_vec_len, data_len), -574 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_twin_sync_impl(ptr, rust_vec_len, data_len), -578 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__panic_unwrap_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -583 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__set_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -592 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_create_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -593 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_get_drop_count_twin_sync_impl(ptr, rust_vec_len, data_len), -590 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -591 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), -604 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_simple_twin_sync_impl(ptr, rust_vec_len, data_len), -608 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_discriminant_twin_sync_impl(ptr, rust_vec_len, data_len), -605 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_mixed_twin_sync_impl(ptr, rust_vec_len, data_len), -607 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -606 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), -611 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_parameter_twin_sync_impl(ptr, rust_vec_len, data_len), -613 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -610 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_return_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -612 => wire__crate__api__pseudo_manual__enumeration_twin_sync__multiply_by_ten_twin_sync_impl(ptr, rust_vec_len, data_len), -609 => wire__crate__api__pseudo_manual__enumeration_twin_sync__print_note_twin_sync_impl(ptr, rust_vec_len, data_len), -651 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_panic_twin_sync_impl(ptr, rust_vec_len, data_len), -652 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -650 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_ok_twin_sync_impl(ptr, rust_vec_len, data_len), -653 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_nested_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -654 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -671 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -674 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_nonstatic_return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), -675 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_nonstatic_return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), -672 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_static_return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), -673 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_static_return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), -647 => wire__crate__api__pseudo_manual__exception_twin_sync__func_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -648 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_fallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), -649 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_infallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), -664 => wire__crate__api__pseudo_manual__exception_twin_sync__panic_with_custom_result_twin_sync_impl(ptr, rust_vec_len, data_len), -658 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_twin_sync_impl(ptr, rust_vec_len, data_len), -659 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_variant1_twin_sync_impl(ptr, rust_vec_len, data_len), -660 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_2_twin_sync_impl(ptr, rust_vec_len, data_len), -661 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), -662 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), -655 => wire__crate__api__pseudo_manual__exception_twin_sync__return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -657 => wire__crate__api__pseudo_manual__exception_twin_sync__return_error_variant_twin_sync_impl(ptr, rust_vec_len, data_len), -656 => wire__crate__api__pseudo_manual__exception_twin_sync__return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -666 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -669 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_non_static_return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -670 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_non_static_return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -667 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_static_return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -668 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_static_return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -665 => wire__crate__api__pseudo_manual__exception_twin_sync__stream_sink_throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), -663 => wire__crate__api__pseudo_manual__exception_twin_sync__throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), -683 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_new_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), -682 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_old_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), -681 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -680 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -692 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_i32_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -696 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -699 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_complex_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -698 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_simple_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -694 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_string_twin_sync_impl(ptr, rust_vec_len, data_len), -697 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -693 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -695 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_string_twin_sync_impl(ptr, rust_vec_len, data_len), -743 => wire__crate__api__pseudo_manual__method_twin_sync__StaticGetterOnlyTwinSync_static_getter_twin_sync_impl(ptr, rust_vec_len, data_len), -726 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_static_twin_sync_impl(ptr, rust_vec_len, data_len), -725 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_twin_sync_impl(ptr, rust_vec_len, data_len), -731 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_static_stream_sink_single_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -730 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_static_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), -729 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_stream_sink_at_1_twin_sync_impl(ptr, rust_vec_len, data_len), -728 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), -724 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -727 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_simple_getter_twin_sync_impl(ptr, rust_vec_len, data_len), -723 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_array_twin_sync_impl(ptr, rust_vec_len, data_len), -722 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -733 => wire__crate__api__pseudo_manual__method_twin_sync__my_callable_twin_sync_call_impl(ptr, rust_vec_len, data_len), -739 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), -740 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), -741 => wire__crate__api__pseudo_manual__method_twin_sync__simple_primitive_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), -737 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_arg_self_twin_sync_impl(ptr, rust_vec_len, data_len), -735 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -736 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_own_twin_sync_impl(ptr, rust_vec_len, data_len), -734 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), -738 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_vec_self_twin_sync_impl(ptr, rust_vec_len, data_len), -742 => wire__crate__api__pseudo_manual__method_twin_sync__static_only_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), -732 => wire__crate__api__pseudo_manual__method_twin_sync__sum_with_twin_sync_sum_twin_sync_impl(ptr, rust_vec_len, data_len), -773 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -774 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_vec_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -780 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_number_twin_sync_impl(ptr, rust_vec_len, data_len), -781 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), -770 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), -771 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_fallible_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), -777 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_message_twin_sync_impl(ptr, rust_vec_len, data_len), -772 => wire__crate__api__pseudo_manual__mirror_twin_sync__is_app_embedded_twin_sync_impl(ptr, rust_vec_len, data_len), -795 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_array_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -790 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -793 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_map_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -791 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_option_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -794 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_set_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -775 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_struct_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -776 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_tuple_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -792 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_vec_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -778 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_number_twin_sync_impl(ptr, rust_vec_len, data_len), -779 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), -788 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_contains_mirrored_sub_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -786 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_fallible_of_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -789 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_hashmap_with_mirrored_value_twin_sync_impl(ptr, rust_vec_len, data_len), -787 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_nested_enums_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -785 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_raw_nested_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -783 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_nested_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -784 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_enum_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -782 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -808 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_big_buffers_twin_sync_impl(ptr, rust_vec_len, data_len), -805 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_complex_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -807 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_nested_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -811 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_string_twin_sync_impl(ptr, rust_vec_len, data_len), -813 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -812 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_vec_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -806 => wire__crate__api__pseudo_manual__misc_example_twin_sync__list_of_primitive_enums_twin_sync_impl(ptr, rust_vec_len, data_len), -809 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_abc_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -810 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_struct_with_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -821 => wire__crate__api__pseudo_manual__misc_type_twin_sync__empty_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -818 => wire__crate__api__pseudo_manual__misc_type_twin_sync__func_return_unit_twin_sync_impl(ptr, rust_vec_len, data_len), -819 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_list_of_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -820 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_string_list_twin_sync_impl(ptr, rust_vec_len, data_len), -823 => wire__crate__api__pseudo_manual__newtype_pattern_twin_sync__handle_newtype_twin_sync_impl(ptr, rust_vec_len, data_len), -825 => wire__crate__api__pseudo_manual__optional_primitive_misc_twin_sync__primitive_optional_types_twin_sync_impl(ptr, rust_vec_len, data_len), -835 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_increment_boxed_optional_twin_sync_impl(ptr, rust_vec_len, data_len), -837 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_option_box_arguments_twin_sync_impl(ptr, rust_vec_len, data_len), -834 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_increment_twin_sync_impl(ptr, rust_vec_len, data_len), -832 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_return_twin_sync_impl(ptr, rust_vec_len, data_len), -833 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -836 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_vec_of_opts_twin_sync_impl(ptr, rust_vec_len, data_len), -844 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -843 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_str_twin_sync_impl(ptr, rust_vec_len, data_len), -842 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_string_twin_sync_impl(ptr, rust_vec_len, data_len), -845 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -847 => wire__crate__api__pseudo_manual__primitive_list_misc_twin_sync__handle_vec_of_primitive_twin_sync_impl(ptr, rust_vec_len, data_len), -850 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_types_twin_sync_impl(ptr, rust_vec_len, data_len), -851 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -855 => wire__crate__api__pseudo_manual__raw_string_twin_sync__test_more_than_just_one_raw_string_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -854 => wire__crate__api__pseudo_manual__raw_string_twin_sync__test_raw_string_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -946 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -947 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -945 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -949 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_getter_twin_sync_impl(ptr, rust_vec_len, data_len), -948 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -943 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_custom_name_twin_sync_impl(ptr, rust_vec_len, data_len), -942 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -944 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_with_result_twin_sync_impl(ptr, rust_vec_len, data_len), -939 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -940 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -938 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -941 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -904 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -905 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -907 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_own_and_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -903 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -928 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_vec_own_twin_sync_impl(ptr, rust_vec_len, data_len), -937 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_borrow_and_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -936 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_borrow_and_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -912 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -913 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_return_twin_sync_impl(ptr, rust_vec_len, data_len), -924 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_dummy_twin_sync_impl(ptr, rust_vec_len, data_len), -925 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -926 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -921 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -922 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_sync_impl(ptr, rust_vec_len, data_len), -923 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -930 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -932 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_return_twin_sync_impl(ptr, rust_vec_len, data_len), -931 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -909 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_normal_and_opaque_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -910 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_plus_sign_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -911 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_plus_sign_return_twin_sync_impl(ptr, rust_vec_len, data_len), -934 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_opaque_one_and_two_twin_sync_impl(ptr, rust_vec_len, data_len), -935 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_opaque_two_twin_sync_impl(ptr, rust_vec_len, data_len), -906 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -929 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_vec_own_twin_sync_impl(ptr, rust_vec_len, data_len), -933 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_sleep_twin_sync_impl(ptr, rust_vec_len, data_len), -927 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), -919 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -920 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -915 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -916 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -914 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -917 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_return_own_one_twin_sync_impl(ptr, rust_vec_len, data_len), -918 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_return_own_two_twin_sync_impl(ptr, rust_vec_len, data_len), -908 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_two_args_twin_sync_impl(ptr, rust_vec_len, data_len), -967 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_array_opaque_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -976 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -965 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -966 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_option_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -979 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__frb_generator_test_twin_sync_impl(ptr, rust_vec_len, data_len), -973 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_run_twin_sync_impl(ptr, rust_vec_len, data_len), -971 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_twin_sync_impl(ptr, rust_vec_len, data_len), -975 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_run_twin_sync_impl(ptr, rust_vec_len, data_len), -974 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_twin_sync_impl(ptr, rust_vec_len, data_len), -968 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_enum_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -977 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -972 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_non_clone_twin_sync_impl(ptr, rust_vec_len, data_len), -969 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -970 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_with_delay_twin_sync_impl(ptr, rust_vec_len, data_len), -978 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__unwrap_rust_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -981 => wire__crate__api__pseudo_manual__simple_twin_sync__simple_adder_twin_sync_impl(ptr, rust_vec_len, data_len), -998 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), -999 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), -997 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_zero_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1000 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1001 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1005 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_2_twin_sync_impl(ptr, rust_vec_len, data_len), -1004 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), -1009 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), -1011 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_model_twin_sync_impl(ptr, rust_vec_len, data_len), -1010 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_nest_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), -1017 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_nested_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), -1015 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuid_twin_sync_impl(ptr, rust_vec_len, data_len), -1016 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), -1085 => wire__crate__api__rust_opaque_sync__frb_sync_generator_test_twin_normal_impl(ptr, rust_vec_len, data_len), -1084 => wire__crate__api__rust_opaque_sync__sync_create_non_clone_twin_normal_impl(ptr, rust_vec_len, data_len), -1083 => wire__crate__api__rust_opaque_sync__sync_create_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), -1082 => wire__crate__api__rust_opaque_sync__sync_option_rust_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +77 => wire__crate__api__dart_opaque_sync__sync_accept_dart_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +75 => wire__crate__api__dart_opaque_sync__sync_loopback_twin_normal_impl(ptr, rust_vec_len, data_len), +79 => wire__crate__api__dart_opaque_sync__sync_option_dart_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +76 => wire__crate__api__dart_opaque_sync__sync_option_loopback_twin_normal_impl(ptr, rust_vec_len, data_len), +78 => wire__crate__api__dart_opaque_sync__unwrap_dart_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +98 => wire__crate__api__event_listener__create_event_sync_twin_normal_impl(ptr, rust_vec_len, data_len), +130 => wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new_impl(ptr, rust_vec_len, data_len), +245 => wire__crate__api__pseudo_manual__array_twin_sync__boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), +249 => wire__crate__api__pseudo_manual__array_twin_sync__func_test_id_twin_sync_impl(ptr, rust_vec_len, data_len), +241 => wire__crate__api__pseudo_manual__array_twin_sync__get_array_twin_sync_impl(ptr, rust_vec_len, data_len), +242 => wire__crate__api__pseudo_manual__array_twin_sync__get_complex_array_twin_sync_impl(ptr, rust_vec_len, data_len), +250 => wire__crate__api__pseudo_manual__array_twin_sync__last_number_twin_sync_impl(ptr, rust_vec_len, data_len), +251 => wire__crate__api__pseudo_manual__array_twin_sync__nested_id_twin_sync_impl(ptr, rust_vec_len, data_len), +243 => wire__crate__api__pseudo_manual__array_twin_sync__new_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), +247 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), +248 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_raw_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), +246 => wire__crate__api__pseudo_manual__array_twin_sync__use_boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), +244 => wire__crate__api__pseudo_manual__array_twin_sync__use_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), +258 => wire__crate__api__pseudo_manual__attribute_twin_sync__handle_customized_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +259 => wire__crate__api__pseudo_manual__attribute_twin_sync__next_user_id_twin_sync_impl(ptr, rust_vec_len, data_len), +326 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +325 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +327 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +322 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +324 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +320 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +321 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +313 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +314 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +315 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +312 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +323 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +317 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +318 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +319 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +316 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +380 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +379 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +381 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +376 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +378 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +374 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +375 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +365 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +366 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +367 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +364 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +372 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), +377 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +369 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +370 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +371 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +368 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +373 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), +434 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +433 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +435 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +430 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +432 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +428 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +429 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +419 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +420 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +421 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +418 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +426 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), +431 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +423 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +424 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +425 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +422 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +427 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), +470 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +469 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +471 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +466 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +468 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +464 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +465 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +455 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +456 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +457 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +454 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +462 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), +467 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +459 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +460 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +461 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +458 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +463 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), +509 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), +507 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +505 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_twin_sync_impl(ptr, rust_vec_len, data_len), +510 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), +508 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +506 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_twin_sync_impl(ptr, rust_vec_len, data_len), +515 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), +513 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +511 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_twin_sync_impl(ptr, rust_vec_len, data_len), +516 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), +514 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +512 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_twin_sync_impl(ptr, rust_vec_len, data_len), +503 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_input_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +504 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_output_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +502 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_void_twin_sync_impl(ptr, rust_vec_len, data_len), +528 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_local_twin_sync_impl(ptr, rust_vec_len, data_len), +527 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), +531 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__duration_twin_sync_impl(ptr, rust_vec_len, data_len), +533 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_durations_twin_sync_impl(ptr, rust_vec_len, data_len), +532 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_timestamps_twin_sync_impl(ptr, rust_vec_len, data_len), +536 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__how_long_does_it_take_twin_sync_impl(ptr, rust_vec_len, data_len), +529 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__naivedatetime_twin_sync_impl(ptr, rust_vec_len, data_len), +530 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__optional_empty_datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), +534 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), +535 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_precise_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), +544 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_slash_star_star_twin_sync_impl(ptr, rust_vec_len, data_len), +543 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_multi_line_twin_sync_impl(ptr, rust_vec_len, data_len), +542 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_single_line_twin_sync_impl(ptr, rust_vec_len, data_len), +546 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_instance_method_twin_sync_impl(ptr, rust_vec_len, data_len), +545 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), +572 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__async_accept_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +587 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__clone_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +583 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +581 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +586 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__drop_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +584 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +582 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +578 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_get_twin_sync_impl(ptr, rust_vec_len, data_len), +575 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_twin_sync_impl(ptr, rust_vec_len, data_len), +577 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_get_twin_sync_impl(ptr, rust_vec_len, data_len), +574 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_twin_sync_impl(ptr, rust_vec_len, data_len), +573 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_twin_sync_impl(ptr, rust_vec_len, data_len), +579 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_get_twin_sync_impl(ptr, rust_vec_len, data_len), +576 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_twin_sync_impl(ptr, rust_vec_len, data_len), +580 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__panic_unwrap_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +585 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__set_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +594 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_create_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +595 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_get_drop_count_twin_sync_impl(ptr, rust_vec_len, data_len), +592 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +593 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), +606 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_simple_twin_sync_impl(ptr, rust_vec_len, data_len), +610 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_discriminant_twin_sync_impl(ptr, rust_vec_len, data_len), +607 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_mixed_twin_sync_impl(ptr, rust_vec_len, data_len), +609 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +608 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), +613 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_parameter_twin_sync_impl(ptr, rust_vec_len, data_len), +615 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +612 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_return_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +614 => wire__crate__api__pseudo_manual__enumeration_twin_sync__multiply_by_ten_twin_sync_impl(ptr, rust_vec_len, data_len), +611 => wire__crate__api__pseudo_manual__enumeration_twin_sync__print_note_twin_sync_impl(ptr, rust_vec_len, data_len), +653 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_panic_twin_sync_impl(ptr, rust_vec_len, data_len), +654 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +652 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_ok_twin_sync_impl(ptr, rust_vec_len, data_len), +655 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_nested_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +656 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +673 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +676 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_nonstatic_return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), +677 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_nonstatic_return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), +674 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_static_return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), +675 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_static_return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), +649 => wire__crate__api__pseudo_manual__exception_twin_sync__func_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +650 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_fallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), +651 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_infallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), +666 => wire__crate__api__pseudo_manual__exception_twin_sync__panic_with_custom_result_twin_sync_impl(ptr, rust_vec_len, data_len), +660 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_twin_sync_impl(ptr, rust_vec_len, data_len), +661 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_variant1_twin_sync_impl(ptr, rust_vec_len, data_len), +662 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_2_twin_sync_impl(ptr, rust_vec_len, data_len), +663 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), +664 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), +657 => wire__crate__api__pseudo_manual__exception_twin_sync__return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +659 => wire__crate__api__pseudo_manual__exception_twin_sync__return_error_variant_twin_sync_impl(ptr, rust_vec_len, data_len), +658 => wire__crate__api__pseudo_manual__exception_twin_sync__return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +668 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +671 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_non_static_return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +672 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_non_static_return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +669 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_static_return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +670 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_static_return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +667 => wire__crate__api__pseudo_manual__exception_twin_sync__stream_sink_throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), +665 => wire__crate__api__pseudo_manual__exception_twin_sync__throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), +685 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_new_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), +684 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_old_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), +683 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +682 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +694 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_i32_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +698 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +701 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_complex_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +700 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_simple_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +696 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_string_twin_sync_impl(ptr, rust_vec_len, data_len), +699 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +695 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +697 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_string_twin_sync_impl(ptr, rust_vec_len, data_len), +745 => wire__crate__api__pseudo_manual__method_twin_sync__StaticGetterOnlyTwinSync_static_getter_twin_sync_impl(ptr, rust_vec_len, data_len), +728 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_static_twin_sync_impl(ptr, rust_vec_len, data_len), +727 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_twin_sync_impl(ptr, rust_vec_len, data_len), +733 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_static_stream_sink_single_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +732 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_static_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), +731 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_stream_sink_at_1_twin_sync_impl(ptr, rust_vec_len, data_len), +730 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), +726 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +729 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_simple_getter_twin_sync_impl(ptr, rust_vec_len, data_len), +725 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_array_twin_sync_impl(ptr, rust_vec_len, data_len), +724 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +735 => wire__crate__api__pseudo_manual__method_twin_sync__my_callable_twin_sync_call_impl(ptr, rust_vec_len, data_len), +741 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), +742 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), +743 => wire__crate__api__pseudo_manual__method_twin_sync__simple_primitive_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), +739 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_arg_self_twin_sync_impl(ptr, rust_vec_len, data_len), +737 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +738 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_own_twin_sync_impl(ptr, rust_vec_len, data_len), +736 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), +740 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_vec_self_twin_sync_impl(ptr, rust_vec_len, data_len), +744 => wire__crate__api__pseudo_manual__method_twin_sync__static_only_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), +734 => wire__crate__api__pseudo_manual__method_twin_sync__sum_with_twin_sync_sum_twin_sync_impl(ptr, rust_vec_len, data_len), +775 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +776 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_vec_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +782 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_number_twin_sync_impl(ptr, rust_vec_len, data_len), +783 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), +772 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), +773 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_fallible_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), +779 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_message_twin_sync_impl(ptr, rust_vec_len, data_len), +774 => wire__crate__api__pseudo_manual__mirror_twin_sync__is_app_embedded_twin_sync_impl(ptr, rust_vec_len, data_len), +797 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_array_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +792 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +795 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_map_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +793 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_option_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +796 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_set_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +777 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_struct_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +778 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_tuple_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +794 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_vec_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +780 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_number_twin_sync_impl(ptr, rust_vec_len, data_len), +781 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), +790 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_contains_mirrored_sub_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +788 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_fallible_of_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +791 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_hashmap_with_mirrored_value_twin_sync_impl(ptr, rust_vec_len, data_len), +789 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_nested_enums_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +787 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_raw_nested_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +785 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_nested_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +786 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_enum_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +784 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +810 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_big_buffers_twin_sync_impl(ptr, rust_vec_len, data_len), +807 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_complex_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +809 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_nested_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +813 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_string_twin_sync_impl(ptr, rust_vec_len, data_len), +815 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +814 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_vec_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +808 => wire__crate__api__pseudo_manual__misc_example_twin_sync__list_of_primitive_enums_twin_sync_impl(ptr, rust_vec_len, data_len), +811 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_abc_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +812 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_struct_with_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +823 => wire__crate__api__pseudo_manual__misc_type_twin_sync__empty_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +820 => wire__crate__api__pseudo_manual__misc_type_twin_sync__func_return_unit_twin_sync_impl(ptr, rust_vec_len, data_len), +821 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_list_of_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +822 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_string_list_twin_sync_impl(ptr, rust_vec_len, data_len), +825 => wire__crate__api__pseudo_manual__newtype_pattern_twin_sync__handle_newtype_twin_sync_impl(ptr, rust_vec_len, data_len), +827 => wire__crate__api__pseudo_manual__optional_primitive_misc_twin_sync__primitive_optional_types_twin_sync_impl(ptr, rust_vec_len, data_len), +837 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_increment_boxed_optional_twin_sync_impl(ptr, rust_vec_len, data_len), +839 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_option_box_arguments_twin_sync_impl(ptr, rust_vec_len, data_len), +836 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_increment_twin_sync_impl(ptr, rust_vec_len, data_len), +834 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_return_twin_sync_impl(ptr, rust_vec_len, data_len), +835 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +838 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_vec_of_opts_twin_sync_impl(ptr, rust_vec_len, data_len), +846 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +845 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_str_twin_sync_impl(ptr, rust_vec_len, data_len), +844 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_string_twin_sync_impl(ptr, rust_vec_len, data_len), +847 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +849 => wire__crate__api__pseudo_manual__primitive_list_misc_twin_sync__handle_vec_of_primitive_twin_sync_impl(ptr, rust_vec_len, data_len), +852 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_types_twin_sync_impl(ptr, rust_vec_len, data_len), +853 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +857 => wire__crate__api__pseudo_manual__raw_string_twin_sync__test_more_than_just_one_raw_string_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +856 => wire__crate__api__pseudo_manual__raw_string_twin_sync__test_raw_string_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +948 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +949 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +947 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +951 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_getter_twin_sync_impl(ptr, rust_vec_len, data_len), +950 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +945 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_custom_name_twin_sync_impl(ptr, rust_vec_len, data_len), +944 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +946 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_with_result_twin_sync_impl(ptr, rust_vec_len, data_len), +941 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +942 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +940 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +943 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +906 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +907 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +909 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_own_and_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +905 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +930 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_vec_own_twin_sync_impl(ptr, rust_vec_len, data_len), +939 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_borrow_and_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +938 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_borrow_and_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +914 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +915 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_return_twin_sync_impl(ptr, rust_vec_len, data_len), +926 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_dummy_twin_sync_impl(ptr, rust_vec_len, data_len), +927 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +928 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +923 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +924 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_sync_impl(ptr, rust_vec_len, data_len), +925 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +932 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +934 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_return_twin_sync_impl(ptr, rust_vec_len, data_len), +933 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +911 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_normal_and_opaque_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +912 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_plus_sign_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +913 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_plus_sign_return_twin_sync_impl(ptr, rust_vec_len, data_len), +936 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_opaque_one_and_two_twin_sync_impl(ptr, rust_vec_len, data_len), +937 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_opaque_two_twin_sync_impl(ptr, rust_vec_len, data_len), +908 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +931 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_vec_own_twin_sync_impl(ptr, rust_vec_len, data_len), +935 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_sleep_twin_sync_impl(ptr, rust_vec_len, data_len), +929 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), +921 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +922 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +917 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +918 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +916 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +919 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_return_own_one_twin_sync_impl(ptr, rust_vec_len, data_len), +920 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_return_own_two_twin_sync_impl(ptr, rust_vec_len, data_len), +910 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_two_args_twin_sync_impl(ptr, rust_vec_len, data_len), +969 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_array_opaque_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +978 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +967 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +968 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_option_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +981 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__frb_generator_test_twin_sync_impl(ptr, rust_vec_len, data_len), +975 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_run_twin_sync_impl(ptr, rust_vec_len, data_len), +973 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_twin_sync_impl(ptr, rust_vec_len, data_len), +977 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_run_twin_sync_impl(ptr, rust_vec_len, data_len), +976 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_twin_sync_impl(ptr, rust_vec_len, data_len), +970 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_enum_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +979 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +974 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_non_clone_twin_sync_impl(ptr, rust_vec_len, data_len), +971 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +972 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_with_delay_twin_sync_impl(ptr, rust_vec_len, data_len), +980 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__unwrap_rust_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +983 => wire__crate__api__pseudo_manual__simple_twin_sync__simple_adder_twin_sync_impl(ptr, rust_vec_len, data_len), +1000 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1001 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), +999 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_zero_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1002 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1003 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1007 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_2_twin_sync_impl(ptr, rust_vec_len, data_len), +1006 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), +1011 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), +1013 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_model_twin_sync_impl(ptr, rust_vec_len, data_len), +1012 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_nest_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), +1019 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_nested_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), +1017 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuid_twin_sync_impl(ptr, rust_vec_len, data_len), +1018 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), +1087 => wire__crate__api__rust_opaque_sync__frb_sync_generator_test_twin_normal_impl(ptr, rust_vec_len, data_len), +1086 => wire__crate__api__rust_opaque_sync__sync_create_non_clone_twin_normal_impl(ptr, rust_vec_len, data_len), +1085 => wire__crate__api__rust_opaque_sync__sync_create_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +1084 => wire__crate__api__rust_opaque_sync__sync_option_rust_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), _ => unreachable!(), } } diff --git a/frb_example/pure_dart_pde/test/api/dart_fn_test.dart b/frb_example/pure_dart_pde/test/api/dart_fn_test.dart index 34d03cf656..34987a055b 100644 --- a/frb_example/pure_dart_pde/test/api/dart_fn_test.dart +++ b/frb_example/pure_dart_pde/test/api/dart_fn_test.dart @@ -83,4 +83,17 @@ Future main({bool skipRustLibInit = false}) async { callback: () => callCount++, numTimes: 10); expect(callCount, 10); }); + + group('rustCallDartReturnResultTwinNormal', () { + test('when normal', () async { + await rustCallDartReturnResultTwinNormal( + callback: (s) => s * 2, expectOutput: "hihi"); + }); + + test('when error', () async { + await rustCallDartReturnResultTwinNormal( + callback: (s) => throw Exception('dummy exception'), + expectOutput: null); + }); + }); } diff --git a/frb_example/pure_dart_pde/test/api/pseudo_manual/dart_fn_twin_rust_async_test.dart b/frb_example/pure_dart_pde/test/api/pseudo_manual/dart_fn_twin_rust_async_test.dart index 0b1b24cc80..3225419954 100644 --- a/frb_example/pure_dart_pde/test/api/pseudo_manual/dart_fn_twin_rust_async_test.dart +++ b/frb_example/pure_dart_pde/test/api/pseudo_manual/dart_fn_twin_rust_async_test.dart @@ -87,4 +87,17 @@ Future main({bool skipRustLibInit = false}) async { callback: () => callCount++, numTimes: 10); expect(callCount, 10); }); + + group('rustCallDartReturnResultTwinRustAsync', () { + test('when normal', () async { + await rustCallDartReturnResultTwinRustAsync( + callback: (s) => s * 2, expectOutput: "hihi"); + }); + + test('when error', () async { + await rustCallDartReturnResultTwinRustAsync( + callback: (s) => throw Exception('dummy exception'), + expectOutput: null); + }); + }); } From 85818ae966dd4a521f0996e42f533ae2c347edf8 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 15:04:11 +0800 Subject: [PATCH 86/94] fix: lint --- frb_rust/src/codec/sse.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frb_rust/src/codec/sse.rs b/frb_rust/src/codec/sse.rs index 2587d9b963..2eb7840895 100644 --- a/frb_rust/src/codec/sse.rs +++ b/frb_rust/src/codec/sse.rs @@ -4,7 +4,7 @@ use crate::handler::error::error_to_string; use crate::platform_types::{DartAbi, PlatformGeneralizedUint8ListPtr, WireSyncRust2DartSse}; use crate::rust2dart::action::Rust2DartAction; use byteorder::WriteBytesExt; -use byteorder::{NativeEndian, ReadBytesExt}; +use byteorder::NativeEndian; use std::any::Any; use std::backtrace::Backtrace; use std::io::Cursor; From eedb45a0c592e7b2cf194ffcdefe806f4fb37fb2 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 15:38:19 +0800 Subject: [PATCH 87/94] chore: lint --- frb_rust/src/codec/sse.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frb_rust/src/codec/sse.rs b/frb_rust/src/codec/sse.rs index 2eb7840895..4cb5311a40 100644 --- a/frb_rust/src/codec/sse.rs +++ b/frb_rust/src/codec/sse.rs @@ -3,8 +3,8 @@ use crate::generalized_isolate::IntoDart; use crate::handler::error::error_to_string; use crate::platform_types::{DartAbi, PlatformGeneralizedUint8ListPtr, WireSyncRust2DartSse}; use crate::rust2dart::action::Rust2DartAction; -use byteorder::WriteBytesExt; use byteorder::NativeEndian; +use byteorder::WriteBytesExt; use std::any::Any; use std::backtrace::Backtrace; use std::io::Cursor; From c3122c1a69126adbe9d90036c580802f3e9b5b60 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 15:43:53 +0800 Subject: [PATCH 88/94] chore: lint --- .../generator/wire/rust/spec_generator/misc/ty/dart_fn.rs | 1 - .../src/library/codegen/parser/function_parser/output.rs | 2 -- .../src/library/codegen/parser/type_parser/dart_fn.rs | 7 ------- 3 files changed, 10 deletions(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs index 16e3844889..d9795cb086 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/dart_fn.rs @@ -2,7 +2,6 @@ use crate::codegen::generator::acc::Acc; use crate::codegen::generator::wire::rust::spec_generator::base::*; use crate::codegen::generator::wire::rust::spec_generator::misc::ty::WireRustGeneratorMiscTrait; use crate::codegen::generator::wire::rust::spec_generator::output_code::WireRustOutputCode; -use crate::codegen::ir::ty::dart_fn::IrDartFnOutput; use crate::codegen::ir::ty::IrTypeTrait; use crate::library::misc::consts::HANDLER_NAME; use itertools::Itertools; diff --git a/frb_codegen/src/library/codegen/parser/function_parser/output.rs b/frb_codegen/src/library/codegen/parser/function_parser/output.rs index 197cb94d58..29558cdd10 100644 --- a/frb_codegen/src/library/codegen/parser/function_parser/output.rs +++ b/frb_codegen/src/library/codegen/parser/function_parser/output.rs @@ -1,9 +1,7 @@ use crate::codegen::ir::ty::primitive::IrTypePrimitive; use crate::codegen::ir::ty::IrType; -use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; use crate::codegen::parser::function_parser::{FunctionParser, FunctionPartialInfo}; use crate::codegen::parser::type_parser::result::parse_type_maybe_result; -use crate::codegen::parser::type_parser::unencodable::splay_segments; use crate::codegen::parser::type_parser::TypeParserParsingContext; use syn::*; diff --git a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs index 5d1c930afe..e6722e8a71 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/dart_fn.rs @@ -1,13 +1,6 @@ -use crate::codegen::ir::field::IrField; -use crate::codegen::ir::ident::IrIdent; -use crate::codegen::ir::namespace::{Namespace, NamespacedName}; use crate::codegen::ir::ty::dart_fn::IrDartFnOutput; use crate::codegen::ir::ty::dart_fn::IrTypeDartFn; use crate::codegen::ir::ty::delegate::IrTypeDelegate; -use crate::codegen::ir::ty::enumeration::{ - IrEnum, IrEnumIdent, IrEnumMode, IrTypeEnumRef, IrVariant, IrVariantKind, -}; -use crate::codegen::ir::ty::structure::IrStruct; use crate::codegen::ir::ty::IrType; use crate::codegen::parser::type_parser::result::{parse_type_maybe_result, ResultTypeInfo}; use crate::codegen::parser::type_parser::TypeParserWithContext; From 6d00ac393249b06a8adc6f99b1ec997b40c25d1c Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 16:12:52 +0800 Subject: [PATCH 89/94] chore: add ignore --- .../codegen/generator/wire/rust/spec_generator/misc/mod.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/mod.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/mod.rs index a1e2aac4fb..5d431c26ad 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/mod.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/mod.rs @@ -81,7 +81,8 @@ clippy::unused_unit, clippy::double_parens, clippy::let_and_return, clippy::too_many_arguments, -clippy::match_single_binding +clippy::match_single_binding, +clippy::let_unit_value )]"#; fn generate_imports( From f827ae102d964368f61827dbaf27f3d5d0c2413b Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 16:27:12 +0800 Subject: [PATCH 90/94] chore: codegen --- frb_example/dart_build_rs/rust/src/frb_generated.rs | 3 ++- frb_example/dart_minimal/rust/src/frb_generated.rs | 3 ++- frb_example/deliberate_bad/rust/src/frb_generated.rs | 3 ++- frb_example/flutter_via_create/rust/src/frb_generated.rs | 3 ++- frb_example/flutter_via_integrate/rust/src/frb_generated.rs | 3 ++- frb_example/gallery/rust/src/frb_generated.rs | 3 ++- frb_example/pure_dart/rust/src/frb_generated.rs | 3 ++- frb_example/pure_dart_pde/rust/src/frb_generated.rs | 3 ++- 8 files changed, 16 insertions(+), 8 deletions(-) diff --git a/frb_example/dart_build_rs/rust/src/frb_generated.rs b/frb_example/dart_build_rs/rust/src/frb_generated.rs index 20b8e03143..772f29b4b4 100644 --- a/frb_example/dart_build_rs/rust/src/frb_generated.rs +++ b/frb_example/dart_build_rs/rust/src/frb_generated.rs @@ -14,7 +14,8 @@ clippy::double_parens, clippy::let_and_return, clippy::too_many_arguments, - clippy::match_single_binding + clippy::match_single_binding, + clippy::let_unit_value )] // Section: imports diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index 20b8e03143..772f29b4b4 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -14,7 +14,8 @@ clippy::double_parens, clippy::let_and_return, clippy::too_many_arguments, - clippy::match_single_binding + clippy::match_single_binding, + clippy::let_unit_value )] // Section: imports diff --git a/frb_example/deliberate_bad/rust/src/frb_generated.rs b/frb_example/deliberate_bad/rust/src/frb_generated.rs index 5107b42fa1..5e9d11534b 100644 --- a/frb_example/deliberate_bad/rust/src/frb_generated.rs +++ b/frb_example/deliberate_bad/rust/src/frb_generated.rs @@ -14,7 +14,8 @@ clippy::double_parens, clippy::let_and_return, clippy::too_many_arguments, - clippy::match_single_binding + clippy::match_single_binding, + clippy::let_unit_value )] // Section: imports diff --git a/frb_example/flutter_via_create/rust/src/frb_generated.rs b/frb_example/flutter_via_create/rust/src/frb_generated.rs index 3d382071c9..4a771e5b2a 100644 --- a/frb_example/flutter_via_create/rust/src/frb_generated.rs +++ b/frb_example/flutter_via_create/rust/src/frb_generated.rs @@ -14,7 +14,8 @@ clippy::double_parens, clippy::let_and_return, clippy::too_many_arguments, - clippy::match_single_binding + clippy::match_single_binding, + clippy::let_unit_value )] // Section: imports diff --git a/frb_example/flutter_via_integrate/rust/src/frb_generated.rs b/frb_example/flutter_via_integrate/rust/src/frb_generated.rs index 3d382071c9..4a771e5b2a 100644 --- a/frb_example/flutter_via_integrate/rust/src/frb_generated.rs +++ b/frb_example/flutter_via_integrate/rust/src/frb_generated.rs @@ -14,7 +14,8 @@ clippy::double_parens, clippy::let_and_return, clippy::too_many_arguments, - clippy::match_single_binding + clippy::match_single_binding, + clippy::let_unit_value )] // Section: imports diff --git a/frb_example/gallery/rust/src/frb_generated.rs b/frb_example/gallery/rust/src/frb_generated.rs index 058c82cf8c..e931a756a0 100644 --- a/frb_example/gallery/rust/src/frb_generated.rs +++ b/frb_example/gallery/rust/src/frb_generated.rs @@ -14,7 +14,8 @@ clippy::double_parens, clippy::let_and_return, clippy::too_many_arguments, - clippy::match_single_binding + clippy::match_single_binding, + clippy::let_unit_value )] // Section: imports diff --git a/frb_example/pure_dart/rust/src/frb_generated.rs b/frb_example/pure_dart/rust/src/frb_generated.rs index a44ec01dad..5f89ff96da 100644 --- a/frb_example/pure_dart/rust/src/frb_generated.rs +++ b/frb_example/pure_dart/rust/src/frb_generated.rs @@ -14,7 +14,8 @@ clippy::double_parens, clippy::let_and_return, clippy::too_many_arguments, - clippy::match_single_binding + clippy::match_single_binding, + clippy::let_unit_value )] // Section: imports diff --git a/frb_example/pure_dart_pde/rust/src/frb_generated.rs b/frb_example/pure_dart_pde/rust/src/frb_generated.rs index 4e787523b9..c77d7f1d74 100644 --- a/frb_example/pure_dart_pde/rust/src/frb_generated.rs +++ b/frb_example/pure_dart_pde/rust/src/frb_generated.rs @@ -14,7 +14,8 @@ clippy::double_parens, clippy::let_and_return, clippy::too_many_arguments, - clippy::match_single_binding + clippy::match_single_binding, + clippy::let_unit_value )] // Section: imports From 8fe3847454f1c1fc4abc03ce8e2c13dbd9b80e30 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 18:13:46 +0800 Subject: [PATCH 91/94] chore: lint --- frb_codegen/src/library/codegen/parser/type_parser/result.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/frb_codegen/src/library/codegen/parser/type_parser/result.rs b/frb_codegen/src/library/codegen/parser/type_parser/result.rs index 0f7aa16bd3..d736193796 100644 --- a/frb_codegen/src/library/codegen/parser/type_parser/result.rs +++ b/frb_codegen/src/library/codegen/parser/type_parser/result.rs @@ -4,6 +4,7 @@ use crate::codegen::ir::ty::IrType::{EnumRef, StructRef}; use crate::codegen::parser::type_parser::unencodable::splay_segments; use crate::codegen::parser::type_parser::{TypeParser, TypeParserParsingContext}; +#[allow(clippy::single_match)] // deliberate do so to ensure style consistency pub(crate) fn parse_type_maybe_result( ir: &IrType, type_parser: &mut TypeParser, From 380159825437e3f44d9cf5fe20237714c738e5d1 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Sun, 19 May 2024 18:14:21 +0800 Subject: [PATCH 92/94] chore: update --- .../REPLACE_ME_RUST_CRATE_DIR/src/frb_generated.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/frb_codegen/assets/integration_template/REPLACE_ME_RUST_CRATE_DIR/src/frb_generated.rs b/frb_codegen/assets/integration_template/REPLACE_ME_RUST_CRATE_DIR/src/frb_generated.rs index 05ad84c9a9..4fb6342a35 100644 --- a/frb_codegen/assets/integration_template/REPLACE_ME_RUST_CRATE_DIR/src/frb_generated.rs +++ b/frb_codegen/assets/integration_template/REPLACE_ME_RUST_CRATE_DIR/src/frb_generated.rs @@ -14,7 +14,8 @@ clippy::double_parens, clippy::let_and_return, clippy::too_many_arguments, - clippy::match_single_binding + clippy::match_single_binding, + clippy::let_unit_value )] // Section: imports From 98e1a413cc4e4d6d8283acdc4189f155d9f205d7 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Mon, 20 May 2024 10:11:46 +0800 Subject: [PATCH 93/94] chore: rm --- frb_rust/src/for_generated/boilerplate.rs | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/frb_rust/src/for_generated/boilerplate.rs b/frb_rust/src/for_generated/boilerplate.rs index c5946118e5..abbfe0d5c4 100644 --- a/frb_rust/src/for_generated/boilerplate.rs +++ b/frb_rust/src/for_generated/boilerplate.rs @@ -90,17 +90,6 @@ macro_rules! frb_generated_sse_codec { () => { pub trait SseDecode { fn sse_decode(deserializer: &mut $crate::for_generated::SseDeserializer) -> Self; - - // just syntax sugar - fn sse_decode_single(message: $crate::for_generated::Dart2RustMessageSse) -> Self - where - Self: Sized, - { - let mut deserializer = $crate::for_generated::SseDeserializer::new(message); - let ans = Self::sse_decode(&mut deserializer); - deserializer.end(); - ans - } } pub trait SseEncode { From f5fdcac708b562c366519ca6941300e16c84e0a8 Mon Sep 17 00:00:00 2001 From: fzyzcjy Date: Mon, 20 May 2024 10:19:53 +0800 Subject: [PATCH 94/94] chore: codegen --- .../pure_dart/lib/src/rust/frb_generated.dart | 340 ++- .../pure_dart/rust/src/frb_generated.rs | 200 +- .../lib/src/rust/frb_generated.dart | 2048 +++++++++-------- .../pure_dart_pde/rust/src/frb_generated.rs | 2002 ++++++++-------- 4 files changed, 2772 insertions(+), 1818 deletions(-) diff --git a/frb_example/pure_dart/lib/src/rust/frb_generated.dart b/frb_example/pure_dart/lib/src/rust/frb_generated.dart index 750933ca19..4f72a6a656 100644 --- a/frb_example/pure_dart/lib/src/rust/frb_generated.dart +++ b/frb_example/pure_dart/lib/src/rust/frb_generated.dart @@ -308,7 +308,7 @@ class RustLib extends BaseEntrypoint { String get codegenVersion => '2.0.0-dev.34'; @override - int get rustContentHash => -1320820513; + int get rustContentHash => -1744878402; static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig( @@ -950,6 +950,9 @@ abstract class RustLibApi extends BaseApi { Future crateApiMiscExampleHandleBigBuffersTwinNormal( {dynamic hint}); + Future crateApiMiscExampleHandleCharTwinNormal( + {required String arg, dynamic hint}); + Future crateApiMiscExampleHandleComplexStructTwinNormal( {required MyTreeNodeTwinNormal s, dynamic hint}); @@ -985,9 +988,16 @@ abstract class RustLibApi extends BaseApi { crateApiMiscNoTwinExampleAStructWithImplBlockInMultiFileMethodInA( {required StructWithImplBlockInMultiFile that, dynamic hint}); + Future crateApiMiscNoTwinExampleAFunctionWithCustomNameTwinNormal( + {dynamic hint}); + Future crateApiMiscNoTwinExampleASameFunctionNameInDifferentFiles( {dynamic hint}); + void + crateApiMiscNoTwinExampleAStructWithCustomNameMethodTwinNormalMethodWithCustomNameTwinNormal( + {required StructWithCustomNameMethodTwinNormal that, dynamic hint}); + Future crateApiMiscNoTwinExampleAStructWithImplBlockInAnotherFileF( {required StructWithImplBlockInAnotherFileDependency arg, dynamic hint}); @@ -6089,6 +6099,10 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualMiscExampleTwinRustAsyncHandleBigBuffersTwinRustAsync( {dynamic hint}); + Future + crateApiPseudoManualMiscExampleTwinRustAsyncHandleCharTwinRustAsync( + {required String arg, dynamic hint}); + Future crateApiPseudoManualMiscExampleTwinRustAsyncHandleComplexStructTwinRustAsync( {required MyTreeNodeTwinRustAsync s, dynamic hint}); @@ -6125,6 +6139,10 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualMiscExampleTwinRustAsyncSseHandleBigBuffersTwinRustAsyncSse( {dynamic hint}); + Future + crateApiPseudoManualMiscExampleTwinRustAsyncSseHandleCharTwinRustAsyncSse( + {required String arg, dynamic hint}); + Future crateApiPseudoManualMiscExampleTwinRustAsyncSseHandleComplexStructTwinRustAsyncSse( {required MyTreeNodeTwinRustAsyncSse s, dynamic hint}); @@ -6161,6 +6179,9 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualMiscExampleTwinSseHandleBigBuffersTwinSse( {dynamic hint}); + Future crateApiPseudoManualMiscExampleTwinSseHandleCharTwinSse( + {required String arg, dynamic hint}); + Future crateApiPseudoManualMiscExampleTwinSseHandleComplexStructTwinSse( {required MyTreeNodeTwinSse s, dynamic hint}); @@ -6193,6 +6214,9 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualMiscExampleTwinSyncHandleBigBuffersTwinSync( {dynamic hint}); + String crateApiPseudoManualMiscExampleTwinSyncHandleCharTwinSync( + {required String arg, dynamic hint}); + MyTreeNodeTwinSync crateApiPseudoManualMiscExampleTwinSyncHandleComplexStructTwinSync( {required MyTreeNodeTwinSync s, dynamic hint}); @@ -6225,6 +6249,9 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualMiscExampleTwinSyncSseHandleBigBuffersTwinSyncSse( {dynamic hint}); + String crateApiPseudoManualMiscExampleTwinSyncSseHandleCharTwinSyncSse( + {required String arg, dynamic hint}); + MyTreeNodeTwinSyncSse crateApiPseudoManualMiscExampleTwinSyncSseHandleComplexStructTwinSyncSse( {required MyTreeNodeTwinSyncSse s, dynamic hint}); @@ -17667,6 +17694,32 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + Future crateApiMiscExampleHandleCharTwinNormal( + {required String arg, dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + var arg0 = cst_encode_Char(arg); + return wire.wire__crate__api__misc_example__handle_char_twin_normal( + port_, arg0); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_Char, + decodeErrorData: null, + ), + constMeta: kCrateApiMiscExampleHandleCharTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta get kCrateApiMiscExampleHandleCharTwinNormalConstMeta => + const TaskConstMeta( + debugName: "handle_char_twin_normal", + argNames: ["arg"], + ); + @override Future crateApiMiscExampleHandleComplexStructTwinNormal( {required MyTreeNodeTwinNormal s, dynamic hint}) { @@ -17949,6 +18002,34 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["that"], ); + @override + Future crateApiMiscNoTwinExampleAFunctionWithCustomNameTwinNormal( + {dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + return wire + .wire__crate__api__misc_no_twin_example_a__function_with_custom_name_twin_normal( + port_); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: null, + ), + constMeta: + kCrateApiMiscNoTwinExampleAFunctionWithCustomNameTwinNormalConstMeta, + argValues: [], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiMiscNoTwinExampleAFunctionWithCustomNameTwinNormalConstMeta => + const TaskConstMeta( + debugName: "function_with_custom_name_twin_normal", + argNames: [], + ); + @override Future crateApiMiscNoTwinExampleASameFunctionNameInDifferentFiles( {dynamic hint}) { @@ -17977,6 +18058,39 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + void + crateApiMiscNoTwinExampleAStructWithCustomNameMethodTwinNormalMethodWithCustomNameTwinNormal( + {required StructWithCustomNameMethodTwinNormal that, dynamic hint}) { + return handler.executeSync(SyncTask( + callFfi: () { + var arg0 = + cst_encode_box_autoadd_struct_with_custom_name_method_twin_normal( + that); + return wire + .wire__crate__api__misc_no_twin_example_a__struct_with_custom_name_method_twin_normal_method_with_custom_name_twin_normal( + arg0); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: null, + ), + constMeta: + kCrateApiMiscNoTwinExampleAStructWithCustomNameMethodTwinNormalMethodWithCustomNameTwinNormalConstMeta, + argValues: [that], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiMiscNoTwinExampleAStructWithCustomNameMethodTwinNormalMethodWithCustomNameTwinNormalConstMeta => + const TaskConstMeta( + debugName: + "struct_with_custom_name_method_twin_normal_method_with_custom_name_twin_normal", + argNames: ["that"], + ); + @override Future crateApiMiscNoTwinExampleAStructWithImplBlockInAnotherFileF( {required StructWithImplBlockInAnotherFileDependency arg, dynamic hint}) { @@ -59160,6 +59274,36 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + Future + crateApiPseudoManualMiscExampleTwinRustAsyncHandleCharTwinRustAsync( + {required String arg, dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + var arg0 = cst_encode_Char(arg); + return wire + .wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_char_twin_rust_async( + port_, arg0); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_Char, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualMiscExampleTwinRustAsyncHandleCharTwinRustAsyncConstMeta, + argValues: [arg], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualMiscExampleTwinRustAsyncHandleCharTwinRustAsyncConstMeta => + const TaskConstMeta( + debugName: "handle_char_twin_rust_async", + argNames: ["arg"], + ); + @override Future crateApiPseudoManualMiscExampleTwinRustAsyncHandleComplexStructTwinRustAsync( @@ -59432,6 +59576,38 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + Future + crateApiPseudoManualMiscExampleTwinRustAsyncSseHandleCharTwinRustAsyncSse( + {required String arg, dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_Char(arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__pseudo_manual__misc_example_twin_rust_async_sse__handle_char_twin_rust_async_sse( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_Char, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualMiscExampleTwinRustAsyncSseHandleCharTwinRustAsyncSseConstMeta, + argValues: [arg], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualMiscExampleTwinRustAsyncSseHandleCharTwinRustAsyncSseConstMeta => + const TaskConstMeta( + debugName: "handle_char_twin_rust_async_sse", + argNames: ["arg"], + ); + @override Future crateApiPseudoManualMiscExampleTwinRustAsyncSseHandleComplexStructTwinRustAsyncSse( @@ -59722,6 +59898,37 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + Future crateApiPseudoManualMiscExampleTwinSseHandleCharTwinSse( + {required String arg, dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_Char(arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__pseudo_manual__misc_example_twin_sse__handle_char_twin_sse( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_Char, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualMiscExampleTwinSseHandleCharTwinSseConstMeta, + argValues: [arg], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualMiscExampleTwinSseHandleCharTwinSseConstMeta => + const TaskConstMeta( + debugName: "handle_char_twin_sse", + argNames: ["arg"], + ); + @override Future crateApiPseudoManualMiscExampleTwinSseHandleComplexStructTwinSse( @@ -60003,6 +60210,35 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + String crateApiPseudoManualMiscExampleTwinSyncHandleCharTwinSync( + {required String arg, dynamic hint}) { + return handler.executeSync(SyncTask( + callFfi: () { + var arg0 = cst_encode_Char(arg); + return wire + .wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_char_twin_sync( + arg0); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_Char, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualMiscExampleTwinSyncHandleCharTwinSyncConstMeta, + argValues: [arg], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualMiscExampleTwinSyncHandleCharTwinSyncConstMeta => + const TaskConstMeta( + debugName: "handle_char_twin_sync", + argNames: ["arg"], + ); + @override MyTreeNodeTwinSync crateApiPseudoManualMiscExampleTwinSyncHandleComplexStructTwinSync( @@ -60271,6 +60507,37 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + String crateApiPseudoManualMiscExampleTwinSyncSseHandleCharTwinSyncSse( + {required String arg, dynamic hint}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_Char(arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__pseudo_manual__misc_example_twin_sync_sse__handle_char_twin_sync_sse( + raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_Char, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualMiscExampleTwinSyncSseHandleCharTwinSyncSseConstMeta, + argValues: [arg], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualMiscExampleTwinSyncSseHandleCharTwinSyncSseConstMeta => + const TaskConstMeta( + debugName: "handle_char_twin_sync_sse", + argNames: ["arg"], + ); + @override MyTreeNodeTwinSyncSse crateApiPseudoManualMiscExampleTwinSyncSseHandleComplexStructTwinSyncSse( @@ -96494,6 +96761,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return raw as String; } + @protected + String dco_decode_Char(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return String.fromCharCode(raw); + } + @protected Duration dco_decode_Chrono_Duration(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs @@ -102604,6 +102877,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return dco_decode_struct_with_comments_twin_sync_sse(raw); } + @protected + StructWithCustomNameMethodTwinNormal + dco_decode_box_autoadd_struct_with_custom_name_method_twin_normal( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_custom_name_method_twin_normal(raw); + } + @protected StructWithEnumTwinNormal dco_decode_box_autoadd_struct_with_enum_twin_normal( dynamic raw) { @@ -113004,6 +113285,18 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); } + @protected + StructWithCustomNameMethodTwinNormal + dco_decode_struct_with_custom_name_method_twin_normal(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 1) + throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); + return StructWithCustomNameMethodTwinNormal( + field0: dco_decode_i_32(arr[0]), + ); + } + @protected StructWithEnumTwinNormal dco_decode_struct_with_enum_twin_normal( dynamic raw) { @@ -116402,6 +116695,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return inner; } + @protected + String sse_decode_Char(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_String(deserializer); + return inner; + } + @protected Duration sse_decode_Chrono_Duration(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -122695,6 +122995,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return (sse_decode_struct_with_comments_twin_sync_sse(deserializer)); } + @protected + StructWithCustomNameMethodTwinNormal + sse_decode_box_autoadd_struct_with_custom_name_method_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_custom_name_method_twin_normal( + deserializer)); + } + @protected StructWithEnumTwinNormal sse_decode_box_autoadd_struct_with_enum_twin_normal( SseDeserializer deserializer) { @@ -134181,6 +134490,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { fieldWithComments: var_fieldWithComments); } + @protected + StructWithCustomNameMethodTwinNormal + sse_decode_struct_with_custom_name_method_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_field0 = sse_decode_i_32(deserializer); + return StructWithCustomNameMethodTwinNormal(field0: var_field0); + } + @protected StructWithEnumTwinNormal sse_decode_struct_with_enum_twin_normal( SseDeserializer deserializer) { @@ -139153,6 +139471,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { throw UnimplementedError('Unreachable ()'); } + @protected + void sse_encode_Char(String self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String(self, serializer); + } + @protected void sse_encode_Chrono_Duration(Duration self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -145384,6 +145708,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_struct_with_comments_twin_sync_sse(self, serializer); } + @protected + void sse_encode_box_autoadd_struct_with_custom_name_method_twin_normal( + StructWithCustomNameMethodTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_custom_name_method_twin_normal(self, serializer); + } + @protected void sse_encode_box_autoadd_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer) { @@ -154890,6 +155221,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(self.fieldWithComments, serializer); } + @protected + void sse_encode_struct_with_custom_name_method_twin_normal( + StructWithCustomNameMethodTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.field0, serializer); + } + @protected void sse_encode_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer) { diff --git a/frb_example/pure_dart/rust/src/frb_generated.rs b/frb_example/pure_dart/rust/src/frb_generated.rs index 5f89ff96da..adb2b40b36 100644 --- a/frb_example/pure_dart/rust/src/frb_generated.rs +++ b/frb_example/pure_dart/rust/src/frb_generated.rs @@ -77,7 +77,7 @@ flutter_rust_bridge::frb_generated_boilerplate!( default_rust_auto_opaque = RustAutoOpaqueNom, ); pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.34"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1320820513; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1744878402; // Section: executor @@ -4048,6 +4048,26 @@ fn wire__crate__api__misc_example__handle_big_buffers_twin_normal_impl( }, ) } +fn wire__crate__api__misc_example__handle_char_twin_normal_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + arg: impl CstDecode, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "handle_char_twin_normal", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let api_arg = arg.cst_decode(); + move |context| { + transform_result_dco((move || { + Result::<_, ()>::Ok(crate::api::misc_example::handle_char_twin_normal(api_arg)) + })()) + } + }, + ) +} fn wire__crate__api__misc_example__handle_complex_struct_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, s: impl CstDecode, @@ -4268,6 +4288,26 @@ let decode_indices_ = flutter_rust_bridge::for_generated::rust_auto_opaque_decod })()) } }) } +fn wire__crate__api__misc_no_twin_example_a__function_with_custom_name_twin_normal_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "function_with_custom_name_twin_normal", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + move |context| { + transform_result_dco((move || { + Result::<_, ()>::Ok( + crate::api::misc_no_twin_example_a::function_with_custom_name_twin_normal(), + ) + })()) + } + }, + ) +} fn wire__crate__api__misc_no_twin_example_a__same_function_name_in_different_files_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ) { @@ -4288,6 +4328,14 @@ fn wire__crate__api__misc_no_twin_example_a__same_function_name_in_different_fil }, ) } +fn wire__crate__api__misc_no_twin_example_a__struct_with_custom_name_method_twin_normal_method_with_custom_name_twin_normal_impl( + that: impl CstDecode, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "struct_with_custom_name_method_twin_normal_method_with_custom_name_twin_normal", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { let api_that = that.cst_decode(); + transform_result_dco((move || { + Result::<_,()>::Ok(crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal::method_with_custom_name_twin_normal(&api_that)) + })()) }) +} fn wire__crate__api__misc_no_twin_example_a__struct_with_impl_block_in_another_file_f_impl( port_: flutter_rust_bridge::for_generated::MessagePort, arg: impl CstDecode, @@ -24084,6 +24132,16 @@ fn wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_big_buf })().await) } }) } +fn wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_char_twin_rust_async_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + arg: impl CstDecode, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "handle_char_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_arg = arg.cst_decode(); move |context| async move { + transform_result_dco((move || async move { + Result::<_,()>::Ok(crate::api::pseudo_manual::misc_example_twin_rust_async::handle_char_twin_rust_async(api_arg).await) + })().await) + } }) +} fn wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_complex_struct_twin_rust_async_impl( port_: flutter_rust_bridge::for_generated::MessagePort, s: impl CstDecode, @@ -24186,6 +24244,21 @@ fn wire__crate__api__pseudo_manual__misc_example_twin_rust_async_sse__handle_big })().await) } }) } +fn wire__crate__api__pseudo_manual__misc_example_twin_rust_async_sse__handle_char_twin_rust_async_sse_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "handle_char_twin_rust_async_sse", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { + let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_arg = ::sse_decode(&mut deserializer);deserializer.end(); move |context| async move { + transform_result_sse((move || async move { + Result::<_,()>::Ok(crate::api::pseudo_manual::misc_example_twin_rust_async_sse::handle_char_twin_rust_async_sse(api_arg).await) + })().await) + } }) +} fn wire__crate__api__pseudo_manual__misc_example_twin_rust_async_sse__handle_complex_struct_twin_rust_async_sse_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -24322,6 +24395,42 @@ fn wire__crate__api__pseudo_manual__misc_example_twin_sse__handle_big_buffers_tw })()) } }) } +fn wire__crate__api__pseudo_manual__misc_example_twin_sse__handle_char_twin_sse_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "handle_char_twin_sse", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_arg = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse((move || { + Result::<_, ()>::Ok( + crate::api::pseudo_manual::misc_example_twin_sse::handle_char_twin_sse( + api_arg, + ), + ) + })()) + } + }, + ) +} fn wire__crate__api__pseudo_manual__misc_example_twin_sse__handle_complex_struct_twin_sse_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -24549,6 +24658,27 @@ fn wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_big_buffers_t }, ) } +fn wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_char_twin_sync_impl( + arg: impl CstDecode, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "handle_char_twin_sync", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let api_arg = arg.cst_decode(); + transform_result_dco((move || { + Result::<_, ()>::Ok( + crate::api::pseudo_manual::misc_example_twin_sync::handle_char_twin_sync( + api_arg, + ), + ) + })()) + }, + ) +} fn wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_complex_struct_twin_sync_impl( s: impl CstDecode, ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { @@ -24680,6 +24810,19 @@ fn wire__crate__api__pseudo_manual__misc_example_twin_sync_sse__handle_big_buffe Result::<_,()>::Ok(crate::api::pseudo_manual::misc_example_twin_sync_sse::handle_big_buffers_twin_sync_sse()) })()) }) } +fn wire__crate__api__pseudo_manual__misc_example_twin_sync_sse__handle_char_twin_sync_sse_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "handle_char_twin_sync_sse", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { + let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_arg = ::sse_decode(&mut deserializer);deserializer.end(); + transform_result_sse((move || { + Result::<_,()>::Ok(crate::api::pseudo_manual::misc_example_twin_sync_sse::handle_char_twin_sync_sse(api_arg)) + })()) }) +} fn wire__crate__api__pseudo_manual__misc_example_twin_sync_sse__handle_complex_struct_twin_sync_sse_impl( ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, @@ -43495,6 +43638,14 @@ impl SseDecode for backtrace::Backtrace { } } +impl SseDecode for char { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return inner.chars().next().unwrap(); + } +} + impl SseDecode for chrono::Duration { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -60411,6 +60562,16 @@ impl SseDecode for crate::api::pseudo_manual::comment_twin_sync_sse::StructWithC } } +impl SseDecode for crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_field0 = ::sse_decode(deserializer); + return crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal( + var_field0, + ); + } +} + impl SseDecode for crate::api::misc_example::StructWithEnumTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -75416,6 +75577,29 @@ impl } } // Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.0.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal, + > for crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal +{ + fn into_into_dart( + self, + ) -> crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs impl flutter_rust_bridge::IntoDart for crate::api::misc_example::StructWithEnumTwinNormal { fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { [ @@ -79276,6 +79460,13 @@ impl SseEncode for backtrace::Backtrace { } } +impl SseEncode for char { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.to_string(), serializer); + } +} + impl SseEncode for chrono::Duration { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -93676,6 +93867,13 @@ impl SseEncode for crate::api::pseudo_manual::comment_twin_sync_sse::StructWithC } } +impl SseEncode for crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.0, serializer); + } +} + impl SseEncode for crate::api::misc_example::StructWithEnumTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { diff --git a/frb_example/pure_dart_pde/lib/src/rust/frb_generated.dart b/frb_example/pure_dart_pde/lib/src/rust/frb_generated.dart index 6cd8028528..791c8b6e4b 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/frb_generated.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/frb_generated.dart @@ -182,7 +182,7 @@ class RustLib extends BaseEntrypoint { String get codegenVersion => '2.0.0-dev.34'; @override - int get rustContentHash => -1044428238; + int get rustContentHash => -1632146532; static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig( @@ -821,6 +821,9 @@ abstract class RustLibApi extends BaseApi { Future crateApiMiscExampleHandleBigBuffersTwinNormal( {dynamic hint}); + Future crateApiMiscExampleHandleCharTwinNormal( + {required String arg, dynamic hint}); + Future crateApiMiscExampleHandleComplexStructTwinNormal( {required MyTreeNodeTwinNormal s, dynamic hint}); @@ -856,9 +859,16 @@ abstract class RustLibApi extends BaseApi { crateApiMiscNoTwinExampleAStructWithImplBlockInMultiFileMethodInA( {required StructWithImplBlockInMultiFile that, dynamic hint}); + Future crateApiMiscNoTwinExampleAFunctionWithCustomNameTwinNormal( + {dynamic hint}); + Future crateApiMiscNoTwinExampleASameFunctionNameInDifferentFiles( {dynamic hint}); + void + crateApiMiscNoTwinExampleAStructWithCustomNameMethodTwinNormalMethodWithCustomNameTwinNormal( + {required StructWithCustomNameMethodTwinNormal that, dynamic hint}); + Future crateApiMiscNoTwinExampleAStructWithImplBlockInAnotherFileF( {required StructWithImplBlockInAnotherFileDependency arg, dynamic hint}); @@ -3117,6 +3127,10 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualMiscExampleTwinRustAsyncHandleBigBuffersTwinRustAsync( {dynamic hint}); + Future + crateApiPseudoManualMiscExampleTwinRustAsyncHandleCharTwinRustAsync( + {required String arg, dynamic hint}); + Future crateApiPseudoManualMiscExampleTwinRustAsyncHandleComplexStructTwinRustAsync( {required MyTreeNodeTwinRustAsync s, dynamic hint}); @@ -3153,6 +3167,9 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualMiscExampleTwinSyncHandleBigBuffersTwinSync( {dynamic hint}); + String crateApiPseudoManualMiscExampleTwinSyncHandleCharTwinSync( + {required String arg, dynamic hint}); + MyTreeNodeTwinSync crateApiPseudoManualMiscExampleTwinSyncHandleComplexStructTwinSync( {required MyTreeNodeTwinSync s, dynamic hint}); @@ -10346,6 +10363,33 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + Future crateApiMiscExampleHandleCharTwinNormal( + {required String arg, dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_Char(arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 201, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_Char, + decodeErrorData: null, + ), + constMeta: kCrateApiMiscExampleHandleCharTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta get kCrateApiMiscExampleHandleCharTwinNormalConstMeta => + const TaskConstMeta( + debugName: "handle_char_twin_normal", + argNames: ["arg"], + ); + @override Future crateApiMiscExampleHandleComplexStructTwinNormal( {required MyTreeNodeTwinNormal s, dynamic hint}) { @@ -10438,7 +10482,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_size(arg, serializer); sse_encode_box_my_size(boxed, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 202, port: port_); + funcId: 203, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_size, @@ -10465,7 +10509,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(v, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 201, port: port_); + funcId: 202, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -10578,7 +10622,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 204, port: port_); + funcId: 206, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10609,7 +10653,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithImplBlockInMultiFile( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 205, port: port_); + funcId: 207, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10630,6 +10674,34 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["that"], ); + @override + Future crateApiMiscNoTwinExampleAFunctionWithCustomNameTwinNormal( + {dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 205, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: + kCrateApiMiscNoTwinExampleAFunctionWithCustomNameTwinNormalConstMeta, + argValues: [], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiMiscNoTwinExampleAFunctionWithCustomNameTwinNormalConstMeta => + const TaskConstMeta( + debugName: "function_with_custom_name_twin_normal", + argNames: [], + ); + @override Future crateApiMiscNoTwinExampleASameFunctionNameInDifferentFiles( {dynamic hint}) { @@ -10637,7 +10709,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 203, port: port_); + funcId: 204, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10658,6 +10730,37 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + void + crateApiMiscNoTwinExampleAStructWithCustomNameMethodTwinNormalMethodWithCustomNameTwinNormal( + {required StructWithCustomNameMethodTwinNormal that, dynamic hint}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_custom_name_method_twin_normal( + that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 208)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: + kCrateApiMiscNoTwinExampleAStructWithCustomNameMethodTwinNormalMethodWithCustomNameTwinNormalConstMeta, + argValues: [that], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiMiscNoTwinExampleAStructWithCustomNameMethodTwinNormalMethodWithCustomNameTwinNormalConstMeta => + const TaskConstMeta( + debugName: + "struct_with_custom_name_method_twin_normal_method_with_custom_name_twin_normal", + argNames: ["that"], + ); + @override Future crateApiMiscNoTwinExampleAStructWithImplBlockInAnotherFileF( {required StructWithImplBlockInAnotherFileDependency arg, dynamic hint}) { @@ -10667,7 +10770,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_impl_block_in_another_file_dependency( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 210, port: port_); + funcId: 213, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10698,7 +10801,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleB( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 207, port: port_); + funcId: 210, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -10731,7 +10834,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleB( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 208, port: port_); + funcId: 211, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10762,7 +10865,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithImplBlockInMultiFile( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 209, port: port_); + funcId: 212, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10790,7 +10893,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 206, port: port_); + funcId: 209, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10819,7 +10922,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_empty_twin_normal(empty, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 214, port: port_); + funcId: 217, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_empty_twin_normal, @@ -10844,7 +10947,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 211, port: port_); + funcId: 214, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10871,7 +10974,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_my_size(l, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 212, port: port_); + funcId: 215, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_my_size, @@ -10898,7 +11001,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(names, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 213, port: port_); + funcId: 216, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -10925,7 +11028,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_new_type_int_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 215, port: port_); + funcId: 218, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_new_type_int_twin_normal, @@ -10952,7 +11055,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_f_64(opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 219, port: port_); + funcId: 222, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -10994,7 +11097,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_bool(boolbox, serializer); sse_encode_opt_box_exotic_optionals_twin_normal(structbox, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 221, port: port_); + funcId: 224, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -11032,7 +11135,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_exotic_optionals_twin_normal( opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 218, port: port_); + funcId: 221, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -11062,7 +11165,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(left, serializer); sse_encode_f_64(right, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 216, port: port_); + funcId: 219, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -11089,7 +11192,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(document, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 217, port: port_); + funcId: 220, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_element_twin_normal, @@ -11116,7 +11219,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_opt_vecs_twin_normal(opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 220, port: port_); + funcId: 223, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_vecs_twin_normal, @@ -11146,7 +11249,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_f_64(myF64, serializer); sse_encode_opt_box_autoadd_bool(myBool, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 222, port: port_); + funcId: 225, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -11175,7 +11278,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 225, port: port_); + funcId: 228, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -11202,7 +11305,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 224, port: port_); + funcId: 227, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -11229,7 +11332,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 223, port: port_); + funcId: 226, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -11258,7 +11361,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_simple_struct_for_borrow_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 226, port: port_); + funcId: 229, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_for_borrow_twin_normal, @@ -11286,7 +11389,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(n, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 227, port: port_); + funcId: 230, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_vec_of_primitive_pack_twin_normal, @@ -11322,7 +11425,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(myF64, serializer); sse_encode_bool(myBool, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 228, port: port_); + funcId: 231, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -11349,7 +11452,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(myU32, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 229, port: port_); + funcId: 232, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -11377,7 +11480,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_u_8_array_1600(blob, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 234, port: port_); + funcId: 237, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_blob_twin_rust_async, @@ -11407,7 +11510,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_test_id_twin_rust_async(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 238, port: port_); + funcId: 241, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_rust_async, @@ -11435,7 +11538,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 230, port: port_); + funcId: 233, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_5, @@ -11464,7 +11567,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 231, port: port_); + funcId: 234, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_point_twin_rust_async_array_2, @@ -11493,7 +11596,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64_array_16(array, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 239, port: port_); + funcId: 242, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -11523,7 +11626,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_test_id_twin_rust_async_array_4(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 240, port: port_); + funcId: 243, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_rust_async_array_2, @@ -11553,7 +11656,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8_array_32(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 232, port: port_); + funcId: 235, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_message_id_twin_rust_async, @@ -11583,7 +11686,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8_array_8(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 236, port: port_); + funcId: 239, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_box_feed_id_twin_rust_async, @@ -11613,7 +11716,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feed_id_twin_rust_async(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 237, port: port_); + funcId: 240, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_box_u_8_array_8, @@ -11643,7 +11746,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_blob_twin_rust_async(blob, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 235, port: port_); + funcId: 238, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_1600, @@ -11672,7 +11775,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_message_id_twin_rust_async(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 233, port: port_); + funcId: 236, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_32, @@ -11700,7 +11803,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_u_8_array_1600(blob, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 245)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 248)!; }, codec: SseCodec( decodeSuccessData: sse_decode_blob_twin_sync, @@ -11727,7 +11830,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_test_id_twin_sync(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 249)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 252)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_sync, @@ -11752,7 +11855,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 241)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 244)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_5, @@ -11778,7 +11881,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 242)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 245)!; }, codec: SseCodec( decodeSuccessData: sse_decode_point_twin_sync_array_2, @@ -11806,7 +11909,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64_array_16(array, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 250)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 253)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -11833,7 +11936,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_test_id_twin_sync_array_4(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 251)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 254)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_sync_array_2, @@ -11860,7 +11963,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8_array_32(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 243)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 246)!; }, codec: SseCodec( decodeSuccessData: sse_decode_message_id_twin_sync, @@ -11887,7 +11990,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8_array_8(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 247)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 250)!; }, codec: SseCodec( decodeSuccessData: sse_decode_box_feed_id_twin_sync, @@ -11915,7 +12018,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feed_id_twin_sync(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 248)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 251)!; }, codec: SseCodec( decodeSuccessData: sse_decode_box_u_8_array_8, @@ -11943,7 +12046,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_blob_twin_sync(blob, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 246)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 249)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_1600, @@ -11971,7 +12074,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_message_id_twin_sync(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 244)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 247)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_32, @@ -12000,7 +12103,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_customized_twin_rust_async(val, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 253, port: port_); + funcId: 256, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -12031,7 +12134,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_user_id_twin_rust_async(userId, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 254, port: port_); + funcId: 257, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_user_id_twin_rust_async, @@ -12059,7 +12162,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_customized_twin_sync(val, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 258)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 261)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -12087,7 +12190,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_user_id_twin_sync(userId, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 259)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 262)!; }, codec: SseCodec( decodeSuccessData: sse_decode_user_id_twin_sync, @@ -12117,7 +12220,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_basic_general_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 278, port: port_); + funcId: 281, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_general_enum_twin_normal, @@ -12148,7 +12251,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_basic_primitive_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 277, port: port_); + funcId: 280, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_primitive_enum_twin_normal, @@ -12179,7 +12282,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_basic_struct_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 279, port: port_); + funcId: 282, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_struct_twin_normal, @@ -12209,7 +12312,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 274, port: port_); + funcId: 277, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -12238,7 +12341,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 276, port: port_); + funcId: 279, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -12267,7 +12370,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 272, port: port_); + funcId: 275, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_32, @@ -12296,7 +12399,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 273, port: port_); + funcId: 276, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -12325,7 +12428,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 263, port: port_); + funcId: 266, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_16, @@ -12354,7 +12457,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 264, port: port_); + funcId: 267, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -12383,7 +12486,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 265, port: port_); + funcId: 268, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_64, @@ -12412,7 +12515,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 262, port: port_); + funcId: 265, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_8, @@ -12441,7 +12544,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 270, port: port_); + funcId: 273, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_isize, @@ -12470,7 +12573,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 275, port: port_); + funcId: 278, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -12499,7 +12602,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 267, port: port_); + funcId: 270, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_16, @@ -12528,7 +12631,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 268, port: port_); + funcId: 271, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -12557,7 +12660,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 269, port: port_); + funcId: 272, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -12586,7 +12689,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 266, port: port_); + funcId: 269, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8, @@ -12615,7 +12718,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 271, port: port_); + funcId: 274, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_usize, @@ -12645,7 +12748,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_general_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 294, port: port_); + funcId: 297, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_general_enum_twin_normal, @@ -12676,7 +12779,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_primitive_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 293, port: port_); + funcId: 296, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_primitive_enum_twin_normal, @@ -12707,7 +12810,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_struct_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 295, port: port_); + funcId: 298, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_struct_twin_normal, @@ -12738,7 +12841,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 290, port: port_); + funcId: 293, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_bool, @@ -12768,7 +12871,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 292, port: port_); + funcId: 295, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_list_prim_u_8_strict, @@ -12798,7 +12901,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 288, port: port_); + funcId: 291, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_32_strict, @@ -12828,7 +12931,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_64_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 289, port: port_); + funcId: 292, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_64_strict, @@ -12858,7 +12961,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 281, port: port_); + funcId: 284, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_16_strict, @@ -12888,7 +12991,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 282, port: port_); + funcId: 285, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_32_strict, @@ -12918,7 +13021,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 283, port: port_); + funcId: 286, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_64_strict, @@ -12948,7 +13051,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 280, port: port_); + funcId: 283, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_8_strict, @@ -12978,7 +13081,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 291, port: port_); + funcId: 294, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -13008,7 +13111,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 285, port: port_); + funcId: 288, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_16_strict, @@ -13038,7 +13141,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 286, port: port_); + funcId: 289, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_32_strict, @@ -13068,7 +13171,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 287, port: port_); + funcId: 290, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_64_strict, @@ -13098,7 +13201,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 284, port: port_); + funcId: 287, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -13128,7 +13231,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_general_enum_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 310, port: port_); + funcId: 313, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_general_enum_twin_rust_async, @@ -13159,7 +13262,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_primitive_enum_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 309, port: port_); + funcId: 312, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_primitive_enum_twin_rust_async, @@ -13190,7 +13293,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_struct_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 311, port: port_); + funcId: 314, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_struct_twin_rust_async, @@ -13221,7 +13324,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 306, port: port_); + funcId: 309, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_bool, @@ -13251,7 +13354,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 308, port: port_); + funcId: 311, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_list_prim_u_8_strict, @@ -13281,7 +13384,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 304, port: port_); + funcId: 307, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_32_strict, @@ -13311,7 +13414,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_64_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 305, port: port_); + funcId: 308, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_64_strict, @@ -13341,7 +13444,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 297, port: port_); + funcId: 300, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_16_strict, @@ -13371,7 +13474,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 298, port: port_); + funcId: 301, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_32_strict, @@ -13401,7 +13504,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 299, port: port_); + funcId: 302, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_64_strict, @@ -13431,7 +13534,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 296, port: port_); + funcId: 299, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_8_strict, @@ -13461,7 +13564,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 307, port: port_); + funcId: 310, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -13491,7 +13594,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 301, port: port_); + funcId: 304, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_16_strict, @@ -13521,7 +13624,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 302, port: port_); + funcId: 305, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_32_strict, @@ -13551,7 +13654,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 303, port: port_); + funcId: 306, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_64_strict, @@ -13581,7 +13684,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 300, port: port_); + funcId: 303, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -13610,7 +13713,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_general_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 326)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 329)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_general_enum_twin_sync, @@ -13640,7 +13743,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_primitive_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 325)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 328)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_primitive_enum_twin_sync, @@ -13670,7 +13773,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 327)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 330)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_struct_twin_sync, @@ -13700,7 +13803,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_bool(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 322)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 325)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_bool, @@ -13729,7 +13832,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_list_prim_u_8_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 324)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 327)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_list_prim_u_8_strict, @@ -13758,7 +13861,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_32_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 320)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 323)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_32_strict, @@ -13787,7 +13890,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_64_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 321)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 324)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_64_strict, @@ -13816,7 +13919,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_16_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 313)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 316)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_16_strict, @@ -13845,7 +13948,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_32_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 314)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 317)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_32_strict, @@ -13874,7 +13977,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_64_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 315)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 318)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_64_strict, @@ -13902,7 +14005,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_8_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 312)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 315)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_8_strict, @@ -13931,7 +14034,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 323)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 326)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -13960,7 +14063,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_16_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 317)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 320)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_16_strict, @@ -13989,7 +14092,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_32_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 318)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 321)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_32_strict, @@ -14018,7 +14121,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_64_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 319)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 322)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_64_strict, @@ -14046,7 +14149,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 316)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 319)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -14076,7 +14179,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_general_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 344, port: port_); + funcId: 347, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_general_enum_twin_normal, @@ -14107,7 +14210,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_primitive_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 343, port: port_); + funcId: 346, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_primitive_enum_twin_normal, @@ -14138,7 +14241,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_struct_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 345, port: port_); + funcId: 348, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_struct_twin_normal, @@ -14169,7 +14272,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 340, port: port_); + funcId: 343, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_bool, @@ -14199,7 +14302,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 342, port: port_); + funcId: 345, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_list_prim_u_8_strict, @@ -14229,7 +14332,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 338, port: port_); + funcId: 341, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_32, @@ -14259,7 +14362,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 339, port: port_); + funcId: 342, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_64, @@ -14289,7 +14392,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 329, port: port_); + funcId: 332, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_16, @@ -14319,7 +14422,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 330, port: port_); + funcId: 333, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -14349,7 +14452,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 331, port: port_); + funcId: 334, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_64, @@ -14379,7 +14482,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 328, port: port_); + funcId: 331, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_8, @@ -14409,7 +14512,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 336, port: port_); + funcId: 339, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_isize, @@ -14439,7 +14542,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 341, port: port_); + funcId: 344, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_String, @@ -14469,7 +14572,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 333, port: port_); + funcId: 336, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_16, @@ -14499,7 +14602,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 334, port: port_); + funcId: 337, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_32, @@ -14529,7 +14632,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 335, port: port_); + funcId: 338, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_64, @@ -14559,7 +14662,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 332, port: port_); + funcId: 335, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_8, @@ -14589,7 +14692,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 337, port: port_); + funcId: 340, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_usize, @@ -14620,7 +14723,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_general_enum_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 362, port: port_); + funcId: 365, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -14654,7 +14757,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Map_i_32_basic_primitive_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 361, port: port_); + funcId: 364, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -14686,7 +14789,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_struct_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 363, port: port_); + funcId: 366, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_struct_twin_rust_async, @@ -14717,7 +14820,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 358, port: port_); + funcId: 361, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_bool, @@ -14747,7 +14850,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 360, port: port_); + funcId: 363, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_list_prim_u_8_strict, @@ -14777,7 +14880,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 356, port: port_); + funcId: 359, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_32, @@ -14807,7 +14910,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 357, port: port_); + funcId: 360, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_64, @@ -14837,7 +14940,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 347, port: port_); + funcId: 350, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_16, @@ -14867,7 +14970,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 348, port: port_); + funcId: 351, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -14897,7 +15000,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 349, port: port_); + funcId: 352, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_64, @@ -14927,7 +15030,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 346, port: port_); + funcId: 349, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_8, @@ -14957,7 +15060,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 354, port: port_); + funcId: 357, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_isize, @@ -14987,7 +15090,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 359, port: port_); + funcId: 362, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_String, @@ -15017,7 +15120,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 351, port: port_); + funcId: 354, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_16, @@ -15047,7 +15150,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 352, port: port_); + funcId: 355, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_32, @@ -15077,7 +15180,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 353, port: port_); + funcId: 356, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_64, @@ -15107,7 +15210,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 350, port: port_); + funcId: 353, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_8, @@ -15137,7 +15240,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 355, port: port_); + funcId: 358, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_usize, @@ -15166,7 +15269,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_general_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 380)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 383)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_general_enum_twin_sync, @@ -15196,7 +15299,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_primitive_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 379)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 382)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_primitive_enum_twin_sync, @@ -15226,7 +15329,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_basic_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 381)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 384)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_struct_twin_sync, @@ -15256,7 +15359,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_bool(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 376)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 379)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_bool, @@ -15285,7 +15388,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_list_prim_u_8_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 378)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 381)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_list_prim_u_8_strict, @@ -15314,7 +15417,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 374)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 377)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_32, @@ -15343,7 +15446,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 375)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 378)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_64, @@ -15372,7 +15475,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 365)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 368)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_16, @@ -15401,7 +15504,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 366)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 369)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -15430,7 +15533,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 367)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 370)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_64, @@ -15459,7 +15562,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 364)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 367)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_8, @@ -15488,7 +15591,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_isize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 372)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 375)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_isize, @@ -15517,7 +15620,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 377)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 380)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_String, @@ -15546,7 +15649,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 369)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 372)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_16, @@ -15575,7 +15678,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 370)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 373)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_32, @@ -15604,7 +15707,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 371)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 374)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_64, @@ -15633,7 +15736,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 368)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 371)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_8, @@ -15662,7 +15765,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_usize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 373)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 376)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_usize, @@ -15693,7 +15796,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_general_enum_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 398, port: port_); + funcId: 401, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -15726,7 +15829,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_primitive_enum_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 397, port: port_); + funcId: 400, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -15758,7 +15861,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_basic_struct_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 399, port: port_); + funcId: 402, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_basic_struct_twin_normal, @@ -15789,7 +15892,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 394, port: port_); + funcId: 397, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_bool, @@ -15819,7 +15922,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 396, port: port_); + funcId: 399, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_list_prim_u_8_strict, @@ -15849,7 +15952,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 392, port: port_); + funcId: 395, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_32, @@ -15879,7 +15982,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 393, port: port_); + funcId: 396, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -15909,7 +16012,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 383, port: port_); + funcId: 386, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_16, @@ -15939,7 +16042,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 384, port: port_); + funcId: 387, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -15969,7 +16072,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 385, port: port_); + funcId: 388, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_64, @@ -15999,7 +16102,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 382, port: port_); + funcId: 385, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_8, @@ -16029,7 +16132,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 390, port: port_); + funcId: 393, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_isize, @@ -16059,7 +16162,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 395, port: port_); + funcId: 398, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_String, @@ -16089,7 +16192,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 387, port: port_); + funcId: 390, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_16, @@ -16119,7 +16222,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 388, port: port_); + funcId: 391, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_32, @@ -16149,7 +16252,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 389, port: port_); + funcId: 392, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_64, @@ -16179,7 +16282,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 386, port: port_); + funcId: 389, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_8, @@ -16209,7 +16312,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 391, port: port_); + funcId: 394, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_usize, @@ -16240,7 +16343,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_general_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 416, port: port_); + funcId: 419, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -16273,7 +16376,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_primitive_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 415, port: port_); + funcId: 418, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -16306,7 +16409,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_struct_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 417, port: port_); + funcId: 420, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -16338,7 +16441,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 412, port: port_); + funcId: 415, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_bool, @@ -16368,7 +16471,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 414, port: port_); + funcId: 417, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_list_prim_u_8_strict, @@ -16398,7 +16501,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 410, port: port_); + funcId: 413, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_32, @@ -16428,7 +16531,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 411, port: port_); + funcId: 414, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -16458,7 +16561,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 401, port: port_); + funcId: 404, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_16, @@ -16488,7 +16591,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 402, port: port_); + funcId: 405, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -16518,7 +16621,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 403, port: port_); + funcId: 406, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_64, @@ -16548,7 +16651,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 400, port: port_); + funcId: 403, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_8, @@ -16578,7 +16681,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 408, port: port_); + funcId: 411, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_isize, @@ -16608,7 +16711,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 413, port: port_); + funcId: 416, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_String, @@ -16638,7 +16741,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 405, port: port_); + funcId: 408, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_16, @@ -16668,7 +16771,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 406, port: port_); + funcId: 409, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_32, @@ -16698,7 +16801,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 407, port: port_); + funcId: 410, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_64, @@ -16728,7 +16831,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 404, port: port_); + funcId: 407, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_8, @@ -16758,7 +16861,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 409, port: port_); + funcId: 412, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_usize, @@ -16788,7 +16891,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_basic_general_enum_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 434)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 437)!; }, codec: SseCodec( decodeSuccessData: @@ -16820,7 +16923,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_basic_primitive_enum_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 433)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 436)!; }, codec: SseCodec( decodeSuccessData: @@ -16851,7 +16954,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_basic_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 435)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 438)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_basic_struct_twin_sync, @@ -16881,7 +16984,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_bool(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 430)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 433)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_bool, @@ -16910,7 +17013,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_list_prim_u_8_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 432)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 435)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_list_prim_u_8_strict, @@ -16939,7 +17042,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 428)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 431)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_32, @@ -16968,7 +17071,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 429)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 432)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -16997,7 +17100,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 419)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 422)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_16, @@ -17026,7 +17129,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 420)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 423)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -17055,7 +17158,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 421)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 424)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_64, @@ -17084,7 +17187,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 418)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 421)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_8, @@ -17113,7 +17216,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_isize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 426)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 429)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_isize, @@ -17142,7 +17245,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 431)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 434)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_String, @@ -17171,7 +17274,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 423)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 426)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_16, @@ -17200,7 +17303,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 424)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 427)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_32, @@ -17229,7 +17332,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 425)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 428)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_64, @@ -17258,7 +17361,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 422)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 425)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_8, @@ -17287,7 +17390,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_usize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 427)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 430)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_usize, @@ -17318,7 +17421,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_basic_general_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 452, port: port_); + funcId: 455, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_general_enum_twin_rust_async, @@ -17349,7 +17452,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_basic_primitive_enum_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 451, port: port_); + funcId: 454, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_primitive_enum_twin_rust_async, @@ -17380,7 +17483,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_basic_struct_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 453, port: port_); + funcId: 456, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_struct_twin_rust_async, @@ -17411,7 +17514,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 448, port: port_); + funcId: 451, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -17441,7 +17544,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 450, port: port_); + funcId: 453, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -17471,7 +17574,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 446, port: port_); + funcId: 449, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_32, @@ -17501,7 +17604,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 447, port: port_); + funcId: 450, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -17531,7 +17634,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 437, port: port_); + funcId: 440, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_16, @@ -17561,7 +17664,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 438, port: port_); + funcId: 441, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -17591,7 +17694,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 439, port: port_); + funcId: 442, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_64, @@ -17621,7 +17724,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 436, port: port_); + funcId: 439, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_8, @@ -17651,7 +17754,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 444, port: port_); + funcId: 447, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_isize, @@ -17681,7 +17784,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 449, port: port_); + funcId: 452, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -17711,7 +17814,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 441, port: port_); + funcId: 444, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_16, @@ -17741,7 +17844,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 442, port: port_); + funcId: 445, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -17771,7 +17874,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 443, port: port_); + funcId: 446, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -17801,7 +17904,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 440, port: port_); + funcId: 443, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8, @@ -17831,7 +17934,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 445, port: port_); + funcId: 448, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_usize, @@ -17860,7 +17963,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_basic_general_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 470)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 473)!; }, codec: SseCodec( decodeSuccessData: sse_decode_basic_general_enum_twin_sync, @@ -17890,7 +17993,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_basic_primitive_enum_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 469)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 472)!; }, codec: SseCodec( decodeSuccessData: sse_decode_basic_primitive_enum_twin_sync, @@ -17920,7 +18023,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_basic_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 471)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 474)!; }, codec: SseCodec( decodeSuccessData: sse_decode_basic_struct_twin_sync, @@ -17948,7 +18051,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 466)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 469)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -17976,7 +18079,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 468)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 471)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -18004,7 +18107,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 464)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 467)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_32, @@ -18032,7 +18135,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 465)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 468)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -18060,7 +18163,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 455)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 458)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_16, @@ -18088,7 +18191,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 456)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 459)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -18116,7 +18219,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 457)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 460)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_64, @@ -18144,7 +18247,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 454)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 457)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_8, @@ -18172,7 +18275,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_isize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 462)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 465)!; }, codec: SseCodec( decodeSuccessData: sse_decode_isize, @@ -18200,7 +18303,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 467)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 470)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -18228,7 +18331,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_16(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 459)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 462)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_16, @@ -18256,7 +18359,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 460)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 463)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -18284,7 +18387,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 461)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 464)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -18312,7 +18415,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 458)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 461)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8, @@ -18340,7 +18443,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_usize(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 463)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 466)!; }, codec: SseCodec( decodeSuccessData: sse_decode_usize, @@ -18370,7 +18473,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 479, port: port_); + funcId: 482, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18400,7 +18503,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 477, port: port_); + funcId: 480, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18431,7 +18534,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_benchmark_binary_tree_twin_normal( tree, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 475, port: port_); + funcId: 478, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18461,7 +18564,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 480, port: port_); + funcId: 483, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -18491,7 +18594,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 478, port: port_); + funcId: 481, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -18521,7 +18624,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 476, port: port_); + funcId: 479, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_binary_tree_twin_normal, @@ -18550,7 +18653,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 485, port: port_); + funcId: 488, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18580,7 +18683,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 483, port: port_); + funcId: 486, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18609,7 +18712,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_benchmark_blob_twin_normal(blob, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 481, port: port_); + funcId: 484, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18639,7 +18742,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 486, port: port_); + funcId: 489, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -18669,7 +18772,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 484, port: port_); + funcId: 487, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -18699,7 +18802,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 482, port: port_); + funcId: 485, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_blob_twin_normal, @@ -18728,7 +18831,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(bytes, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 473, port: port_); + funcId: 476, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -18758,7 +18861,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 474, port: port_); + funcId: 477, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -18786,7 +18889,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 472, port: port_); + funcId: 475, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18816,7 +18919,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 494, port: port_); + funcId: 497, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18846,7 +18949,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 492, port: port_); + funcId: 495, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18877,7 +18980,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_benchmark_binary_tree_twin_rust_async( tree, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 490, port: port_); + funcId: 493, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -18907,7 +19010,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 495, port: port_); + funcId: 498, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -18937,7 +19040,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 493, port: port_); + funcId: 496, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -18967,7 +19070,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 491, port: port_); + funcId: 494, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_binary_tree_twin_rust_async, @@ -18997,7 +19100,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 500, port: port_); + funcId: 503, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19027,7 +19130,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 498, port: port_); + funcId: 501, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19057,7 +19160,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_benchmark_blob_twin_rust_async(blob, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 496, port: port_); + funcId: 499, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19087,7 +19190,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 501, port: port_); + funcId: 504, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -19117,7 +19220,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 499, port: port_); + funcId: 502, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19147,7 +19250,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 497, port: port_); + funcId: 500, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_blob_twin_rust_async, @@ -19177,7 +19280,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(bytes, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 488, port: port_); + funcId: 491, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -19207,7 +19310,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 489, port: port_); + funcId: 492, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19236,7 +19339,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 487, port: port_); + funcId: 490, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19265,7 +19368,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 509)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 512)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19294,7 +19397,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 507)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 510)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19323,7 +19426,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_benchmark_binary_tree_twin_sync( tree, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 505)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 508)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19352,7 +19455,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 510)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 513)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -19381,7 +19484,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 508)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 511)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19410,7 +19513,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 506)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 509)!; }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_binary_tree_twin_sync, @@ -19438,7 +19541,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 515)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 518)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19467,7 +19570,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 513)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 516)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19495,7 +19598,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_benchmark_blob_twin_sync(blob, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 511)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 514)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19524,7 +19627,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 516)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 519)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -19553,7 +19656,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 514)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 517)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19582,7 +19685,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 512)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 515)!; }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_blob_twin_sync, @@ -19610,7 +19713,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(bytes, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 503)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 506)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -19639,7 +19742,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 504)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 507)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19666,7 +19769,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 502)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 505)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -19696,7 +19799,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Local(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 518, port: port_); + funcId: 521, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Local, @@ -19726,7 +19829,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Utc(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 517, port: port_); + funcId: 520, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Utc, @@ -19756,7 +19859,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Duration(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 521, port: port_); + funcId: 524, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -19789,7 +19892,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_Chrono_Duration(durations, serializer); sse_encode_Chrono_Local(since, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 523, port: port_); + funcId: 526, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Local, @@ -19822,7 +19925,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_Chrono_Naive(timestamps, serializer); sse_encode_Chrono_Naive(epoch, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 522, port: port_); + funcId: 525, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Duration, @@ -19852,7 +19955,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feature_chrono_twin_rust_async(mine, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 526, port: port_); + funcId: 529, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -19882,7 +19985,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Naive(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 519, port: port_); + funcId: 522, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Naive, @@ -19912,7 +20015,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_Chrono_Utc(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 520, port: port_); + funcId: 523, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_Chrono_Utc, @@ -19941,7 +20044,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 524, port: port_); + funcId: 527, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_rust_async, @@ -19970,7 +20073,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 525, port: port_); + funcId: 528, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_rust_async, @@ -19998,7 +20101,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Local(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 528)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 531)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Local, @@ -20026,7 +20129,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Utc(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 527)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 530)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Utc, @@ -20054,7 +20157,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Duration(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 531)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 534)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -20085,7 +20188,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Chrono_Duration(durations, serializer); sse_encode_Chrono_Local(since, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 533)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 536)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Local, @@ -20116,7 +20219,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Chrono_Naive(timestamps, serializer); sse_encode_Chrono_Naive(epoch, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 532)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 535)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Duration, @@ -20144,7 +20247,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feature_chrono_twin_sync(mine, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 536)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 539)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -20172,7 +20275,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Naive(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 529)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 532)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Naive, @@ -20201,7 +20304,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_Chrono_Utc(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 530)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 533)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_Chrono_Utc, @@ -20228,7 +20331,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 534)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 537)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_sync, @@ -20256,7 +20359,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 535)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 538)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_sync, @@ -20285,7 +20388,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 539, port: port_); + funcId: 542, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20314,7 +20417,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 538, port: port_); + funcId: 541, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20344,7 +20447,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 537, port: port_); + funcId: 540, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20376,7 +20479,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_comments_twin_rust_async( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 541, port: port_); + funcId: 544, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20406,7 +20509,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 540, port: port_); + funcId: 543, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20435,7 +20538,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 544)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 547)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20463,7 +20566,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 543)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 546)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20492,7 +20595,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 542)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 545)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20522,7 +20625,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_comments_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 546)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 549)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20551,7 +20654,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 545)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 548)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20585,7 +20688,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs_demo_struct_for_rust_call_dart_twin_rust_async_Output_demo_struct_for_rust_call_dart_twin_rust_async_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 551, port: port_); + funcId: 554, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20619,7 +20722,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callback, serializer); sse_encode_i_32(numTimes, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 554, port: port_); + funcId: 557, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20650,7 +20753,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 548, port: port_); + funcId: 551, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20684,7 +20787,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callback, serializer); sse_encode_opt_String(expectOutput, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 555, port: port_); + funcId: 558, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20715,7 +20818,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs__Output_String_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 550, port: port_); + funcId: 553, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20746,7 +20849,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs__Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 547, port: port_); + funcId: 550, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20780,7 +20883,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_rust_async_Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 549, port: port_); + funcId: 552, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20814,7 +20917,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 552, port: port_); + funcId: 555, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20845,7 +20948,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 553, port: port_); + funcId: 556, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -20875,7 +20978,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 556, port: port_); + funcId: 559, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -20905,7 +21008,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 571, port: port_); + funcId: 574, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -20935,7 +21038,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 567, port: port_); + funcId: 570, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_dart_opaque_twin_rust_async, @@ -20966,7 +21069,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartOpaque(opaque1, serializer); sse_encode_DartOpaque(opaque2, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 565, port: port_); + funcId: 568, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_dart_opaque_nested_twin_rust_async, @@ -20996,7 +21099,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 570, port: port_); + funcId: 573, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21027,7 +21130,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_dart_opaque_twin_rust_async( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 568, port: port_); + funcId: 571, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21058,7 +21161,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_dart_opaque_nested_twin_rust_async( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 566, port: port_); + funcId: 569, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21088,7 +21191,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque_array_1(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 562, port: port_); + funcId: 565, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21118,7 +21221,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 559, port: port_); + funcId: 562, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque_array_1, @@ -21148,7 +21251,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 561, port: port_); + funcId: 564, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21178,7 +21281,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 558, port: port_); + funcId: 561, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -21208,7 +21311,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 557, port: port_); + funcId: 560, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -21238,7 +21341,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 563, port: port_); + funcId: 566, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21268,7 +21371,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 560, port: port_); + funcId: 563, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -21298,7 +21401,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 564, port: port_); + funcId: 567, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21329,7 +21432,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(id, serializer); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 569, port: port_); + funcId: 572, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21357,7 +21460,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 572)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 575)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -21385,7 +21488,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 587)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 590)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -21414,7 +21517,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 583)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 586)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_dart_opaque_twin_sync, @@ -21444,7 +21547,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque1, serializer); sse_encode_DartOpaque(opaque2, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 581)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 584)!; }, codec: SseCodec( decodeSuccessData: sse_decode_dart_opaque_nested_twin_sync, @@ -21472,7 +21575,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 586)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 589)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21500,7 +21603,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_dart_opaque_twin_sync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 584)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 587)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21528,7 +21631,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_dart_opaque_nested_twin_sync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 582)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 585)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21556,7 +21659,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque_array_1(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 578)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 581)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21584,7 +21687,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 575)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 578)!; }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque_array_1, @@ -21612,7 +21715,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 577)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 580)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21640,7 +21743,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 574)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 577)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -21668,7 +21771,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 573)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 576)!; }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -21696,7 +21799,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 579)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 582)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21724,7 +21827,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 576)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 579)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -21752,7 +21855,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 580)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 583)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21781,7 +21884,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(id, serializer); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 585)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 588)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21814,7 +21917,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_StreamSink_i_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 590, port: port_); + funcId: 593, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21844,7 +21947,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 591, port: port_); + funcId: 594, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -21873,7 +21976,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 588, port: port_); + funcId: 591, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -21905,7 +22008,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDroppableTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 589, port: port_); + funcId: 592, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21937,7 +22040,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDroppableTwinSync( that, serializer); sse_encode_StreamSink_i_32_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 594)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 597)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21965,7 +22068,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 595)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 598)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -21993,7 +22096,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 592)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 595)!; }, codec: SseCodec( decodeSuccessData: @@ -22024,7 +22127,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDroppableTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 593)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 596)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22054,7 +22157,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_simple_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 596, port: port_); + funcId: 599, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_simple_twin_rust_async, @@ -22084,7 +22187,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_with_discriminant_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 600, port: port_); + funcId: 603, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_discriminant_twin_rust_async, @@ -22115,7 +22218,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_mixed_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 597, port: port_); + funcId: 600, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_mixed_twin_rust_async, @@ -22146,7 +22249,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_struct_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 599, port: port_); + funcId: 602, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_struct_twin_rust_async, @@ -22177,7 +22280,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_tuple_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 598, port: port_); + funcId: 601, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_tuple_twin_rust_async, @@ -22207,7 +22310,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_weekdays_twin_rust_async(weekday, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 603, port: port_); + funcId: 606, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_weekdays_twin_rust_async, @@ -22237,7 +22340,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_kitchen_sink_twin_rust_async(val, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 605, port: port_); + funcId: 608, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_kitchen_sink_twin_rust_async, @@ -22267,7 +22370,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 602, port: port_); + funcId: 605, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_weekdays_twin_rust_async, @@ -22297,7 +22400,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_measure_twin_rust_async(measure, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 604, port: port_); + funcId: 607, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_measure_twin_rust_async, @@ -22327,7 +22430,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_note_twin_rust_async(note, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 601, port: port_); + funcId: 604, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -22356,7 +22459,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_simple_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 606)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 609)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_simple_twin_sync, @@ -22385,7 +22488,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_with_discriminant_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 610)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 613)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_discriminant_twin_sync, @@ -22414,7 +22517,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_with_item_mixed_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 607)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 610)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_mixed_twin_sync, @@ -22443,7 +22546,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_with_item_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 609)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 612)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_struct_twin_sync, @@ -22472,7 +22575,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_with_item_tuple_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 608)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 611)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_tuple_twin_sync, @@ -22501,7 +22604,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_weekdays_twin_sync(weekday, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 613)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 616)!; }, codec: SseCodec( decodeSuccessData: sse_decode_weekdays_twin_sync, @@ -22530,7 +22633,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_kitchen_sink_twin_sync(val, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 615)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 618)!; }, codec: SseCodec( decodeSuccessData: sse_decode_kitchen_sink_twin_sync, @@ -22559,7 +22662,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 612)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 615)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_weekdays_twin_sync, @@ -22587,7 +22690,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_measure_twin_sync(measure, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 614)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 617)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_measure_twin_sync, @@ -22615,7 +22718,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_note_twin_sync(note, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 611)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 614)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -22644,7 +22747,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 617, port: port_); + funcId: 620, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22675,7 +22778,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(address, serializer); sse_encode_String(payload, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 618, port: port_); + funcId: 621, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22705,7 +22808,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_event_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 619, port: port_); + funcId: 622, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -22736,7 +22839,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_event_twin_rust_async_Sse(listener, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 616, port: port_); + funcId: 619, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22766,7 +22869,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 624, port: port_); + funcId: 627, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22795,7 +22898,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 625, port: port_); + funcId: 628, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -22825,7 +22928,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 623, port: port_); + funcId: 626, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -22856,7 +22959,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_custom_nested_error_outer_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 626, port: port_); + funcId: 629, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22887,7 +22990,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_custom_struct_error_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 627, port: port_); + funcId: 630, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22917,7 +23020,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(message, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 644, port: port_); + funcId: 647, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_custom_struct_twin_rust_async, @@ -22947,7 +23050,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 647, port: port_); + funcId: 650, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22978,7 +23081,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 648, port: port_); + funcId: 651, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23008,7 +23111,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 645, port: port_); + funcId: 648, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23038,7 +23141,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 646, port: port_); + funcId: 649, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23068,7 +23171,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 620, port: port_); + funcId: 623, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23097,7 +23200,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 621, port: port_); + funcId: 624, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23126,7 +23229,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 622, port: port_); + funcId: 625, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23155,7 +23258,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 637, port: port_); + funcId: 640, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23184,7 +23287,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 631, port: port_); + funcId: 634, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23213,7 +23316,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 632, port: port_); + funcId: 635, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23242,7 +23345,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 633, port: port_); + funcId: 636, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23271,7 +23374,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 634, port: port_); + funcId: 637, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23300,7 +23403,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 635, port: port_); + funcId: 638, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23329,7 +23432,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 628, port: port_); + funcId: 631, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23359,7 +23462,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(variant, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 630, port: port_); + funcId: 633, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23388,7 +23491,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 629, port: port_); + funcId: 632, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23418,7 +23521,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 639, port: port_); + funcId: 642, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_some_struct_twin_rust_async, @@ -23448,7 +23551,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_some_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 642, port: port_); + funcId: 645, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23479,7 +23582,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_some_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 643, port: port_); + funcId: 646, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23509,7 +23612,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 640, port: port_); + funcId: 643, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23539,7 +23642,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 641, port: port_); + funcId: 644, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23571,7 +23674,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 638, port: port_); + funcId: 641, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23601,7 +23704,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 636, port: port_); + funcId: 639, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23628,7 +23731,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 653)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 656)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23655,7 +23758,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 654)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 657)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23683,7 +23786,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 652)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 655)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23713,7 +23816,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_nested_error_outer_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 655)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 658)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23742,7 +23845,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_error_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 656)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 659)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23771,7 +23874,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(message, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 673)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 676)!; }, codec: SseCodec( decodeSuccessData: sse_decode_custom_struct_twin_sync, @@ -23800,7 +23903,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 676)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 679)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23829,7 +23932,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_custom_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 677)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 680)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23858,7 +23961,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 674)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 677)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23886,7 +23989,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 675)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 678)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -23914,7 +24017,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 649)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 652)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23941,7 +24044,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 650)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 653)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23968,7 +24071,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 651)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 654)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23995,7 +24098,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 666)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 669)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24022,7 +24125,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 660)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 663)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24050,7 +24153,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 661)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 664)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24077,7 +24180,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 662)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 665)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24104,7 +24207,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 663)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 666)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24131,7 +24234,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 664)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 667)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24158,7 +24261,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 657)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 660)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24186,7 +24289,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(variant, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 659)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 662)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24213,7 +24316,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 658)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 661)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24242,7 +24345,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(value, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 668)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 671)!; }, codec: SseCodec( decodeSuccessData: sse_decode_some_struct_twin_sync, @@ -24270,7 +24373,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_some_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 671)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 674)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24299,7 +24402,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_some_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 672)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 675)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24327,7 +24430,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 669)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 672)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24355,7 +24458,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 670)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 673)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24386,7 +24489,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 667)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 670)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24414,7 +24517,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 665)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 668)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24443,7 +24546,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 681, port: port_); + funcId: 684, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_new_simple_struct, @@ -24472,7 +24575,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 680, port: port_); + funcId: 683, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_old_simple_struct, @@ -24502,7 +24605,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_my_enum(myEnum, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 679, port: port_); + funcId: 682, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -24532,7 +24635,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_struct(myStruct, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 678, port: port_); + funcId: 681, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -24560,7 +24663,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 685)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 688)!; }, codec: SseCodec( decodeSuccessData: sse_decode_new_simple_struct, @@ -24588,7 +24691,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 684)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 687)!; }, codec: SseCodec( decodeSuccessData: sse_decode_old_simple_struct, @@ -24616,7 +24719,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_my_enum(myEnum, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 683)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 686)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -24644,7 +24747,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_struct(myStruct, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 682)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 685)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -24674,7 +24777,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 686, port: port_); + funcId: 689, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -24704,7 +24807,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_list_prim_u_8_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 690, port: port_); + funcId: 693, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_list_prim_u_8_strict, @@ -24734,7 +24837,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_kitchen_sink_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 693, port: port_); + funcId: 696, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_kitchen_sink_twin_rust_async, @@ -24764,7 +24867,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_enum_simple_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 692, port: port_); + funcId: 695, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_enum_simple_twin_rust_async, @@ -24794,7 +24897,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 688, port: port_); + funcId: 691, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_String, @@ -24824,7 +24927,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_my_size(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 691, port: port_); + funcId: 694, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_my_size, @@ -24854,7 +24957,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 687, port: port_); + funcId: 690, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Set_i_32, @@ -24884,7 +24987,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 689, port: port_); + funcId: 692, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Set_String, @@ -24912,7 +25015,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 694)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 697)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -24941,7 +25044,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_list_prim_u_8_strict(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 698)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 701)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_list_prim_u_8_strict, @@ -24970,7 +25073,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_kitchen_sink_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 701)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 704)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_kitchen_sink_twin_sync, @@ -24999,7 +25102,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_enum_simple_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 700)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 703)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_enum_simple_twin_sync, @@ -25028,7 +25131,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 696)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 699)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_String, @@ -25057,7 +25160,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_my_size(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 699)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 702)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_my_size, @@ -25085,7 +25188,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 695)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 698)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Set_i_32, @@ -25113,7 +25216,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 697)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 700)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Set_String, @@ -25142,7 +25245,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 723, port: port_); + funcId: 726, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -25174,7 +25277,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(a, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 706, port: port_); + funcId: 709, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25209,7 +25312,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 705, port: port_); + funcId: 708, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25241,7 +25344,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_u_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 711, port: port_); + funcId: 714, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25276,7 +25379,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_2_twin_rust_async_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 710, port: port_); + funcId: 713, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25311,7 +25414,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_StreamSink_u_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 709, port: port_); + funcId: 712, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25351,7 +25454,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_2_twin_rust_async_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 708, port: port_); + funcId: 711, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25383,7 +25486,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(a, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 704, port: port_); + funcId: 707, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_concatenate_with_twin_rust_async, @@ -25414,7 +25517,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_concatenate_with_twin_rust_async( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 707, port: port_); + funcId: 710, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25447,7 +25550,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(b, serializer); sse_encode_u_32(c, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 703, port: port_); + funcId: 706, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_rust_async_array_3, @@ -25476,7 +25579,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 702, port: port_); + funcId: 705, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_rust_async, @@ -25509,7 +25612,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_callable_twin_rust_async(that, serializer); sse_encode_String(two, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 713, port: port_); + funcId: 716, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25539,7 +25642,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 719, port: port_); + funcId: 722, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_enum_twin_rust_async, @@ -25570,7 +25673,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_enum_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 720, port: port_); + funcId: 723, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25601,7 +25704,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_simple_primitive_enum_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 721, port: port_); + funcId: 724, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -25635,7 +25738,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_simple_struct_twin_rust_async(a, serializer); sse_encode_box_autoadd_simple_struct_twin_rust_async(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 717, port: port_); + funcId: 720, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25665,7 +25768,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 715, port: port_); + funcId: 718, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25696,7 +25799,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_rust_async(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 716, port: port_); + funcId: 719, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25727,7 +25830,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 714, port: port_); + funcId: 717, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_twin_rust_async, @@ -25758,7 +25861,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_simple_struct_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 718, port: port_); + funcId: 721, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -25788,7 +25891,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(a, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 722, port: port_); + funcId: 725, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -25824,7 +25927,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(y, serializer); sse_encode_u_32(z, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 712, port: port_); + funcId: 715, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25851,7 +25954,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 745)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 748)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -25881,7 +25984,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(a, serializer); sse_encode_String(b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 728)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 731)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25914,7 +26017,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_concatenate_with_twin_sync(that, serializer); sse_encode_String(b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 727)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 730)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -25944,7 +26047,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_u_32_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 733)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 736)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25978,7 +26081,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(key, serializer); sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_2_twin_sync_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 732)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 735)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26011,7 +26114,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_concatenate_with_twin_sync(that, serializer); sse_encode_StreamSink_u_32_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 731)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 734)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26049,7 +26152,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(key, serializer); sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_2_twin_sync_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 730)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 733)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26080,7 +26183,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(a, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 726)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 729)!; }, codec: SseCodec( decodeSuccessData: sse_decode_concatenate_with_twin_sync, @@ -26109,7 +26212,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_concatenate_with_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 729)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 732)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26139,7 +26242,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(a, serializer); sse_encode_u_32(b, serializer); sse_encode_u_32(c, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 725)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 728)!; }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_sync_array_3, @@ -26166,7 +26269,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 724)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 727)!; }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_sync, @@ -26195,7 +26298,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_callable_twin_sync(that, serializer); sse_encode_String(two, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 735)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 738)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26224,7 +26327,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 741)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 744)!; }, codec: SseCodec( decodeSuccessData: sse_decode_simple_enum_twin_sync, @@ -26253,7 +26356,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_enum_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 742)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 745)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26281,7 +26384,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_simple_primitive_enum_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 743)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 746)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -26313,7 +26416,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_sync(a, serializer); sse_encode_box_autoadd_simple_struct_twin_sync(b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 739)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 742)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26342,7 +26445,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 737)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 740)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26371,7 +26474,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_twin_sync(that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 738)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 741)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26400,7 +26503,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 736)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 739)!; }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_twin_sync, @@ -26429,7 +26532,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_simple_struct_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 740)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 743)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -26457,7 +26560,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(a, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 744)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 747)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -26490,7 +26593,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_sum_with_twin_sync(that, serializer); sse_encode_u_32(y, serializer); sse_encode_u_32(z, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 734)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 737)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -26521,7 +26624,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_settings_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 749, port: port_); + funcId: 752, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26553,7 +26656,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_settings_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 750, port: port_); + funcId: 753, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26583,7 +26686,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_numbers(nums, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 756, port: port_); + funcId: 759, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -26613,7 +26716,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_sequences(seqs, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 757, port: port_); + funcId: 760, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -26642,7 +26745,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 746, port: port_); + funcId: 749, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -26671,7 +26774,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 747, port: port_); + funcId: 750, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -26700,7 +26803,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 753, port: port_); + funcId: 756, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_message, @@ -26730,7 +26833,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_application_settings(appSettings, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 748, port: port_); + funcId: 751, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -26761,7 +26864,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_array_2_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 771, port: port_); + funcId: 774, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26793,7 +26896,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 766, port: port_); + funcId: 769, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26825,7 +26928,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Map_u_8_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 769, port: port_); + funcId: 772, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26858,7 +26961,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_opt_box_autoadd_application_mode_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 767, port: port_); + funcId: 770, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26890,7 +26993,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Set_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 770, port: port_); + funcId: 773, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26923,7 +27026,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_mirror_struct_twin_rust_async_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 751, port: port_); + funcId: 754, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26956,7 +27059,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_record_application_settings_raw_string_enum_mirrored_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 752, port: port_); + funcId: 755, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26988,7 +27091,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 768, port: port_); + funcId: 771, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27020,7 +27123,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(num, serializer); sse_encode_usize(times, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 754, port: port_); + funcId: 757, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_numbers, @@ -27051,7 +27154,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(seq, serializer); sse_encode_usize(times, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 755, port: port_); + funcId: 758, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sequences, @@ -27080,7 +27183,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 764, port: port_); + funcId: 767, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -27110,7 +27213,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 762, port: port_); + funcId: 765, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_mirrored, @@ -27139,7 +27242,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 765, port: port_); + funcId: 768, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_hash_map, @@ -27168,7 +27271,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 763, port: port_); + funcId: 766, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_enum_mirrored, @@ -27197,7 +27300,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 761, port: port_); + funcId: 764, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_of_nested_raw_string_mirrored, @@ -27227,7 +27330,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 759, port: port_); + funcId: 762, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_nested_raw_string_mirrored, @@ -27257,7 +27360,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(nested, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 760, port: port_); + funcId: 763, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_enum_mirrored, @@ -27286,7 +27389,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 758, port: port_); + funcId: 761, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_mirrored, @@ -27316,7 +27419,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_settings_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 775)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 778)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27347,7 +27450,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_settings_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 776)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 779)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27376,7 +27479,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_numbers(nums, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 782)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 785)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -27404,7 +27507,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_sequences(seqs, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 783)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 786)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -27431,7 +27534,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 772)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 775)!; }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -27459,7 +27562,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 773)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 776)!; }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -27486,7 +27589,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 779)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 782)!; }, codec: SseCodec( decodeSuccessData: sse_decode_application_message, @@ -27513,7 +27616,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_application_settings(appSettings, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 774)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 777)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -27543,7 +27646,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_array_2_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 797)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 800)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27574,7 +27677,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 792)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 795)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27605,7 +27708,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Map_u_8_application_mode_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 795)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 798)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27637,7 +27740,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_opt_box_autoadd_application_mode_Sse( sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 793)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 796)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27668,7 +27771,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Set_application_mode_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 796)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 799)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27699,7 +27802,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_mirror_struct_twin_sync_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 777)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 780)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27731,7 +27834,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_record_application_settings_raw_string_enum_mirrored_Sse( sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 778)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 781)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27762,7 +27865,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_mode_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 794)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 797)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27792,7 +27895,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(num, serializer); sse_encode_usize(times, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 780)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 783)!; }, codec: SseCodec( decodeSuccessData: sse_decode_numbers, @@ -27821,7 +27924,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(seq, serializer); sse_encode_usize(times, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 781)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 784)!; }, codec: SseCodec( decodeSuccessData: sse_decode_sequences, @@ -27849,7 +27952,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 790)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 793)!; }, codec: SseCodec( decodeSuccessData: sse_decode_contains_mirrored_sub_struct_twin_sync, @@ -27877,7 +27980,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 788)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 791)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_mirrored, @@ -27905,7 +28008,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 791)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 794)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_hash_map, @@ -27933,7 +28036,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 789)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 792)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_enum_mirrored, @@ -27961,7 +28064,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 787)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 790)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_of_nested_raw_string_mirrored, @@ -27989,7 +28092,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 785)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 788)!; }, codec: SseCodec( decodeSuccessData: sse_decode_nested_raw_string_mirrored, @@ -28018,7 +28121,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(nested, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 786)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 789)!; }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_enum_mirrored, @@ -28046,7 +28149,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 784)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 787)!; }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_mirrored, @@ -28075,7 +28178,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 801, port: port_); + funcId: 804, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_big_buffers_twin_rust_async, @@ -28096,6 +28199,36 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + Future + crateApiPseudoManualMiscExampleTwinRustAsyncHandleCharTwinRustAsync( + {required String arg, dynamic hint}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_Char(arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 808, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_Char, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualMiscExampleTwinRustAsyncHandleCharTwinRustAsyncConstMeta, + argValues: [arg], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualMiscExampleTwinRustAsyncHandleCharTwinRustAsyncConstMeta => + const TaskConstMeta( + debugName: "handle_char_twin_rust_async", + argNames: ["arg"], + ); + @override Future crateApiPseudoManualMiscExampleTwinRustAsyncHandleComplexStructTwinRustAsync( @@ -28105,7 +28238,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_tree_node_twin_rust_async(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 798, port: port_); + funcId: 801, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_tree_node_twin_rust_async, @@ -28135,7 +28268,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_nested_struct_twin_rust_async(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 800, port: port_); + funcId: 803, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_nested_struct_twin_rust_async, @@ -28165,7 +28298,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 804, port: port_); + funcId: 807, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -28196,7 +28329,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_size(arg, serializer); sse_encode_box_my_size(boxed, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 806, port: port_); + funcId: 810, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_size, @@ -28226,7 +28359,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(v, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 805, port: port_); + funcId: 809, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -28256,7 +28389,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_weekdays_twin_rust_async(weekdays, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 799, port: port_); + funcId: 802, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_weekdays_twin_rust_async, @@ -28286,7 +28419,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_abc_twin_rust_async(abc, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 802, port: port_); + funcId: 805, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_abc_twin_rust_async, @@ -28316,7 +28449,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_enum_twin_rust_async(se, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 803, port: port_); + funcId: 806, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_enum_twin_rust_async, @@ -28344,7 +28477,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 810)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 814)!; }, codec: SseCodec( decodeSuccessData: sse_decode_big_buffers_twin_sync, @@ -28365,6 +28498,34 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + String crateApiPseudoManualMiscExampleTwinSyncHandleCharTwinSync( + {required String arg, dynamic hint}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_Char(arg, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 818)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_Char, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualMiscExampleTwinSyncHandleCharTwinSyncConstMeta, + argValues: [arg], + apiImpl: this, + hint: hint, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualMiscExampleTwinSyncHandleCharTwinSyncConstMeta => + const TaskConstMeta( + debugName: "handle_char_twin_sync", + argNames: ["arg"], + ); + @override MyTreeNodeTwinSync crateApiPseudoManualMiscExampleTwinSyncHandleComplexStructTwinSync( @@ -28373,7 +28534,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_tree_node_twin_sync(s, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 807)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 811)!; }, codec: SseCodec( decodeSuccessData: sse_decode_my_tree_node_twin_sync, @@ -28402,7 +28563,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_nested_struct_twin_sync(s, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 809)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 813)!; }, codec: SseCodec( decodeSuccessData: sse_decode_my_nested_struct_twin_sync, @@ -28430,7 +28591,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(s, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 813)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 817)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -28459,7 +28620,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_size(arg, serializer); sse_encode_box_my_size(boxed, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 815)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 820)!; }, codec: SseCodec( decodeSuccessData: sse_decode_my_size, @@ -28487,7 +28648,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(v, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 814)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 819)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -28516,7 +28677,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_weekdays_twin_sync(weekdays, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 808)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 812)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_weekdays_twin_sync, @@ -28544,7 +28705,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_abc_twin_sync(abc, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 811)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 815)!; }, codec: SseCodec( decodeSuccessData: sse_decode_abc_twin_sync, @@ -28573,7 +28734,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_enum_twin_sync(se, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 812)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 816)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_enum_twin_sync, @@ -28603,7 +28764,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_empty_twin_rust_async(empty, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 819, port: port_); + funcId: 824, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_empty_twin_rust_async, @@ -28632,7 +28793,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 816, port: port_); + funcId: 821, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28662,7 +28823,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_my_size(l, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 817, port: port_); + funcId: 822, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_my_size, @@ -28692,7 +28853,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(names, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 818, port: port_); + funcId: 823, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -28720,7 +28881,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_empty_twin_sync(empty, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 823)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 828)!; }, codec: SseCodec( decodeSuccessData: sse_decode_empty_twin_sync, @@ -28747,7 +28908,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 820)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 825)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28775,7 +28936,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_my_size(l, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 821)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 826)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_my_size, @@ -28803,7 +28964,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(names, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 822)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 827)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -28833,7 +28994,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_new_type_int_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 824, port: port_); + funcId: 829, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_new_type_int_twin_rust_async, @@ -28862,7 +29023,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_new_type_int_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 825)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 830)!; }, codec: SseCodec( decodeSuccessData: sse_decode_new_type_int_twin_sync, @@ -28895,7 +29056,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_f_64(myF64, serializer); sse_encode_opt_box_autoadd_bool(myBool, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 826, port: port_); + funcId: 831, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -28927,7 +29088,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_i_64(myI64, serializer); sse_encode_opt_box_autoadd_f_64(myF64, serializer); sse_encode_opt_box_autoadd_bool(myBool, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 827)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 832)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -28957,7 +29118,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_f_64(opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 831, port: port_); + funcId: 836, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -29001,7 +29162,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_exotic_optionals_twin_rust_async( structbox, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 833, port: port_); + funcId: 838, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29040,7 +29201,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_exotic_optionals_twin_rust_async( opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 830, port: port_); + funcId: 835, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -29072,7 +29233,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(left, serializer); sse_encode_f_64(right, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 828, port: port_); + funcId: 833, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -29102,7 +29263,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(document, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 829, port: port_); + funcId: 834, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_element_twin_rust_async, @@ -29132,7 +29293,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_opt_vecs_twin_rust_async(opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 832, port: port_); + funcId: 837, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_vecs_twin_rust_async, @@ -29161,7 +29322,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_f_64(opt, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 837)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 842)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -29202,7 +29363,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_f_64(f64Box, serializer); sse_encode_opt_box_bool(boolbox, serializer); sse_encode_opt_box_exotic_optionals_twin_sync(structbox, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 839)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 844)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29239,7 +29400,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_exotic_optionals_twin_sync(opt, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 836)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 841)!; }, codec: SseCodec( decodeSuccessData: @@ -29269,7 +29430,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64(left, serializer); sse_encode_f_64(right, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 834)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 839)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -29298,7 +29459,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(document, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 835)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 840)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_element_twin_sync, @@ -29326,7 +29487,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_opt_vecs_twin_sync(opt, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 838)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 843)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_vecs_twin_sync, @@ -29355,7 +29516,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 842, port: port_); + funcId: 847, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -29385,7 +29546,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 841, port: port_); + funcId: 846, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29415,7 +29576,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 840, port: port_); + funcId: 845, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29446,7 +29607,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_simple_struct_for_borrow_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 843, port: port_); + funcId: 848, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_for_borrow_twin_rust_async, @@ -29474,7 +29635,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 846)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 851)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -29502,7 +29663,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 845)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 850)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29530,7 +29691,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 844)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 849)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29560,7 +29721,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_simple_struct_for_borrow_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 847)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 852)!; }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_for_borrow_twin_sync, @@ -29590,7 +29751,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(n, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 848, port: port_); + funcId: 853, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_vec_of_primitive_pack_twin_rust_async, @@ -29619,7 +29780,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(n, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 849)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 854)!; }, codec: SseCodec( decodeSuccessData: sse_decode_vec_of_primitive_pack_twin_sync, @@ -29656,7 +29817,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(myF64, serializer); sse_encode_bool(myBool, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 850, port: port_); + funcId: 855, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -29686,7 +29847,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(myU32, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 851, port: port_); + funcId: 856, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -29721,7 +29882,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_64(myI64, serializer); sse_encode_f_64(myF64, serializer); sse_encode_bool(myBool, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 852)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 857)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -29749,7 +29910,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(myU32, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 853)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 858)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -29778,7 +29939,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 855, port: port_); + funcId: 860, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -29809,7 +29970,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 854, port: port_); + funcId: 859, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_item_struct_twin_rust_async, @@ -29837,7 +29998,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 857)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 862)!; }, codec: SseCodec( decodeSuccessData: @@ -29866,7 +30027,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 856)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 861)!; }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_item_struct_twin_sync, @@ -29897,7 +30058,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 901, port: port_); + funcId: 906, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29929,7 +30090,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 902, port: port_); + funcId: 907, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29961,7 +30122,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 900, port: port_); + funcId: 905, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29993,7 +30154,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 904, port: port_); + funcId: 909, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -30025,7 +30186,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 903, port: port_); + funcId: 908, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30056,7 +30217,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 898, port: port_); + funcId: 903, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30087,7 +30248,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 897, port: port_); + funcId: 902, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30117,7 +30278,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 899, port: port_); + funcId: 904, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30150,7 +30311,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 894, port: port_); + funcId: 899, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30182,7 +30343,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 895, port: port_); + funcId: 900, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30214,7 +30375,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 893, port: port_); + funcId: 898, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30244,7 +30405,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 896, port: port_); + funcId: 901, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30280,7 +30441,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 859, port: port_); + funcId: 864, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30316,7 +30477,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(expect, serializer); sse_encode_i_32(adder, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 860, port: port_); + funcId: 865, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30347,7 +30508,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 862, port: port_); + funcId: 867, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30383,7 +30544,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 858, port: port_); + funcId: 863, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30417,7 +30578,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_list_prim_i_32_loose(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 883, port: port_); + funcId: 888, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30452,7 +30613,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 892, port: port_); + funcId: 897, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -30487,7 +30648,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( mutBorrow, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 891, port: port_); + funcId: 896, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -30518,7 +30679,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynFnStringStringSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 867, port: port_); + funcId: 872, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30547,7 +30708,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 868, port: port_); + funcId: 873, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30583,7 +30744,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerEnumWithGoodAndOpaqueWithoutOptionTwinRustAsync( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 879, port: port_); + funcId: 884, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30614,7 +30775,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleEnumTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 880, port: port_); + funcId: 885, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30643,7 +30804,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 881, port: port_); + funcId: 886, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30675,7 +30836,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_good_and_opaque_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 876, port: port_); + funcId: 881, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30705,7 +30866,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 877, port: port_); + funcId: 882, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_rust_async, @@ -30735,7 +30896,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 878, port: port_); + funcId: 883, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_rust_async, @@ -30770,7 +30931,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 885, port: port_); + funcId: 890, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30800,7 +30961,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 887, port: port_); + funcId: 892, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30833,7 +30994,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 886, port: port_); + funcId: 891, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30867,7 +31028,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 864, port: port_); + funcId: 869, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30898,7 +31059,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynMyTraitTwinRustAsyncSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 865, port: port_); + funcId: 870, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30927,7 +31088,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 866, port: port_); + funcId: 871, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30957,7 +31118,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 889, port: port_); + funcId: 894, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30988,7 +31149,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 890, port: port_); + funcId: 895, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31019,7 +31180,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 861, port: port_); + funcId: 866, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31049,7 +31210,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 884, port: port_); + funcId: 889, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31085,7 +31246,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( orange, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 888, port: port_); + funcId: 893, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -31117,7 +31278,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 882, port: port_); + funcId: 887, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31150,7 +31311,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 874, port: port_); + funcId: 879, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31180,7 +31341,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 875, port: port_); + funcId: 880, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31216,7 +31377,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 870, port: port_); + funcId: 875, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31251,7 +31412,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 871, port: port_); + funcId: 876, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31286,7 +31447,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 869, port: port_); + funcId: 874, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31315,7 +31476,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 872, port: port_); + funcId: 877, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31346,7 +31507,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 873, port: port_); + funcId: 878, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31383,7 +31544,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 863, port: port_); + funcId: 868, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31413,7 +31574,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 948)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 953)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31444,7 +31605,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 949)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 954)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31475,7 +31636,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 947)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 952)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31505,7 +31666,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 951)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 956)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -31536,7 +31697,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 950)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 955)!; }, codec: SseCodec( decodeSuccessData: @@ -31566,7 +31727,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 945)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 950)!; }, codec: SseCodec( decodeSuccessData: @@ -31595,7 +31756,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 944)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 949)!; }, codec: SseCodec( decodeSuccessData: @@ -31624,7 +31785,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 946)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 951)!; }, codec: SseCodec( decodeSuccessData: @@ -31655,7 +31816,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 941)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 946)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31686,7 +31847,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 942)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 947)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31717,7 +31878,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 940)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 945)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31745,7 +31906,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 943)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 948)!; }, codec: SseCodec( decodeSuccessData: @@ -31780,7 +31941,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); sse_encode_i_32(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 906)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 911)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31815,7 +31976,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); sse_encode_i_32(adder, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 907)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 912)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31845,7 +32006,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 909)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 914)!; }, codec: SseCodec( decodeSuccessData: @@ -31878,7 +32039,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); sse_encode_i_32(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 905)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 910)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31911,7 +32072,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); sse_encode_list_prim_i_32_loose(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 930)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 935)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31944,7 +32105,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 939)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 944)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -31977,7 +32138,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { borrow, serializer); sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( mutBorrow, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 938)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 943)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -32007,7 +32168,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynFnStringStringSendSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 914)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 919)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32035,7 +32196,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 915)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 920)!; }, codec: SseCodec( decodeSuccessData: @@ -32069,7 +32230,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerEnumWithGoodAndOpaqueWithoutOptionTwinSync( b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 926)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 931)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32099,7 +32260,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleEnumTwinSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 927)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 932)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32127,7 +32288,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 928)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 933)!; }, codec: SseCodec( decodeSuccessData: @@ -32158,7 +32319,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_with_good_and_opaque_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 923)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 928)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32187,7 +32348,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 924)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 929)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_sync, @@ -32216,7 +32377,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 925)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 930)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_sync, @@ -32250,7 +32411,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); sse_encode_i_32(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 932)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 937)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32279,7 +32440,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 934)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 939)!; }, codec: SseCodec( decodeSuccessData: @@ -32311,7 +32472,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 933)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 938)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32344,7 +32505,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( a, serializer); sse_encode_String(b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 911)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 916)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32374,7 +32535,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynMyTraitTwinSyncSendSync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 912)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 917)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32402,7 +32563,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 913)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 918)!; }, codec: SseCodec( decodeSuccessData: @@ -32433,7 +32594,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 936)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 941)!; }, codec: SseCodec( decodeSuccessData: @@ -32462,7 +32623,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 937)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 942)!; }, codec: SseCodec( decodeSuccessData: @@ -32492,7 +32653,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 908)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 913)!; }, codec: SseCodec( decodeSuccessData: @@ -32521,7 +32682,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 931)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 936)!; }, codec: SseCodec( decodeSuccessData: @@ -32555,7 +32716,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { apple, serializer); sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( orange, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 935)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 940)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -32586,7 +32747,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync_Sse( sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 929)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 934)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32617,7 +32778,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 921)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 926)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32646,7 +32807,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 922)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 927)!; }, codec: SseCodec( decodeSuccessData: @@ -32681,7 +32842,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynHelloTraitTwinSync( arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 917)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 922)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32714,7 +32875,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynHelloTraitTwinSync( arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 918)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 923)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32747,7 +32908,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynHelloTraitTwinSync( arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 916)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 921)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32775,7 +32936,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 919)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 924)!; }, codec: SseCodec( decodeSuccessData: @@ -32804,7 +32965,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 920)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 925)!; }, codec: SseCodec( decodeSuccessData: @@ -32838,7 +32999,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 910)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 915)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32867,7 +33028,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 954, port: port_); + funcId: 959, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_opaque_twin_rust_async_array_5, @@ -32896,7 +33057,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 963, port: port_); + funcId: 968, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opaque_nested_twin_rust_async, @@ -32925,7 +33086,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 952, port: port_); + funcId: 957, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinRustAsync, @@ -32956,7 +33117,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_RustOpaque_HideDataTwinRustAsync( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 953, port: port_); + funcId: 958, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32986,7 +33147,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 966, port: port_); + funcId: 971, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueReturnTwinRustAsync, @@ -33016,7 +33177,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync_array_2(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 960, port: port_); + funcId: 965, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33045,7 +33206,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 958, port: port_); + funcId: 963, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinRustAsync_array_2, @@ -33075,7 +33236,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_RustOpaque_HideDataTwinRustAsync(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 962, port: port_); + funcId: 967, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33104,7 +33265,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 961, port: port_); + funcId: 966, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_RustOpaque_HideDataTwinRustAsync, @@ -33134,7 +33295,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_opaque_twin_rust_async(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 955, port: port_); + funcId: 960, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33165,7 +33326,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_opaque_nested_twin_rust_async( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 964, port: port_); + funcId: 969, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33195,7 +33356,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_NonCloneDataTwinRustAsync(clone, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 959, port: port_); + funcId: 964, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33225,7 +33386,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 956, port: port_); + funcId: 961, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33255,7 +33416,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 957, port: port_); + funcId: 962, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33285,7 +33446,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 965, port: port_); + funcId: 970, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33313,7 +33474,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 969)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 974)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_opaque_twin_sync_array_5, @@ -33341,7 +33502,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 978)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 983)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opaque_nested_twin_sync, @@ -33368,7 +33529,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 967)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 972)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinSync, @@ -33398,7 +33559,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_RustOpaque_HideDataTwinSync( opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 968)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 973)!; }, codec: SseCodec( decodeSuccessData: @@ -33427,7 +33588,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 981)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 986)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueReturnTwinSync, @@ -33455,7 +33616,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinSync_array_2(data, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 975)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 980)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33483,7 +33644,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 973)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 978)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinSync_array_2, @@ -33511,7 +33672,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_RustOpaque_HideDataTwinSync(data, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 977)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 982)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33538,7 +33699,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 976)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 981)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_RustOpaque_HideDataTwinSync, @@ -33566,7 +33727,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_opaque_twin_sync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 970)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 975)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33594,7 +33755,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_opaque_nested_twin_sync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 979)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 984)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33622,7 +33783,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_NonCloneDataTwinSync(clone, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 974)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 979)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33650,7 +33811,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinSync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 971)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 976)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33678,7 +33839,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinSync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 972)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 977)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33706,7 +33867,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinSync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 980)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 985)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33736,7 +33897,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(a, serializer); sse_encode_i_32(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 982, port: port_); + funcId: 987, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -33765,7 +33926,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(a, serializer); sse_encode_i_32(b, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 983)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 988)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -33796,7 +33957,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 984, port: port_); + funcId: 989, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33828,7 +33989,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 985, port: port_); + funcId: 990, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33862,7 +34023,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(b, serializer); sse_encode_StreamSink_u_32_Sse(c, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 986, port: port_); + funcId: 991, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33895,7 +34056,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_my_stream_entry_twin_rust_async_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 987, port: port_); + funcId: 992, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33929,7 +34090,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_twin_rust_async_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 988, port: port_); + funcId: 993, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33963,7 +34124,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_log_twin_rust_async_Sse(sink, serializer); sse_encode_u_32(max, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 989, port: port_); + funcId: 994, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33997,7 +34158,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(key, serializer); sse_encode_u_32(max, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 990, port: port_); + funcId: 995, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34029,7 +34190,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_u_8_array_2_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 991, port: port_); + funcId: 996, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34063,7 +34224,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_struct_containing_stream_sink_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 993, port: port_); + funcId: 998, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34093,7 +34254,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_StreamSink_i_32_Sse(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 992, port: port_); + funcId: 997, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34124,7 +34285,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_one_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 995, port: port_); + funcId: 1000, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_one_field_twin_rust_async, @@ -34155,7 +34316,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_two_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 996, port: port_); + funcId: 1001, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_two_field_twin_rust_async, @@ -34186,7 +34347,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_zero_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 994, port: port_); + funcId: 999, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_zero_field_twin_rust_async, @@ -34217,7 +34378,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_tuple_struct_with_one_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 997, port: port_); + funcId: 1002, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -34249,7 +34410,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_tuple_struct_with_two_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 998, port: port_); + funcId: 1003, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -34279,7 +34440,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_one_field_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1000)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1005)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_one_field_twin_sync, @@ -34308,7 +34469,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_two_field_twin_sync(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1001)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1006)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_two_field_twin_sync, @@ -34338,7 +34499,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_zero_field_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 999)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1004)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_zero_field_twin_sync, @@ -34368,7 +34529,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_tuple_struct_with_one_field_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1002)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1007)!; }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_one_field_twin_sync, @@ -34398,7 +34559,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_tuple_struct_with_two_field_twin_sync( arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1003)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1008)!; }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_two_field_twin_sync, @@ -34427,7 +34588,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_record_string_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1005, port: port_); + funcId: 1010, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34457,7 +34618,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_record_string_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1004, port: port_); + funcId: 1009, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_record_string_i_32, @@ -34485,7 +34646,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_record_string_i_32(value, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1007)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1012)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34512,7 +34673,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_record_string_i_32(value, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1006)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1011)!; }, codec: SseCodec( decodeSuccessData: sse_decode_record_string_i_32, @@ -34541,7 +34702,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1008, port: port_); + funcId: 1013, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -34571,7 +34732,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1010, port: port_); + funcId: 1015, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_model_twin_rust_async, @@ -34601,7 +34762,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1009, port: port_); + funcId: 1014, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -34629,7 +34790,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1011)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1016)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -34658,7 +34819,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1013)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1018)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_model_twin_sync, @@ -34686,7 +34847,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1012)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1017)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -34716,7 +34877,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feature_uuid_twin_rust_async(ids, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1016, port: port_); + funcId: 1021, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_feature_uuid_twin_rust_async, @@ -34746,7 +34907,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Uuid(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1014, port: port_); + funcId: 1019, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Uuid, @@ -34776,7 +34937,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Uuid(ids, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1015, port: port_); + funcId: 1020, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Uuid, @@ -34805,7 +34966,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feature_uuid_twin_sync(ids, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1019)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1024)!; }, codec: SseCodec( decodeSuccessData: sse_decode_feature_uuid_twin_sync, @@ -34833,7 +34994,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Uuid(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1017)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1022)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Uuid, @@ -34861,7 +35022,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Uuid(ids, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1018)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1023)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_Uuid, @@ -34890,7 +35051,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1021, port: port_); + funcId: 1026, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -34919,7 +35080,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1020, port: port_); + funcId: 1025, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_item_struct_twin_normal, @@ -34949,7 +35110,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1065, port: port_); + funcId: 1070, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34981,7 +35142,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1066, port: port_); + funcId: 1071, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35013,7 +35174,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1064, port: port_); + funcId: 1069, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35045,7 +35206,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1068, port: port_); + funcId: 1073, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -35077,7 +35238,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1067, port: port_); + funcId: 1072, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35108,7 +35269,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1062, port: port_); + funcId: 1067, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35138,7 +35299,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1061, port: port_); + funcId: 1066, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35168,7 +35329,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1063, port: port_); + funcId: 1068, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35200,7 +35361,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1058, port: port_); + funcId: 1063, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35232,7 +35393,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1059, port: port_); + funcId: 1064, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35264,7 +35425,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1057, port: port_); + funcId: 1062, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35294,7 +35455,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1060, port: port_); + funcId: 1065, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35329,7 +35490,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1023, port: port_); + funcId: 1028, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35364,7 +35525,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(expect, serializer); sse_encode_i_32(adder, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1024, port: port_); + funcId: 1029, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35395,7 +35556,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1026, port: port_); + funcId: 1031, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35429,7 +35590,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1022, port: port_); + funcId: 1027, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35461,7 +35622,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_list_prim_i_32_loose(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1047, port: port_); + funcId: 1052, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35495,7 +35656,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1056, port: port_); + funcId: 1061, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -35529,7 +35690,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( mutBorrow, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1055, port: port_); + funcId: 1060, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -35559,7 +35720,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynFnStringStringSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1031, port: port_); + funcId: 1036, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35588,7 +35749,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1032, port: port_); + funcId: 1037, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35623,7 +35784,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerEnumWithGoodAndOpaqueWithoutOptionTwinNormal( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1043, port: port_); + funcId: 1048, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35652,7 +35813,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleEnumTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1044, port: port_); + funcId: 1049, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35681,7 +35842,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1045, port: port_); + funcId: 1050, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35713,7 +35874,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_good_and_opaque_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1040, port: port_); + funcId: 1045, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35743,7 +35904,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1041, port: port_); + funcId: 1046, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_normal, @@ -35773,7 +35934,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1042, port: port_); + funcId: 1047, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_normal, @@ -35807,7 +35968,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1049, port: port_); + funcId: 1054, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35837,7 +35998,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1051, port: port_); + funcId: 1056, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35869,7 +36030,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1050, port: port_); + funcId: 1055, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35900,7 +36061,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1028, port: port_); + funcId: 1033, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35930,7 +36091,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynMyTraitTwinNormalSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1029, port: port_); + funcId: 1034, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35959,7 +36120,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1030, port: port_); + funcId: 1035, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35989,7 +36150,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1053, port: port_); + funcId: 1058, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36019,7 +36180,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1054, port: port_); + funcId: 1059, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36050,7 +36211,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1025, port: port_); + funcId: 1030, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36080,7 +36241,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1048, port: port_); + funcId: 1053, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36115,7 +36276,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( orange, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1052, port: port_); + funcId: 1057, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -36145,7 +36306,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1046, port: port_); + funcId: 1051, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36177,7 +36338,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1038, port: port_); + funcId: 1043, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36207,7 +36368,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1039, port: port_); + funcId: 1044, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36243,7 +36404,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1034, port: port_); + funcId: 1039, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36277,7 +36438,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1035, port: port_); + funcId: 1040, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36311,7 +36472,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1033, port: port_); + funcId: 1038, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36340,7 +36501,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1036, port: port_); + funcId: 1041, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36371,7 +36532,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1037, port: port_); + funcId: 1042, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36407,7 +36568,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1027, port: port_); + funcId: 1032, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36435,7 +36596,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1071, port: port_); + funcId: 1076, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_opaque_twin_normal_array_5, @@ -36462,7 +36623,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1080, port: port_); + funcId: 1085, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opaque_nested_twin_normal, @@ -36488,7 +36649,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1069, port: port_); + funcId: 1074, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinNormal, @@ -36516,7 +36677,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_RustOpaque_HideDataTwinNormal( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1070, port: port_); + funcId: 1075, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36543,7 +36704,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1083, port: port_); + funcId: 1088, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueReturnTwinNormal, @@ -36570,7 +36731,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal_array_2(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1077, port: port_); + funcId: 1082, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36596,7 +36757,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1075, port: port_); + funcId: 1080, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinNormal_array_2, @@ -36623,7 +36784,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_RustOpaque_HideDataTwinNormal(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1079, port: port_); + funcId: 1084, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36649,7 +36810,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1078, port: port_); + funcId: 1083, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_RustOpaque_HideDataTwinNormal, @@ -36676,7 +36837,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_enum_opaque_twin_normal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1072, port: port_); + funcId: 1077, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -36703,7 +36864,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_opaque_nested_twin_normal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1081, port: port_); + funcId: 1086, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36730,7 +36891,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_NonCloneDataTwinNormal(clone, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1076, port: port_); + funcId: 1081, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -36757,7 +36918,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1073, port: port_); + funcId: 1078, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -36784,7 +36945,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1074, port: port_); + funcId: 1079, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -36811,7 +36972,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1082, port: port_); + funcId: 1087, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -36836,7 +36997,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1087)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1092)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueSyncReturnTwinNormal, @@ -36862,7 +37023,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1086)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1091)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_NonCloneDataTwinNormal, @@ -36888,7 +37049,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1085)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1090)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataAnotherTwinNormal, @@ -36914,7 +37075,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1084)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1089)!; }, codec: SseCodec( decodeSuccessData: @@ -36944,7 +37105,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(a, serializer); sse_encode_i_32(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1088, port: port_); + funcId: 1093, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -36972,7 +37133,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1089, port: port_); + funcId: 1094, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37001,7 +37162,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1090, port: port_); + funcId: 1095, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37032,7 +37193,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(b, serializer); sse_encode_StreamSink_u_32_Sse(c, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1091, port: port_); + funcId: 1096, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37062,7 +37223,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_my_stream_entry_twin_normal_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1092, port: port_); + funcId: 1097, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37093,7 +37254,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(max, serializer); sse_encode_StreamSink_log_twin_normal_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1093, port: port_); + funcId: 1098, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37124,7 +37285,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_log_twin_normal_Sse(sink, serializer); sse_encode_u_32(max, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1094, port: port_); + funcId: 1099, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37155,7 +37316,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(key, serializer); sse_encode_u_32(max, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1095, port: port_); + funcId: 1100, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37184,7 +37345,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_u_8_array_2_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1096, port: port_); + funcId: 1101, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37215,7 +37376,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_struct_containing_stream_sink_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1098, port: port_); + funcId: 1103, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37242,7 +37403,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_StreamSink_i_32_Sse(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1097, port: port_); + funcId: 1102, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37271,7 +37432,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_String_Sse(sink, serializer); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1099, port: port_); + funcId: 1104, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37300,7 +37461,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_i_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1100, port: port_); + funcId: 1105, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37330,7 +37491,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_one_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1102, port: port_); + funcId: 1107, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_one_field_twin_normal, @@ -37360,7 +37521,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_two_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1103, port: port_); + funcId: 1108, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_two_field_twin_normal, @@ -37390,7 +37551,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_zero_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1101, port: port_); + funcId: 1106, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_zero_field_twin_normal, @@ -37420,7 +37581,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_tuple_struct_with_one_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1104, port: port_); + funcId: 1109, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_one_field_twin_normal, @@ -37451,7 +37612,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_tuple_struct_with_two_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1105, port: port_); + funcId: 1110, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_two_field_twin_normal, @@ -37480,7 +37641,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_record_string_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1107, port: port_); + funcId: 1112, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37507,7 +37668,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_record_string_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1106, port: port_); + funcId: 1111, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_record_string_i_32, @@ -37534,7 +37695,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1108, port: port_); + funcId: 1113, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -37561,7 +37722,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1110, port: port_); + funcId: 1115, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_model_twin_normal, @@ -37588,7 +37749,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1109, port: port_); + funcId: 1114, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -37616,7 +37777,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feature_uuid_twin_normal(ids, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1113, port: port_); + funcId: 1118, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_feature_uuid_twin_normal, @@ -37643,7 +37804,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Uuid(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1111, port: port_); + funcId: 1116, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Uuid, @@ -37670,7 +37831,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Uuid(ids, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1112, port: port_); + funcId: 1117, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Uuid, @@ -39055,6 +39216,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return raw as String; } + @protected + String dco_decode_Char(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return String.fromCharCode(raw); + } + @protected Duration dco_decode_Chrono_Duration(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs @@ -41882,6 +42049,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return dco_decode_struct_with_comments_twin_sync(raw); } + @protected + StructWithCustomNameMethodTwinNormal + dco_decode_box_autoadd_struct_with_custom_name_method_twin_normal( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_custom_name_method_twin_normal(raw); + } + @protected StructWithEnumTwinNormal dco_decode_box_autoadd_struct_with_enum_twin_normal( dynamic raw) { @@ -47184,6 +47359,18 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); } + @protected + StructWithCustomNameMethodTwinNormal + dco_decode_struct_with_custom_name_method_twin_normal(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 1) + throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); + return StructWithCustomNameMethodTwinNormal( + field0: dco_decode_i_32(arr[0]), + ); + } + @protected StructWithEnumTwinNormal dco_decode_struct_with_enum_twin_normal( dynamic raw) { @@ -48555,6 +48742,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return inner; } + @protected + String sse_decode_Char(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_String(deserializer); + return inner; + } + @protected Duration sse_decode_Chrono_Duration(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -51406,6 +51600,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return (sse_decode_struct_with_comments_twin_sync(deserializer)); } + @protected + StructWithCustomNameMethodTwinNormal + sse_decode_box_autoadd_struct_with_custom_name_method_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_custom_name_method_twin_normal( + deserializer)); + } + @protected StructWithEnumTwinNormal sse_decode_box_autoadd_struct_with_enum_twin_normal( SseDeserializer deserializer) { @@ -57325,6 +57528,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return StructWithCommentsTwinSync(fieldWithComments: var_fieldWithComments); } + @protected + StructWithCustomNameMethodTwinNormal + sse_decode_struct_with_custom_name_method_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_field0 = sse_decode_i_32(deserializer); + return StructWithCustomNameMethodTwinNormal(field0: var_field0); + } + @protected StructWithEnumTwinNormal sse_decode_struct_with_enum_twin_normal( SseDeserializer deserializer) { @@ -58553,6 +58765,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { throw UnimplementedError('Unreachable ()'); } + @protected + void sse_encode_Char(String self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String(self, serializer); + } + @protected void sse_encode_Chrono_Duration(Duration self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -61438,6 +61656,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_struct_with_comments_twin_sync(self, serializer); } + @protected + void sse_encode_box_autoadd_struct_with_custom_name_method_twin_normal( + StructWithCustomNameMethodTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_custom_name_method_twin_normal(self, serializer); + } + @protected void sse_encode_box_autoadd_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer) { @@ -66400,6 +66625,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(self.fieldWithComments, serializer); } + @protected + void sse_encode_struct_with_custom_name_method_twin_normal( + StructWithCustomNameMethodTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.field0, serializer); + } + @protected void sse_encode_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer) { diff --git a/frb_example/pure_dart_pde/rust/src/frb_generated.rs b/frb_example/pure_dart_pde/rust/src/frb_generated.rs index c77d7f1d74..f7c9f7055d 100644 --- a/frb_example/pure_dart_pde/rust/src/frb_generated.rs +++ b/frb_example/pure_dart_pde/rust/src/frb_generated.rs @@ -50,7 +50,7 @@ flutter_rust_bridge::frb_generated_boilerplate!( default_rust_auto_opaque = RustAutoOpaqueMoi, ); pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.0.0-dev.34"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1044428238; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1632146532; // Section: executor @@ -6127,6 +6127,38 @@ fn wire__crate__api__misc_example__handle_big_buffers_twin_normal_impl( }, ) } +fn wire__crate__api__misc_example__handle_char_twin_normal_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "handle_char_twin_normal", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_arg = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse((move || { + Result::<_, ()>::Ok(crate::api::misc_example::handle_char_twin_normal(api_arg)) + })()) + } + }, + ) +} fn wire__crate__api__misc_example__handle_complex_struct_twin_normal_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -6449,6 +6481,39 @@ let decode_indices_ = flutter_rust_bridge::for_generated::rust_auto_opaque_decod })()) } }) } +fn wire__crate__api__misc_no_twin_example_a__function_with_custom_name_twin_normal_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "function_with_custom_name_twin_normal", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + deserializer.end(); + move |context| { + transform_result_sse((move || { + Result::<_, ()>::Ok( + crate::api::misc_no_twin_example_a::function_with_custom_name_twin_normal(), + ) + })()) + } + }, + ) +} fn wire__crate__api__misc_no_twin_example_a__same_function_name_in_different_files_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -6482,6 +6547,19 @@ fn wire__crate__api__misc_no_twin_example_a__same_function_name_in_different_fil }, ) } +fn wire__crate__api__misc_no_twin_example_a__struct_with_custom_name_method_twin_normal_method_with_custom_name_twin_normal_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "struct_with_custom_name_method_twin_normal_method_with_custom_name_twin_normal", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { + let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer);deserializer.end(); + transform_result_sse((move || { + Result::<_,()>::Ok(crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal::method_with_custom_name_twin_normal(&api_that)) + })()) }) +} fn wire__crate__api__misc_no_twin_example_a__struct_with_impl_block_in_another_file_f_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -17400,6 +17478,21 @@ fn wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_big_buf })().await) } }) } +fn wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_char_twin_rust_async_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "handle_char_twin_rust_async", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { + let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) }; + let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_arg = ::sse_decode(&mut deserializer);deserializer.end(); move |context| async move { + transform_result_sse((move || async move { + Result::<_,()>::Ok(crate::api::pseudo_manual::misc_example_twin_rust_async::handle_char_twin_rust_async(api_arg).await) + })().await) + } }) +} fn wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_complex_struct_twin_rust_async_impl( port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -17552,6 +17645,39 @@ fn wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_big_buffers_t }, ) } +fn wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_char_twin_sync_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "handle_char_twin_sync", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_arg = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse((move || { + Result::<_, ()>::Ok( + crate::api::pseudo_manual::misc_example_twin_sync::handle_char_twin_sync( + api_arg, + ), + ) + })()) + }, + ) +} fn wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_complex_struct_twin_sync_impl( ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, @@ -25425,6 +25551,14 @@ impl SseDecode for backtrace::Backtrace { } } +impl SseDecode for char { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return inner.chars().next().unwrap(); + } +} + impl SseDecode for chrono::Duration { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -33957,6 +34091,16 @@ impl SseDecode for crate::api::pseudo_manual::comment_twin_sync::StructWithComme } } +impl SseDecode for crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_field0 = ::sse_decode(deserializer); + return crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal( + var_field0, + ); + } +} + impl SseDecode for crate::api::misc_example::StructWithEnumTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -34878,577 +35022,580 @@ fn pde_ffi_dispatcher_primary_impl( 182 => wire__crate__api__mirror__test_raw_string_enum_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), 180 => wire__crate__api__mirror__test_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), 197 => wire__crate__api__misc_example__handle_big_buffers_twin_normal_impl(port, ptr, rust_vec_len, data_len), +201 => wire__crate__api__misc_example__handle_char_twin_normal_impl(port, ptr, rust_vec_len, data_len), 194 => wire__crate__api__misc_example__handle_complex_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), 196 => wire__crate__api__misc_example__handle_nested_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), 200 => wire__crate__api__misc_example__handle_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -202 => wire__crate__api__misc_example__handle_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -201 => wire__crate__api__misc_example__handle_vec_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +203 => wire__crate__api__misc_example__handle_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +202 => wire__crate__api__misc_example__handle_vec_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), 195 => wire__crate__api__misc_example__list_of_primitive_enums_twin_normal_impl(port, ptr, rust_vec_len, data_len), 198 => wire__crate__api__misc_example__test_abc_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), 199 => wire__crate__api__misc_example__test_struct_with_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -204 => wire__crate__api__misc_no_twin_example_a__StructInMiscNoTwinExampleA_sample_function_a_impl(port, ptr, rust_vec_len, data_len), -205 => wire__crate__api__misc_no_twin_example_a__StructWithImplBlockInMultiFile_method_in_a_impl(port, ptr, rust_vec_len, data_len), -203 => wire__crate__api__misc_no_twin_example_a__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), -210 => wire__crate__api__misc_no_twin_example_a__struct_with_impl_block_in_another_file_f_impl(port, ptr, rust_vec_len, data_len), -207 => wire__crate__api__misc_no_twin_example_b__StructInMiscNoTwinExampleB_get_struct_in_misc_no_twin_example_a_impl(port, ptr, rust_vec_len, data_len), -208 => wire__crate__api__misc_no_twin_example_b__StructInMiscNoTwinExampleB_sample_function_b_impl(port, ptr, rust_vec_len, data_len), -209 => wire__crate__api__misc_no_twin_example_b__StructWithImplBlockInMultiFile_method_in_b_impl(port, ptr, rust_vec_len, data_len), -206 => wire__crate__api__misc_no_twin_example_b__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), -214 => wire__crate__api__misc_type__empty_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -211 => wire__crate__api__misc_type__func_return_unit_twin_normal_impl(port, ptr, rust_vec_len, data_len), -212 => wire__crate__api__misc_type__handle_list_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -213 => wire__crate__api__misc_type__handle_string_list_twin_normal_impl(port, ptr, rust_vec_len, data_len), -215 => wire__crate__api__newtype_pattern__handle_newtype_twin_normal_impl(port, ptr, rust_vec_len, data_len), -219 => wire__crate__api__optional__handle_increment_boxed_optional_twin_normal_impl(port, ptr, rust_vec_len, data_len), -221 => wire__crate__api__optional__handle_option_box_arguments_twin_normal_impl(port, ptr, rust_vec_len, data_len), -218 => wire__crate__api__optional__handle_optional_increment_twin_normal_impl(port, ptr, rust_vec_len, data_len), -216 => wire__crate__api__optional__handle_optional_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -217 => wire__crate__api__optional__handle_optional_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -220 => wire__crate__api__optional__handle_vec_of_opts_twin_normal_impl(port, ptr, rust_vec_len, data_len), -222 => wire__crate__api__optional_primitive_misc__primitive_optional_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), -225 => wire__crate__api__ownership__borrow_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -224 => wire__crate__api__ownership__borrow_str_twin_normal_impl(port, ptr, rust_vec_len, data_len), -223 => wire__crate__api__ownership__borrow_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -226 => wire__crate__api__ownership__borrow_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -227 => wire__crate__api__primitive_list_misc__handle_vec_of_primitive_twin_normal_impl(port, ptr, rust_vec_len, data_len), -228 => wire__crate__api__primitive_misc__primitive_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), -229 => wire__crate__api__primitive_misc__primitive_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -234 => wire__crate__api__pseudo_manual__array_twin_rust_async__boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -238 => wire__crate__api__pseudo_manual__array_twin_rust_async__func_test_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -230 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -231 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_complex_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -239 => wire__crate__api__pseudo_manual__array_twin_rust_async__last_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -240 => wire__crate__api__pseudo_manual__array_twin_rust_async__nested_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -232 => wire__crate__api__pseudo_manual__array_twin_rust_async__new_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -236 => wire__crate__api__pseudo_manual__array_twin_rust_async__return_boxed_feed_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -237 => wire__crate__api__pseudo_manual__array_twin_rust_async__return_boxed_raw_feed_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -235 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -233 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -253 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__handle_customized_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -254 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__next_user_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -278 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -277 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -279 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -274 => wire__crate__api__pseudo_manual__basic__example_basic_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -276 => wire__crate__api__pseudo_manual__basic__example_basic_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -272 => wire__crate__api__pseudo_manual__basic__example_basic_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -273 => wire__crate__api__pseudo_manual__basic__example_basic_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -263 => wire__crate__api__pseudo_manual__basic__example_basic_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -264 => wire__crate__api__pseudo_manual__basic__example_basic_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -265 => wire__crate__api__pseudo_manual__basic__example_basic_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -262 => wire__crate__api__pseudo_manual__basic__example_basic_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -270 => wire__crate__api__pseudo_manual__basic__example_basic_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -275 => wire__crate__api__pseudo_manual__basic__example_basic_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -267 => wire__crate__api__pseudo_manual__basic__example_basic_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -268 => wire__crate__api__pseudo_manual__basic__example_basic_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -269 => wire__crate__api__pseudo_manual__basic__example_basic_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -266 => wire__crate__api__pseudo_manual__basic__example_basic_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -271 => wire__crate__api__pseudo_manual__basic__example_basic_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -294 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -293 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -295 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -290 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -292 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -288 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -289 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -281 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -282 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -283 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -280 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -291 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -285 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -286 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -287 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -284 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -310 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -309 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -311 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -306 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -308 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -304 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -305 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -297 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -298 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -299 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -296 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -307 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -301 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -302 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -303 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -300 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -344 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -343 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -345 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -340 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -342 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -338 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -339 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -329 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -330 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -331 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -328 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -336 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -341 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -333 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -334 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -335 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -332 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -337 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -362 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -361 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -363 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -358 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -360 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -356 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -357 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -347 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -348 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -349 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -346 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -354 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -359 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -351 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -352 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -353 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -350 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -355 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -398 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -397 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -399 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -394 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -396 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -392 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -393 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -383 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -384 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -385 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -382 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -390 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -395 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -387 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -388 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -389 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -386 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -391 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -416 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -415 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -417 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -412 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -414 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -410 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -411 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -401 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -402 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -403 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -400 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -408 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -413 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -405 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -406 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -407 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -404 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -409 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -452 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -451 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -453 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -448 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -450 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -446 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -447 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -437 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -438 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -439 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -436 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -444 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -449 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -441 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -442 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -443 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -440 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -445 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -479 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -477 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -475 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), -480 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -478 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -476 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), -485 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -483 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -481 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), -486 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -484 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -482 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), -473 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_input_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -474 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_output_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -472 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_void_twin_normal_impl(port, ptr, rust_vec_len, data_len), -494 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -492 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -490 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -495 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -493 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -491 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -500 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -498 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -496 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -501 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -499 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -497 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -488 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_input_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -489 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_output_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -487 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_void_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -518 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_local_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -517 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_utc_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -521 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__duration_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -523 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_durations_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -522 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_timestamps_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -526 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__how_long_does_it_take_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -519 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__naivedatetime_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -520 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__optional_empty_datetime_utc_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -524 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -525 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_precise_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -539 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_slash_star_star_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -538 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_triple_slash_multi_line_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -537 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_triple_slash_single_line_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -541 => wire__crate__api__pseudo_manual__comment_twin_rust_async__struct_with_comments_twin_rust_async_instance_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -540 => wire__crate__api__pseudo_manual__comment_twin_rust_async__struct_with_comments_twin_rust_async_static_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -551 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_loopback_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -554 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_multi_times_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -548 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -555 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -550 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -547 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_simple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -549 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_two_args_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -552 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with_dart_opaque_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -553 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with_dart_opaque_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -556 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__async_accept_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -571 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__clone_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -567 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__create_enum_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -565 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__create_nested_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -570 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__drop_static_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -568 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__get_enum_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -566 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__get_nested_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -562 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_array_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -559 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -561 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_option_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -558 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_option_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -557 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -563 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_vec_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -560 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -564 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__panic_unwrap_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -569 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__set_static_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -590 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_create_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -591 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_get_drop_count_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -588 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -589 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -596 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_simple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -600 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_discriminant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -597 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_mixed_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -599 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -598 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_tuple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -603 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_parameter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -605 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -602 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_return_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -604 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__multiply_by_ten_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -601 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__print_note_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -617 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__close_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -618 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__create_event_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -619 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__event_twin_rust_async_as_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -616 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__register_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -624 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -625 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -623 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_return_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -626 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_nested_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -627 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -644 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -647 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_nonstatic_return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -648 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_nonstatic_return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -645 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_static_return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -646 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_static_return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -620 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -621 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_fallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -622 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_infallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -637 => wire__crate__api__pseudo_manual__exception_twin_rust_async__panic_with_custom_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -631 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -632 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_1_variant1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -633 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -634 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -635 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -628 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -630 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_error_variant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -629 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -639 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -642 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_non_static_return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -643 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_non_static_return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -640 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_static_return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -641 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_static_return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -638 => wire__crate__api__pseudo_manual__exception_twin_rust_async__stream_sink_throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -636 => wire__crate__api__pseudo_manual__exception_twin_rust_async__throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -681 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__call_new_module_system_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -680 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__call_old_module_system_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -679 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__use_imported_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -678 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__use_imported_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -686 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_i32_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -690 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -693 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_complex_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -692 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_simple_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -688 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -691 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -687 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_set_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -689 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_set_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -723 => wire__crate__api__pseudo_manual__method_twin_rust_async__StaticGetterOnlyTwinRustAsync_static_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -706 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_concatenate_static_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -705 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_concatenate_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -711 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_static_stream_sink_single_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -710 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_static_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -709 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_stream_sink_at_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -708 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -704 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -707 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_simple_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -703 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -702 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -713 => wire__crate__api__pseudo_manual__method_twin_rust_async__my_callable_twin_rust_async_call_impl(port, ptr, rust_vec_len, data_len), -719 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_enum_twin_rust_async_return_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -720 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_enum_twin_rust_async_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -721 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_primitive_enum_twin_rust_async_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -717 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_arg_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -715 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_receiver_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -716 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_receiver_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -714 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_return_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -718 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_vec_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -722 => wire__crate__api__pseudo_manual__method_twin_rust_async__static_only_twin_rust_async_static_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -712 => wire__crate__api__pseudo_manual__method_twin_rust_async__sum_with_twin_rust_async_sum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -749 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -750 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_vec_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -756 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -757 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -746 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -747 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_fallible_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -753 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_message_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -748 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__is_app_embedded_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -771 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_array_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -766 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -769 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_map_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -767 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_option_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -770 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_set_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -751 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_struct_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -752 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_tuple_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -768 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_vec_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -754 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -755 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -764 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_contains_mirrored_sub_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -762 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_fallible_of_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -765 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_hashmap_with_mirrored_value_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -763 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_list_of_nested_enums_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -761 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_list_of_raw_nested_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -759 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_nested_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -760 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_raw_string_enum_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -758 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -801 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_big_buffers_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -798 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_complex_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -800 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_nested_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -804 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -806 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -805 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_vec_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -799 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__list_of_primitive_enums_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -802 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__test_abc_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -803 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__test_struct_with_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -819 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__empty_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -816 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__func_return_unit_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -817 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__handle_list_of_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -818 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__handle_string_list_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -824 => wire__crate__api__pseudo_manual__newtype_pattern_twin_rust_async__handle_newtype_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -826 => wire__crate__api__pseudo_manual__optional_primitive_misc_twin_rust_async__primitive_optional_types_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -831 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_increment_boxed_optional_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -833 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_option_box_arguments_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -830 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_increment_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -828 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -829 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -832 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_vec_of_opts_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -842 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -841 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_str_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -840 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -843 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -848 => wire__crate__api__pseudo_manual__primitive_list_misc_twin_rust_async__handle_vec_of_primitive_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -850 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_types_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -851 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -855 => wire__crate__api__pseudo_manual__raw_string_twin_rust_async__test_more_than_just_one_raw_string_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -854 => wire__crate__api__pseudo_manual__raw_string_twin_rust_async__test_raw_string_item_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -901 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -902 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -900 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -904 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -903 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -898 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_custom_name_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -897 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -899 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_with_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -894 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -895 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -893 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -896 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -859 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -860 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -862 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_own_and_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -858 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -883 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_vec_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -892 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_borrow_and_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -891 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_borrow_and_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -867 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_callable_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -868 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_callable_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -879 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_dummy_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -880 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -881 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -876 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -877 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -878 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -885 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -887 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -886 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -864 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_normal_and_opaque_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -865 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_plus_sign_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -866 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_plus_sign_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -889 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_opaque_one_and_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -890 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_opaque_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -861 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -884 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_vec_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -888 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_sleep_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -882 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -874 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -875 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -870 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -871 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -869 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -872 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_return_own_one_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -873 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_return_own_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -863 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_two_args_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -954 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_array_opaque_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -963 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -952 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -953 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_option_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -966 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__frb_generator_test_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -960 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -958 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -962 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -961 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -955 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_enum_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -964 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -959 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_non_clone_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -956 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -957 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_opaque_with_delay_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -965 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__unwrap_rust_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -982 => wire__crate__api__pseudo_manual__simple_twin_rust_async__simple_adder_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -984 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -985 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -986 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_sink_arg_position_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -987 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_of_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -988 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -989 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -990 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_3_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -991 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_fixed_sized_primitive_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -993 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -992 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -995 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -996 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_two_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -994 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_zero_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -997 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_one_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -998 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_two_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1005 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1004 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1008 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_alias_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1010 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_alias_model_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1009 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_nest_alias_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1016 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_nested_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1014 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1015 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1021 => wire__crate__api__raw_string__test_more_than_just_one_raw_string_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1020 => wire__crate__api__raw_string__test_raw_string_item_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1065 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1066 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1064 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1068 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1067 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1062 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_custom_name_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1061 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1063 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_with_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1058 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1059 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1057 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1060 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1023 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1024 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1026 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_and_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1022 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1047 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1056 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1055 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1031 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1032 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1043 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_dummy_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1044 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1045 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1040 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1041 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1042 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1049 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1051 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1050 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1028 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_normal_and_opaque_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1029 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1030 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1053 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_one_and_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1054 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1025 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1048 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1052 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_sleep_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1046 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1038 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1039 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1034 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1035 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1033 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1036 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_return_own_one_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1037 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_return_own_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1027 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_two_args_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1071 => wire__crate__api__rust_opaque__create_array_opaque_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1080 => wire__crate__api__rust_opaque__create_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1069 => wire__crate__api__rust_opaque__create_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1070 => wire__crate__api__rust_opaque__create_option_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1083 => wire__crate__api__rust_opaque__frb_generator_test_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1077 => wire__crate__api__rust_opaque__opaque_array_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1075 => wire__crate__api__rust_opaque__opaque_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1079 => wire__crate__api__rust_opaque__opaque_vec_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1078 => wire__crate__api__rust_opaque__opaque_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1072 => wire__crate__api__rust_opaque__run_enum_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1081 => wire__crate__api__rust_opaque__run_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1076 => wire__crate__api__rust_opaque__run_non_clone_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1073 => wire__crate__api__rust_opaque__run_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1074 => wire__crate__api__rust_opaque__run_opaque_with_delay_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1082 => wire__crate__api__rust_opaque__unwrap_rust_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1088 => wire__crate__api__simple__simple_adder_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1089 => wire__crate__api__stream__func_stream_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1090 => wire__crate__api__stream__func_stream_return_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1091 => wire__crate__api__stream__func_stream_sink_arg_position_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1092 => wire__crate__api__stream__handle_stream_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1093 => wire__crate__api__stream__handle_stream_sink_at_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1094 => wire__crate__api__stream__handle_stream_sink_at_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1095 => wire__crate__api__stream__handle_stream_sink_at_3_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1096 => wire__crate__api__stream__stream_sink_fixed_sized_primitive_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1098 => wire__crate__api__stream__stream_sink_inside_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1097 => wire__crate__api__stream__stream_sink_inside_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1099 => wire__crate__api__stream_misc__func_stream_realistic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1100 => wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1102 => wire__crate__api__structure__func_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1103 => wire__crate__api__structure__func_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1101 => wire__crate__api__structure__func_struct_with_zero_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1104 => wire__crate__api__structure__func_tuple_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1105 => wire__crate__api__structure__func_tuple_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1107 => wire__crate__api__tuple__test_tuple_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1106 => wire__crate__api__tuple__test_tuple_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1108 => wire__crate__api__type_alias__handle_type_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1110 => wire__crate__api__type_alias__handle_type_alias_model_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1109 => wire__crate__api__type_alias__handle_type_nest_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1113 => wire__crate__api__uuid_type__handle_nested_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1111 => wire__crate__api__uuid_type__handle_uuid_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1112 => wire__crate__api__uuid_type__handle_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), +206 => wire__crate__api__misc_no_twin_example_a__StructInMiscNoTwinExampleA_sample_function_a_impl(port, ptr, rust_vec_len, data_len), +207 => wire__crate__api__misc_no_twin_example_a__StructWithImplBlockInMultiFile_method_in_a_impl(port, ptr, rust_vec_len, data_len), +205 => wire__crate__api__misc_no_twin_example_a__function_with_custom_name_twin_normal_impl(port, ptr, rust_vec_len, data_len), +204 => wire__crate__api__misc_no_twin_example_a__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), +213 => wire__crate__api__misc_no_twin_example_a__struct_with_impl_block_in_another_file_f_impl(port, ptr, rust_vec_len, data_len), +210 => wire__crate__api__misc_no_twin_example_b__StructInMiscNoTwinExampleB_get_struct_in_misc_no_twin_example_a_impl(port, ptr, rust_vec_len, data_len), +211 => wire__crate__api__misc_no_twin_example_b__StructInMiscNoTwinExampleB_sample_function_b_impl(port, ptr, rust_vec_len, data_len), +212 => wire__crate__api__misc_no_twin_example_b__StructWithImplBlockInMultiFile_method_in_b_impl(port, ptr, rust_vec_len, data_len), +209 => wire__crate__api__misc_no_twin_example_b__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), +217 => wire__crate__api__misc_type__empty_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +214 => wire__crate__api__misc_type__func_return_unit_twin_normal_impl(port, ptr, rust_vec_len, data_len), +215 => wire__crate__api__misc_type__handle_list_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +216 => wire__crate__api__misc_type__handle_string_list_twin_normal_impl(port, ptr, rust_vec_len, data_len), +218 => wire__crate__api__newtype_pattern__handle_newtype_twin_normal_impl(port, ptr, rust_vec_len, data_len), +222 => wire__crate__api__optional__handle_increment_boxed_optional_twin_normal_impl(port, ptr, rust_vec_len, data_len), +224 => wire__crate__api__optional__handle_option_box_arguments_twin_normal_impl(port, ptr, rust_vec_len, data_len), +221 => wire__crate__api__optional__handle_optional_increment_twin_normal_impl(port, ptr, rust_vec_len, data_len), +219 => wire__crate__api__optional__handle_optional_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +220 => wire__crate__api__optional__handle_optional_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +223 => wire__crate__api__optional__handle_vec_of_opts_twin_normal_impl(port, ptr, rust_vec_len, data_len), +225 => wire__crate__api__optional_primitive_misc__primitive_optional_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), +228 => wire__crate__api__ownership__borrow_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +227 => wire__crate__api__ownership__borrow_str_twin_normal_impl(port, ptr, rust_vec_len, data_len), +226 => wire__crate__api__ownership__borrow_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +229 => wire__crate__api__ownership__borrow_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +230 => wire__crate__api__primitive_list_misc__handle_vec_of_primitive_twin_normal_impl(port, ptr, rust_vec_len, data_len), +231 => wire__crate__api__primitive_misc__primitive_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), +232 => wire__crate__api__primitive_misc__primitive_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +237 => wire__crate__api__pseudo_manual__array_twin_rust_async__boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +241 => wire__crate__api__pseudo_manual__array_twin_rust_async__func_test_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +233 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +234 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_complex_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +242 => wire__crate__api__pseudo_manual__array_twin_rust_async__last_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +243 => wire__crate__api__pseudo_manual__array_twin_rust_async__nested_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +235 => wire__crate__api__pseudo_manual__array_twin_rust_async__new_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +239 => wire__crate__api__pseudo_manual__array_twin_rust_async__return_boxed_feed_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +240 => wire__crate__api__pseudo_manual__array_twin_rust_async__return_boxed_raw_feed_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +238 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +236 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +256 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__handle_customized_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +257 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__next_user_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +281 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +280 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +282 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +277 => wire__crate__api__pseudo_manual__basic__example_basic_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +279 => wire__crate__api__pseudo_manual__basic__example_basic_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +275 => wire__crate__api__pseudo_manual__basic__example_basic_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +276 => wire__crate__api__pseudo_manual__basic__example_basic_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +266 => wire__crate__api__pseudo_manual__basic__example_basic_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +267 => wire__crate__api__pseudo_manual__basic__example_basic_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +268 => wire__crate__api__pseudo_manual__basic__example_basic_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +265 => wire__crate__api__pseudo_manual__basic__example_basic_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +273 => wire__crate__api__pseudo_manual__basic__example_basic_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +278 => wire__crate__api__pseudo_manual__basic__example_basic_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +270 => wire__crate__api__pseudo_manual__basic__example_basic_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +271 => wire__crate__api__pseudo_manual__basic__example_basic_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +272 => wire__crate__api__pseudo_manual__basic__example_basic_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +269 => wire__crate__api__pseudo_manual__basic__example_basic_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +274 => wire__crate__api__pseudo_manual__basic__example_basic_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +297 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +296 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +298 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +293 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +295 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +291 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +292 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +284 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +285 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +286 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +283 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +294 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +288 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +289 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +290 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +287 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +313 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +312 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +314 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +309 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +311 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +307 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +308 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +300 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +301 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +302 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +299 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +310 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +304 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +305 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +306 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +303 => wire__crate__api__pseudo_manual__basic_list_twin_rust_async__example_basic_list_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +347 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +346 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +348 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +343 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +345 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +341 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +342 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +332 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +333 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +334 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +331 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +339 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +344 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +336 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +337 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +338 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +335 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +340 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +365 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +364 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +366 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +361 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +363 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +359 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +360 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +350 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +351 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +352 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +349 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +357 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +362 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +354 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +355 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +356 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +353 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +358 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +401 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +400 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +402 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +397 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +399 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +395 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +396 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +386 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +387 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +388 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +385 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +393 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +398 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +390 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +391 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +392 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +389 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +394 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +419 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +418 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +420 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +415 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +417 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +413 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +414 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +404 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +405 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +406 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +403 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +411 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +416 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +408 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +409 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +410 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +407 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +412 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +455 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_general_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +454 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_primitive_enum_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +456 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_basic_struct_twin_rust_async_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +451 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +453 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +449 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +450 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +440 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +441 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +442 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +439 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +447 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +452 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +444 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +445 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +446 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +443 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +448 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +482 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +480 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +478 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), +483 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +481 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +479 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), +488 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +486 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +484 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), +489 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +487 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +485 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), +476 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_input_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +477 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_output_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +475 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_void_twin_normal_impl(port, ptr, rust_vec_len, data_len), +497 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +495 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +493 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_input_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +498 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +496 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +494 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_binary_tree_output_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +503 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +501 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +499 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +504 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_json_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +502 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_protobuf_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +500 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +491 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_input_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +492 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_output_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +490 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_void_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +521 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_local_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +520 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_utc_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +524 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__duration_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +526 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_durations_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +525 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_timestamps_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +529 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__how_long_does_it_take_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +522 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__naivedatetime_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +523 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__optional_empty_datetime_utc_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +527 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +528 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_precise_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +542 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_slash_star_star_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +541 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_triple_slash_multi_line_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +540 => wire__crate__api__pseudo_manual__comment_twin_rust_async__function_with_comments_triple_slash_single_line_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +544 => wire__crate__api__pseudo_manual__comment_twin_rust_async__struct_with_comments_twin_rust_async_instance_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +543 => wire__crate__api__pseudo_manual__comment_twin_rust_async__struct_with_comments_twin_rust_async_static_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +554 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_loopback_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +557 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_multi_times_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +551 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_one_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +558 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +553 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +550 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_simple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +552 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_two_args_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +555 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with_dart_opaque_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +556 => wire__crate__api__pseudo_manual__dart_fn_twin_rust_async__rust_call_dart_with_dart_opaque_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +559 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__async_accept_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +574 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__clone_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +570 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__create_enum_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +568 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__create_nested_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +573 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__drop_static_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +571 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__get_enum_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +569 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__get_nested_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +565 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_array_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +562 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +564 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_option_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +561 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_option_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +560 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +566 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_vec_get_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +563 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +567 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__panic_unwrap_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +572 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__set_static_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +593 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_create_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +594 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_get_drop_count_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +591 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +592 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +599 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_simple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +603 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_discriminant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +600 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_mixed_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +602 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +601 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_item_tuple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +606 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_parameter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +608 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +605 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_return_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +607 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__multiply_by_ten_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +604 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__print_note_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +620 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__close_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +621 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__create_event_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +622 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__event_twin_rust_async_as_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +619 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__register_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +627 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +628 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +626 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_return_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +629 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_nested_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +630 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_error_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +647 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +650 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_nonstatic_return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +651 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_nonstatic_return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +648 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_static_return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +649 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_struct_twin_rust_async_static_return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +623 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +624 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_fallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +625 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_infallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +640 => wire__crate__api__pseudo_manual__exception_twin_rust_async__panic_with_custom_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +634 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +635 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_1_variant1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +636 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_nested_error_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +637 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +638 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +631 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +633 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_error_variant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +632 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +642 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +645 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_non_static_return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +646 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_non_static_return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +643 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_static_return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +644 => wire__crate__api__pseudo_manual__exception_twin_rust_async__some_struct_twin_rust_async_static_return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +641 => wire__crate__api__pseudo_manual__exception_twin_rust_async__stream_sink_throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +639 => wire__crate__api__pseudo_manual__exception_twin_rust_async__throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +684 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__call_new_module_system_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +683 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__call_old_module_system_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +682 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__use_imported_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +681 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_rust_async__use_imported_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +689 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_i32_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +693 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +696 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_complex_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +695 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_simple_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +691 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +694 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_map_string_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +690 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_set_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +692 => wire__crate__api__pseudo_manual__map_and_set_twin_rust_async__func_hash_set_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +726 => wire__crate__api__pseudo_manual__method_twin_rust_async__StaticGetterOnlyTwinRustAsync_static_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +709 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_concatenate_static_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +708 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_concatenate_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +714 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_static_stream_sink_single_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +713 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_static_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +712 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_stream_sink_at_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +711 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_handle_some_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +707 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +710 => wire__crate__api__pseudo_manual__method_twin_rust_async__concatenate_with_twin_rust_async_simple_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +706 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +705 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +716 => wire__crate__api__pseudo_manual__method_twin_rust_async__my_callable_twin_rust_async_call_impl(port, ptr, rust_vec_len, data_len), +722 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_enum_twin_rust_async_return_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +723 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_enum_twin_rust_async_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +724 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_primitive_enum_twin_rust_async_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +720 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_arg_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +718 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_receiver_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +719 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_receiver_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +717 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_return_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +721 => wire__crate__api__pseudo_manual__method_twin_rust_async__simple_struct_twin_rust_async_vec_self_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +725 => wire__crate__api__pseudo_manual__method_twin_rust_async__static_only_twin_rust_async_static_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +715 => wire__crate__api__pseudo_manual__method_twin_rust_async__sum_with_twin_rust_async_sum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +752 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +753 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_vec_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +759 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +760 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +749 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +750 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_fallible_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +756 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_message_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +751 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__is_app_embedded_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +774 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_array_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +769 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +772 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_map_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +770 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_option_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +773 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_set_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +754 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_struct_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +755 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_tuple_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +771 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_vec_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +757 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +758 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +767 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_contains_mirrored_sub_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +765 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_fallible_of_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +768 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_hashmap_with_mirrored_value_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +766 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_list_of_nested_enums_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +764 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_list_of_raw_nested_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +762 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_nested_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +763 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_raw_string_enum_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +761 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +804 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_big_buffers_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +808 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_char_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +801 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_complex_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +803 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_nested_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +807 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +810 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +809 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_vec_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +802 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__list_of_primitive_enums_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +805 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__test_abc_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +806 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__test_struct_with_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +824 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__empty_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +821 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__func_return_unit_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +822 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__handle_list_of_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +823 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__handle_string_list_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +829 => wire__crate__api__pseudo_manual__newtype_pattern_twin_rust_async__handle_newtype_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +831 => wire__crate__api__pseudo_manual__optional_primitive_misc_twin_rust_async__primitive_optional_types_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +836 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_increment_boxed_optional_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +838 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_option_box_arguments_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +835 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_increment_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +833 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +834 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +837 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_vec_of_opts_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +847 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +846 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_str_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +845 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +848 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +853 => wire__crate__api__pseudo_manual__primitive_list_misc_twin_rust_async__handle_vec_of_primitive_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +855 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_types_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +856 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +860 => wire__crate__api__pseudo_manual__raw_string_twin_rust_async__test_more_than_just_one_raw_string_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +859 => wire__crate__api__pseudo_manual__raw_string_twin_rust_async__test_raw_string_item_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +906 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +907 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +905 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +909 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +908 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_instance_method_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +903 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_custom_name_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +902 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +904 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_with_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +899 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +900 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +898 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +901 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_static_method_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +864 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +865 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +867 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_own_and_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +863 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +888 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_arg_vec_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +897 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_borrow_and_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +896 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_borrow_and_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +872 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_callable_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +873 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_callable_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +884 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_dummy_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +885 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +886 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +881 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +882 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +883 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +890 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +892 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +891 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +869 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_normal_and_opaque_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +870 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_plus_sign_arg_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +871 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_plus_sign_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +894 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_opaque_one_and_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +895 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_opaque_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +866 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +889 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_return_vec_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +893 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_sleep_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +887 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_stream_sink_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +879 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +880 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +875 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +876 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_mut_borrow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +874 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_arg_own_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +877 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_return_own_one_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +878 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_trait_object_return_own_two_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +868 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_two_args_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +959 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_array_opaque_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +968 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +957 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +958 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_option_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +971 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__frb_generator_test_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +965 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +963 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +967 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +966 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +960 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_enum_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +969 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +964 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_non_clone_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +961 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +962 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_opaque_with_delay_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +970 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__unwrap_rust_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +987 => wire__crate__api__pseudo_manual__simple_twin_rust_async__simple_adder_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +989 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +990 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +991 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_sink_arg_position_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +992 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_of_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +993 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_1_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +994 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +995 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_sink_at_3_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +996 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_fixed_sized_primitive_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +998 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +997 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1000 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1001 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_two_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +999 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_zero_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1002 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_one_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1003 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_two_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1010 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1009 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1013 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_alias_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1015 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_alias_model_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1014 => wire__crate__api__pseudo_manual__type_alias_twin_rust_async__handle_type_nest_alias_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1021 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_nested_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1019 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1020 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1026 => wire__crate__api__raw_string__test_more_than_just_one_raw_string_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1025 => wire__crate__api__raw_string__test_raw_string_item_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1070 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1071 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1069 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1073 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1072 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1067 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_custom_name_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1066 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1068 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_with_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1063 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1064 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1062 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1065 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1028 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1029 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1031 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_and_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1027 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1052 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1061 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1060 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1036 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1037 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1048 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_dummy_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1049 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1050 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1045 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1046 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1047 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1054 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1056 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1055 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1033 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_normal_and_opaque_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1034 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1035 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1058 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_one_and_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1059 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1030 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1053 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1057 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_sleep_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1051 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1043 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1044 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1039 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1040 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1038 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1041 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_return_own_one_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1042 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_trait_object_return_own_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1032 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_two_args_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1076 => wire__crate__api__rust_opaque__create_array_opaque_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1085 => wire__crate__api__rust_opaque__create_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1074 => wire__crate__api__rust_opaque__create_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1075 => wire__crate__api__rust_opaque__create_option_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1088 => wire__crate__api__rust_opaque__frb_generator_test_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1082 => wire__crate__api__rust_opaque__opaque_array_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1080 => wire__crate__api__rust_opaque__opaque_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1084 => wire__crate__api__rust_opaque__opaque_vec_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1083 => wire__crate__api__rust_opaque__opaque_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1077 => wire__crate__api__rust_opaque__run_enum_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1086 => wire__crate__api__rust_opaque__run_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1081 => wire__crate__api__rust_opaque__run_non_clone_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1078 => wire__crate__api__rust_opaque__run_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1079 => wire__crate__api__rust_opaque__run_opaque_with_delay_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1087 => wire__crate__api__rust_opaque__unwrap_rust_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1093 => wire__crate__api__simple__simple_adder_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1094 => wire__crate__api__stream__func_stream_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1095 => wire__crate__api__stream__func_stream_return_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1096 => wire__crate__api__stream__func_stream_sink_arg_position_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1097 => wire__crate__api__stream__handle_stream_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1098 => wire__crate__api__stream__handle_stream_sink_at_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1099 => wire__crate__api__stream__handle_stream_sink_at_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1100 => wire__crate__api__stream__handle_stream_sink_at_3_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1101 => wire__crate__api__stream__stream_sink_fixed_sized_primitive_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1103 => wire__crate__api__stream__stream_sink_inside_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1102 => wire__crate__api__stream__stream_sink_inside_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1104 => wire__crate__api__stream_misc__func_stream_realistic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1105 => wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1107 => wire__crate__api__structure__func_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1108 => wire__crate__api__structure__func_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1106 => wire__crate__api__structure__func_struct_with_zero_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1109 => wire__crate__api__structure__func_tuple_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1110 => wire__crate__api__structure__func_tuple_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1112 => wire__crate__api__tuple__test_tuple_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1111 => wire__crate__api__tuple__test_tuple_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1113 => wire__crate__api__type_alias__handle_type_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1115 => wire__crate__api__type_alias__handle_type_alias_model_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1114 => wire__crate__api__type_alias__handle_type_nest_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1118 => wire__crate__api__uuid_type__handle_nested_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1116 => wire__crate__api__uuid_type__handle_uuid_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1117 => wire__crate__api__uuid_type__handle_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), _ => unreachable!(), } } @@ -35473,348 +35620,350 @@ fn pde_ffi_dispatcher_sync_impl( 78 => wire__crate__api__dart_opaque_sync__unwrap_dart_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), 98 => wire__crate__api__event_listener__create_event_sync_twin_normal_impl(ptr, rust_vec_len, data_len), 130 => wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new_impl(ptr, rust_vec_len, data_len), -245 => wire__crate__api__pseudo_manual__array_twin_sync__boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), -249 => wire__crate__api__pseudo_manual__array_twin_sync__func_test_id_twin_sync_impl(ptr, rust_vec_len, data_len), -241 => wire__crate__api__pseudo_manual__array_twin_sync__get_array_twin_sync_impl(ptr, rust_vec_len, data_len), -242 => wire__crate__api__pseudo_manual__array_twin_sync__get_complex_array_twin_sync_impl(ptr, rust_vec_len, data_len), -250 => wire__crate__api__pseudo_manual__array_twin_sync__last_number_twin_sync_impl(ptr, rust_vec_len, data_len), -251 => wire__crate__api__pseudo_manual__array_twin_sync__nested_id_twin_sync_impl(ptr, rust_vec_len, data_len), -243 => wire__crate__api__pseudo_manual__array_twin_sync__new_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), -247 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), -248 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_raw_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), -246 => wire__crate__api__pseudo_manual__array_twin_sync__use_boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), -244 => wire__crate__api__pseudo_manual__array_twin_sync__use_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), -258 => wire__crate__api__pseudo_manual__attribute_twin_sync__handle_customized_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -259 => wire__crate__api__pseudo_manual__attribute_twin_sync__next_user_id_twin_sync_impl(ptr, rust_vec_len, data_len), -326 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -325 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -327 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -322 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -324 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -320 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -321 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -313 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -314 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -315 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -312 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -323 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -317 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -318 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -319 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -316 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -380 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -379 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -381 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -376 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -378 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -374 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -375 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -365 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -366 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -367 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -364 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -372 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), -377 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -369 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -370 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -371 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -368 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -373 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), -434 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -433 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -435 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -430 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -432 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -428 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -429 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -419 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -420 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -421 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -418 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -426 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), -431 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -423 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -424 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -425 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -422 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -427 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), -470 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -469 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -471 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -466 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -468 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -464 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -465 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -455 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -456 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -457 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -454 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -462 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), -467 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -459 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -460 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -461 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -458 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -463 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), -509 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), -507 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -505 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_twin_sync_impl(ptr, rust_vec_len, data_len), -510 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), -508 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -506 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_twin_sync_impl(ptr, rust_vec_len, data_len), -515 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), -513 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -511 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_twin_sync_impl(ptr, rust_vec_len, data_len), -516 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), -514 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -512 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_twin_sync_impl(ptr, rust_vec_len, data_len), -503 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_input_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -504 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_output_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -502 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_void_twin_sync_impl(ptr, rust_vec_len, data_len), -528 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_local_twin_sync_impl(ptr, rust_vec_len, data_len), -527 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), -531 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__duration_twin_sync_impl(ptr, rust_vec_len, data_len), -533 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_durations_twin_sync_impl(ptr, rust_vec_len, data_len), -532 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_timestamps_twin_sync_impl(ptr, rust_vec_len, data_len), -536 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__how_long_does_it_take_twin_sync_impl(ptr, rust_vec_len, data_len), -529 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__naivedatetime_twin_sync_impl(ptr, rust_vec_len, data_len), -530 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__optional_empty_datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), -534 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), -535 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_precise_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), -544 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_slash_star_star_twin_sync_impl(ptr, rust_vec_len, data_len), -543 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_multi_line_twin_sync_impl(ptr, rust_vec_len, data_len), -542 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_single_line_twin_sync_impl(ptr, rust_vec_len, data_len), -546 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_instance_method_twin_sync_impl(ptr, rust_vec_len, data_len), -545 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), -572 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__async_accept_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -587 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__clone_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -583 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -581 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -586 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__drop_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -584 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -582 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -578 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_get_twin_sync_impl(ptr, rust_vec_len, data_len), -575 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_twin_sync_impl(ptr, rust_vec_len, data_len), -577 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_get_twin_sync_impl(ptr, rust_vec_len, data_len), -574 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_twin_sync_impl(ptr, rust_vec_len, data_len), -573 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_twin_sync_impl(ptr, rust_vec_len, data_len), -579 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_get_twin_sync_impl(ptr, rust_vec_len, data_len), -576 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_twin_sync_impl(ptr, rust_vec_len, data_len), -580 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__panic_unwrap_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -585 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__set_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -594 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_create_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -595 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_get_drop_count_twin_sync_impl(ptr, rust_vec_len, data_len), -592 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -593 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), -606 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_simple_twin_sync_impl(ptr, rust_vec_len, data_len), -610 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_discriminant_twin_sync_impl(ptr, rust_vec_len, data_len), -607 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_mixed_twin_sync_impl(ptr, rust_vec_len, data_len), -609 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -608 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), -613 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_parameter_twin_sync_impl(ptr, rust_vec_len, data_len), -615 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -612 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_return_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -614 => wire__crate__api__pseudo_manual__enumeration_twin_sync__multiply_by_ten_twin_sync_impl(ptr, rust_vec_len, data_len), -611 => wire__crate__api__pseudo_manual__enumeration_twin_sync__print_note_twin_sync_impl(ptr, rust_vec_len, data_len), -653 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_panic_twin_sync_impl(ptr, rust_vec_len, data_len), -654 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -652 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_ok_twin_sync_impl(ptr, rust_vec_len, data_len), -655 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_nested_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -656 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -673 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -676 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_nonstatic_return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), -677 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_nonstatic_return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), -674 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_static_return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), -675 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_static_return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), -649 => wire__crate__api__pseudo_manual__exception_twin_sync__func_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -650 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_fallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), -651 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_infallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), -666 => wire__crate__api__pseudo_manual__exception_twin_sync__panic_with_custom_result_twin_sync_impl(ptr, rust_vec_len, data_len), -660 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_twin_sync_impl(ptr, rust_vec_len, data_len), -661 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_variant1_twin_sync_impl(ptr, rust_vec_len, data_len), -662 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_2_twin_sync_impl(ptr, rust_vec_len, data_len), -663 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), -664 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), -657 => wire__crate__api__pseudo_manual__exception_twin_sync__return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -659 => wire__crate__api__pseudo_manual__exception_twin_sync__return_error_variant_twin_sync_impl(ptr, rust_vec_len, data_len), -658 => wire__crate__api__pseudo_manual__exception_twin_sync__return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -668 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -671 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_non_static_return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -672 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_non_static_return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -669 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_static_return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -670 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_static_return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -667 => wire__crate__api__pseudo_manual__exception_twin_sync__stream_sink_throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), -665 => wire__crate__api__pseudo_manual__exception_twin_sync__throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), -685 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_new_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), -684 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_old_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), -683 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -682 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -694 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_i32_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -698 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -701 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_complex_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -700 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_simple_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -696 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_string_twin_sync_impl(ptr, rust_vec_len, data_len), -699 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -695 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -697 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_string_twin_sync_impl(ptr, rust_vec_len, data_len), -745 => wire__crate__api__pseudo_manual__method_twin_sync__StaticGetterOnlyTwinSync_static_getter_twin_sync_impl(ptr, rust_vec_len, data_len), -728 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_static_twin_sync_impl(ptr, rust_vec_len, data_len), -727 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_twin_sync_impl(ptr, rust_vec_len, data_len), -733 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_static_stream_sink_single_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -732 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_static_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), -731 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_stream_sink_at_1_twin_sync_impl(ptr, rust_vec_len, data_len), -730 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), -726 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -729 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_simple_getter_twin_sync_impl(ptr, rust_vec_len, data_len), -725 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_array_twin_sync_impl(ptr, rust_vec_len, data_len), -724 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -735 => wire__crate__api__pseudo_manual__method_twin_sync__my_callable_twin_sync_call_impl(ptr, rust_vec_len, data_len), -741 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), -742 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), -743 => wire__crate__api__pseudo_manual__method_twin_sync__simple_primitive_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), -739 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_arg_self_twin_sync_impl(ptr, rust_vec_len, data_len), -737 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -738 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_own_twin_sync_impl(ptr, rust_vec_len, data_len), -736 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), -740 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_vec_self_twin_sync_impl(ptr, rust_vec_len, data_len), -744 => wire__crate__api__pseudo_manual__method_twin_sync__static_only_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), -734 => wire__crate__api__pseudo_manual__method_twin_sync__sum_with_twin_sync_sum_twin_sync_impl(ptr, rust_vec_len, data_len), -775 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -776 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_vec_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -782 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_number_twin_sync_impl(ptr, rust_vec_len, data_len), -783 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), -772 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), -773 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_fallible_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), -779 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_message_twin_sync_impl(ptr, rust_vec_len, data_len), -774 => wire__crate__api__pseudo_manual__mirror_twin_sync__is_app_embedded_twin_sync_impl(ptr, rust_vec_len, data_len), -797 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_array_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -792 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -795 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_map_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -793 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_option_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -796 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_set_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -777 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_struct_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -778 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_tuple_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -794 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_vec_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -780 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_number_twin_sync_impl(ptr, rust_vec_len, data_len), -781 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), -790 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_contains_mirrored_sub_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -788 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_fallible_of_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -791 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_hashmap_with_mirrored_value_twin_sync_impl(ptr, rust_vec_len, data_len), -789 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_nested_enums_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -787 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_raw_nested_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -785 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_nested_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -786 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_enum_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -784 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -810 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_big_buffers_twin_sync_impl(ptr, rust_vec_len, data_len), -807 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_complex_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -809 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_nested_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -813 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_string_twin_sync_impl(ptr, rust_vec_len, data_len), -815 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -814 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_vec_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -808 => wire__crate__api__pseudo_manual__misc_example_twin_sync__list_of_primitive_enums_twin_sync_impl(ptr, rust_vec_len, data_len), -811 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_abc_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -812 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_struct_with_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -823 => wire__crate__api__pseudo_manual__misc_type_twin_sync__empty_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -820 => wire__crate__api__pseudo_manual__misc_type_twin_sync__func_return_unit_twin_sync_impl(ptr, rust_vec_len, data_len), -821 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_list_of_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -822 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_string_list_twin_sync_impl(ptr, rust_vec_len, data_len), -825 => wire__crate__api__pseudo_manual__newtype_pattern_twin_sync__handle_newtype_twin_sync_impl(ptr, rust_vec_len, data_len), -827 => wire__crate__api__pseudo_manual__optional_primitive_misc_twin_sync__primitive_optional_types_twin_sync_impl(ptr, rust_vec_len, data_len), -837 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_increment_boxed_optional_twin_sync_impl(ptr, rust_vec_len, data_len), -839 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_option_box_arguments_twin_sync_impl(ptr, rust_vec_len, data_len), -836 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_increment_twin_sync_impl(ptr, rust_vec_len, data_len), -834 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_return_twin_sync_impl(ptr, rust_vec_len, data_len), -835 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -838 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_vec_of_opts_twin_sync_impl(ptr, rust_vec_len, data_len), -846 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -845 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_str_twin_sync_impl(ptr, rust_vec_len, data_len), -844 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_string_twin_sync_impl(ptr, rust_vec_len, data_len), -847 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -849 => wire__crate__api__pseudo_manual__primitive_list_misc_twin_sync__handle_vec_of_primitive_twin_sync_impl(ptr, rust_vec_len, data_len), -852 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_types_twin_sync_impl(ptr, rust_vec_len, data_len), -853 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -857 => wire__crate__api__pseudo_manual__raw_string_twin_sync__test_more_than_just_one_raw_string_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -856 => wire__crate__api__pseudo_manual__raw_string_twin_sync__test_raw_string_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -948 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -949 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -947 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -951 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_getter_twin_sync_impl(ptr, rust_vec_len, data_len), -950 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -945 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_custom_name_twin_sync_impl(ptr, rust_vec_len, data_len), -944 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -946 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_with_result_twin_sync_impl(ptr, rust_vec_len, data_len), -941 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -942 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -940 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -943 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -906 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -907 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -909 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_own_and_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -905 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -930 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_vec_own_twin_sync_impl(ptr, rust_vec_len, data_len), -939 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_borrow_and_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -938 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_borrow_and_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -914 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -915 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_return_twin_sync_impl(ptr, rust_vec_len, data_len), -926 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_dummy_twin_sync_impl(ptr, rust_vec_len, data_len), -927 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -928 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -923 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -924 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_sync_impl(ptr, rust_vec_len, data_len), -925 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -932 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -934 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_return_twin_sync_impl(ptr, rust_vec_len, data_len), -933 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -911 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_normal_and_opaque_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -912 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_plus_sign_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -913 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_plus_sign_return_twin_sync_impl(ptr, rust_vec_len, data_len), -936 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_opaque_one_and_two_twin_sync_impl(ptr, rust_vec_len, data_len), -937 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_opaque_two_twin_sync_impl(ptr, rust_vec_len, data_len), -908 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -931 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_vec_own_twin_sync_impl(ptr, rust_vec_len, data_len), -935 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_sleep_twin_sync_impl(ptr, rust_vec_len, data_len), -929 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), -921 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -922 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -917 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -918 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -916 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -919 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_return_own_one_twin_sync_impl(ptr, rust_vec_len, data_len), -920 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_return_own_two_twin_sync_impl(ptr, rust_vec_len, data_len), -910 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_two_args_twin_sync_impl(ptr, rust_vec_len, data_len), -969 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_array_opaque_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -978 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -967 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -968 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_option_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -981 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__frb_generator_test_twin_sync_impl(ptr, rust_vec_len, data_len), -975 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_run_twin_sync_impl(ptr, rust_vec_len, data_len), -973 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_twin_sync_impl(ptr, rust_vec_len, data_len), -977 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_run_twin_sync_impl(ptr, rust_vec_len, data_len), -976 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_twin_sync_impl(ptr, rust_vec_len, data_len), -970 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_enum_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -979 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -974 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_non_clone_twin_sync_impl(ptr, rust_vec_len, data_len), -971 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -972 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_with_delay_twin_sync_impl(ptr, rust_vec_len, data_len), -980 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__unwrap_rust_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -983 => wire__crate__api__pseudo_manual__simple_twin_sync__simple_adder_twin_sync_impl(ptr, rust_vec_len, data_len), -1000 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1001 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), -999 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_zero_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1002 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1003 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1007 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_2_twin_sync_impl(ptr, rust_vec_len, data_len), -1006 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), -1011 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), -1013 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_model_twin_sync_impl(ptr, rust_vec_len, data_len), -1012 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_nest_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), -1019 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_nested_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), -1017 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuid_twin_sync_impl(ptr, rust_vec_len, data_len), -1018 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), -1087 => wire__crate__api__rust_opaque_sync__frb_sync_generator_test_twin_normal_impl(ptr, rust_vec_len, data_len), -1086 => wire__crate__api__rust_opaque_sync__sync_create_non_clone_twin_normal_impl(ptr, rust_vec_len, data_len), -1085 => wire__crate__api__rust_opaque_sync__sync_create_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), -1084 => wire__crate__api__rust_opaque_sync__sync_option_rust_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +208 => wire__crate__api__misc_no_twin_example_a__struct_with_custom_name_method_twin_normal_method_with_custom_name_twin_normal_impl(ptr, rust_vec_len, data_len), +248 => wire__crate__api__pseudo_manual__array_twin_sync__boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), +252 => wire__crate__api__pseudo_manual__array_twin_sync__func_test_id_twin_sync_impl(ptr, rust_vec_len, data_len), +244 => wire__crate__api__pseudo_manual__array_twin_sync__get_array_twin_sync_impl(ptr, rust_vec_len, data_len), +245 => wire__crate__api__pseudo_manual__array_twin_sync__get_complex_array_twin_sync_impl(ptr, rust_vec_len, data_len), +253 => wire__crate__api__pseudo_manual__array_twin_sync__last_number_twin_sync_impl(ptr, rust_vec_len, data_len), +254 => wire__crate__api__pseudo_manual__array_twin_sync__nested_id_twin_sync_impl(ptr, rust_vec_len, data_len), +246 => wire__crate__api__pseudo_manual__array_twin_sync__new_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), +250 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), +251 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_raw_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), +249 => wire__crate__api__pseudo_manual__array_twin_sync__use_boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), +247 => wire__crate__api__pseudo_manual__array_twin_sync__use_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), +261 => wire__crate__api__pseudo_manual__attribute_twin_sync__handle_customized_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +262 => wire__crate__api__pseudo_manual__attribute_twin_sync__next_user_id_twin_sync_impl(ptr, rust_vec_len, data_len), +329 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +328 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +330 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +325 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +327 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +323 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +324 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +316 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +317 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +318 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +315 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +326 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +320 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +321 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +322 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +319 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +383 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +382 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +384 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +379 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +381 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +377 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +378 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +368 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +369 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +370 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +367 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +375 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), +380 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +372 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +373 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +374 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +371 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +376 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), +437 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +436 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +438 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +433 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +435 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +431 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +432 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +422 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +423 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +424 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +421 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +429 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), +434 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +426 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +427 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +428 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +425 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +430 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), +473 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_general_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +472 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_primitive_enum_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +474 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +469 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +471 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +467 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +468 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +458 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +459 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +460 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +457 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +465 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), +470 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +462 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +463 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +464 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +461 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +466 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), +512 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), +510 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +508 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_twin_sync_impl(ptr, rust_vec_len, data_len), +513 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), +511 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +509 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_twin_sync_impl(ptr, rust_vec_len, data_len), +518 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), +516 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +514 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_twin_sync_impl(ptr, rust_vec_len, data_len), +519 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), +517 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +515 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_twin_sync_impl(ptr, rust_vec_len, data_len), +506 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_input_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +507 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_output_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +505 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_void_twin_sync_impl(ptr, rust_vec_len, data_len), +531 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_local_twin_sync_impl(ptr, rust_vec_len, data_len), +530 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), +534 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__duration_twin_sync_impl(ptr, rust_vec_len, data_len), +536 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_durations_twin_sync_impl(ptr, rust_vec_len, data_len), +535 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_timestamps_twin_sync_impl(ptr, rust_vec_len, data_len), +539 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__how_long_does_it_take_twin_sync_impl(ptr, rust_vec_len, data_len), +532 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__naivedatetime_twin_sync_impl(ptr, rust_vec_len, data_len), +533 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__optional_empty_datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), +537 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), +538 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_precise_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), +547 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_slash_star_star_twin_sync_impl(ptr, rust_vec_len, data_len), +546 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_multi_line_twin_sync_impl(ptr, rust_vec_len, data_len), +545 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_single_line_twin_sync_impl(ptr, rust_vec_len, data_len), +549 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_instance_method_twin_sync_impl(ptr, rust_vec_len, data_len), +548 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), +575 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__async_accept_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +590 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__clone_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +586 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +584 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +589 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__drop_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +587 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +585 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +581 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_get_twin_sync_impl(ptr, rust_vec_len, data_len), +578 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_twin_sync_impl(ptr, rust_vec_len, data_len), +580 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_get_twin_sync_impl(ptr, rust_vec_len, data_len), +577 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_twin_sync_impl(ptr, rust_vec_len, data_len), +576 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_twin_sync_impl(ptr, rust_vec_len, data_len), +582 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_get_twin_sync_impl(ptr, rust_vec_len, data_len), +579 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_twin_sync_impl(ptr, rust_vec_len, data_len), +583 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__panic_unwrap_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +588 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__set_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +597 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_create_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +598 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_get_drop_count_twin_sync_impl(ptr, rust_vec_len, data_len), +595 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +596 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), +609 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_simple_twin_sync_impl(ptr, rust_vec_len, data_len), +613 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_discriminant_twin_sync_impl(ptr, rust_vec_len, data_len), +610 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_mixed_twin_sync_impl(ptr, rust_vec_len, data_len), +612 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +611 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), +616 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_parameter_twin_sync_impl(ptr, rust_vec_len, data_len), +618 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +615 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_return_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +617 => wire__crate__api__pseudo_manual__enumeration_twin_sync__multiply_by_ten_twin_sync_impl(ptr, rust_vec_len, data_len), +614 => wire__crate__api__pseudo_manual__enumeration_twin_sync__print_note_twin_sync_impl(ptr, rust_vec_len, data_len), +656 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_panic_twin_sync_impl(ptr, rust_vec_len, data_len), +657 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +655 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_ok_twin_sync_impl(ptr, rust_vec_len, data_len), +658 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_nested_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +659 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +676 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +679 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_nonstatic_return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), +680 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_nonstatic_return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), +677 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_static_return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), +678 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_static_return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), +652 => wire__crate__api__pseudo_manual__exception_twin_sync__func_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +653 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_fallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), +654 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_infallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), +669 => wire__crate__api__pseudo_manual__exception_twin_sync__panic_with_custom_result_twin_sync_impl(ptr, rust_vec_len, data_len), +663 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_twin_sync_impl(ptr, rust_vec_len, data_len), +664 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_variant1_twin_sync_impl(ptr, rust_vec_len, data_len), +665 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_2_twin_sync_impl(ptr, rust_vec_len, data_len), +666 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), +667 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), +660 => wire__crate__api__pseudo_manual__exception_twin_sync__return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +662 => wire__crate__api__pseudo_manual__exception_twin_sync__return_error_variant_twin_sync_impl(ptr, rust_vec_len, data_len), +661 => wire__crate__api__pseudo_manual__exception_twin_sync__return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +671 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +674 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_non_static_return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +675 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_non_static_return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +672 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_static_return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +673 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_static_return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +670 => wire__crate__api__pseudo_manual__exception_twin_sync__stream_sink_throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), +668 => wire__crate__api__pseudo_manual__exception_twin_sync__throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), +688 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_new_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), +687 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_old_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), +686 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +685 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +697 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_i32_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +701 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +704 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_complex_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +703 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_simple_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +699 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_string_twin_sync_impl(ptr, rust_vec_len, data_len), +702 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +698 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +700 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_string_twin_sync_impl(ptr, rust_vec_len, data_len), +748 => wire__crate__api__pseudo_manual__method_twin_sync__StaticGetterOnlyTwinSync_static_getter_twin_sync_impl(ptr, rust_vec_len, data_len), +731 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_static_twin_sync_impl(ptr, rust_vec_len, data_len), +730 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_twin_sync_impl(ptr, rust_vec_len, data_len), +736 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_static_stream_sink_single_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +735 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_static_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), +734 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_stream_sink_at_1_twin_sync_impl(ptr, rust_vec_len, data_len), +733 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_handle_some_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), +729 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +732 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_simple_getter_twin_sync_impl(ptr, rust_vec_len, data_len), +728 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_array_twin_sync_impl(ptr, rust_vec_len, data_len), +727 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +738 => wire__crate__api__pseudo_manual__method_twin_sync__my_callable_twin_sync_call_impl(ptr, rust_vec_len, data_len), +744 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), +745 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), +746 => wire__crate__api__pseudo_manual__method_twin_sync__simple_primitive_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), +742 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_arg_self_twin_sync_impl(ptr, rust_vec_len, data_len), +740 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +741 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_own_twin_sync_impl(ptr, rust_vec_len, data_len), +739 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), +743 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_vec_self_twin_sync_impl(ptr, rust_vec_len, data_len), +747 => wire__crate__api__pseudo_manual__method_twin_sync__static_only_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), +737 => wire__crate__api__pseudo_manual__method_twin_sync__sum_with_twin_sync_sum_twin_sync_impl(ptr, rust_vec_len, data_len), +778 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +779 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_vec_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +785 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_number_twin_sync_impl(ptr, rust_vec_len, data_len), +786 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), +775 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), +776 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_fallible_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), +782 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_message_twin_sync_impl(ptr, rust_vec_len, data_len), +777 => wire__crate__api__pseudo_manual__mirror_twin_sync__is_app_embedded_twin_sync_impl(ptr, rust_vec_len, data_len), +800 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_array_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +795 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +798 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_map_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +796 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_option_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +799 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_set_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +780 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_struct_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +781 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_tuple_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +797 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_vec_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +783 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_number_twin_sync_impl(ptr, rust_vec_len, data_len), +784 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), +793 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_contains_mirrored_sub_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +791 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_fallible_of_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +794 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_hashmap_with_mirrored_value_twin_sync_impl(ptr, rust_vec_len, data_len), +792 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_nested_enums_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +790 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_raw_nested_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +788 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_nested_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +789 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_enum_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +787 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +814 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_big_buffers_twin_sync_impl(ptr, rust_vec_len, data_len), +818 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_char_twin_sync_impl(ptr, rust_vec_len, data_len), +811 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_complex_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +813 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_nested_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +817 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_string_twin_sync_impl(ptr, rust_vec_len, data_len), +820 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +819 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_vec_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +812 => wire__crate__api__pseudo_manual__misc_example_twin_sync__list_of_primitive_enums_twin_sync_impl(ptr, rust_vec_len, data_len), +815 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_abc_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +816 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_struct_with_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +828 => wire__crate__api__pseudo_manual__misc_type_twin_sync__empty_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +825 => wire__crate__api__pseudo_manual__misc_type_twin_sync__func_return_unit_twin_sync_impl(ptr, rust_vec_len, data_len), +826 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_list_of_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +827 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_string_list_twin_sync_impl(ptr, rust_vec_len, data_len), +830 => wire__crate__api__pseudo_manual__newtype_pattern_twin_sync__handle_newtype_twin_sync_impl(ptr, rust_vec_len, data_len), +832 => wire__crate__api__pseudo_manual__optional_primitive_misc_twin_sync__primitive_optional_types_twin_sync_impl(ptr, rust_vec_len, data_len), +842 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_increment_boxed_optional_twin_sync_impl(ptr, rust_vec_len, data_len), +844 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_option_box_arguments_twin_sync_impl(ptr, rust_vec_len, data_len), +841 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_increment_twin_sync_impl(ptr, rust_vec_len, data_len), +839 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_return_twin_sync_impl(ptr, rust_vec_len, data_len), +840 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +843 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_vec_of_opts_twin_sync_impl(ptr, rust_vec_len, data_len), +851 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +850 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_str_twin_sync_impl(ptr, rust_vec_len, data_len), +849 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_string_twin_sync_impl(ptr, rust_vec_len, data_len), +852 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +854 => wire__crate__api__pseudo_manual__primitive_list_misc_twin_sync__handle_vec_of_primitive_twin_sync_impl(ptr, rust_vec_len, data_len), +857 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_types_twin_sync_impl(ptr, rust_vec_len, data_len), +858 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +862 => wire__crate__api__pseudo_manual__raw_string_twin_sync__test_more_than_just_one_raw_string_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +861 => wire__crate__api__pseudo_manual__raw_string_twin_sync__test_raw_string_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +953 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +954 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +952 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +956 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_getter_twin_sync_impl(ptr, rust_vec_len, data_len), +955 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +950 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_custom_name_twin_sync_impl(ptr, rust_vec_len, data_len), +949 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +951 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_with_result_twin_sync_impl(ptr, rust_vec_len, data_len), +946 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +947 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +945 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +948 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +911 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +912 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +914 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_own_and_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +910 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +935 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_vec_own_twin_sync_impl(ptr, rust_vec_len, data_len), +944 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_borrow_and_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +943 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_borrow_and_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +919 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +920 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_return_twin_sync_impl(ptr, rust_vec_len, data_len), +931 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_dummy_twin_sync_impl(ptr, rust_vec_len, data_len), +932 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +933 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +928 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +929 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_return_own_good_twin_sync_impl(ptr, rust_vec_len, data_len), +930 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_enum_with_good_and_opaque_return_own_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +937 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +939 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_return_twin_sync_impl(ptr, rust_vec_len, data_len), +938 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +916 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_normal_and_opaque_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +917 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_plus_sign_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +918 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_plus_sign_return_twin_sync_impl(ptr, rust_vec_len, data_len), +941 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_opaque_one_and_two_twin_sync_impl(ptr, rust_vec_len, data_len), +942 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_opaque_two_twin_sync_impl(ptr, rust_vec_len, data_len), +913 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +936 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_vec_own_twin_sync_impl(ptr, rust_vec_len, data_len), +940 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_sleep_twin_sync_impl(ptr, rust_vec_len, data_len), +934 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), +926 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_struct_with_good_and_opaque_field_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +927 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_struct_with_good_and_opaque_field_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +922 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +923 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_mut_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +921 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +924 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_return_own_one_twin_sync_impl(ptr, rust_vec_len, data_len), +925 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_trait_object_return_own_two_twin_sync_impl(ptr, rust_vec_len, data_len), +915 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_two_args_twin_sync_impl(ptr, rust_vec_len, data_len), +974 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_array_opaque_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +983 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +972 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +973 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_option_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +986 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__frb_generator_test_twin_sync_impl(ptr, rust_vec_len, data_len), +980 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_run_twin_sync_impl(ptr, rust_vec_len, data_len), +978 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_twin_sync_impl(ptr, rust_vec_len, data_len), +982 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_run_twin_sync_impl(ptr, rust_vec_len, data_len), +981 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_twin_sync_impl(ptr, rust_vec_len, data_len), +975 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_enum_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +984 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +979 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_non_clone_twin_sync_impl(ptr, rust_vec_len, data_len), +976 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +977 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_with_delay_twin_sync_impl(ptr, rust_vec_len, data_len), +985 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__unwrap_rust_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +988 => wire__crate__api__pseudo_manual__simple_twin_sync__simple_adder_twin_sync_impl(ptr, rust_vec_len, data_len), +1005 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1006 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1004 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_zero_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1007 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1008 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1012 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_2_twin_sync_impl(ptr, rust_vec_len, data_len), +1011 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), +1016 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), +1018 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_model_twin_sync_impl(ptr, rust_vec_len, data_len), +1017 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_nest_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), +1024 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_nested_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), +1022 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuid_twin_sync_impl(ptr, rust_vec_len, data_len), +1023 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), +1092 => wire__crate__api__rust_opaque_sync__frb_sync_generator_test_twin_normal_impl(ptr, rust_vec_len, data_len), +1091 => wire__crate__api__rust_opaque_sync__sync_create_non_clone_twin_normal_impl(ptr, rust_vec_len, data_len), +1090 => wire__crate__api__rust_opaque_sync__sync_create_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +1089 => wire__crate__api__rust_opaque_sync__sync_option_rust_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), _ => unreachable!(), } } @@ -42154,6 +42303,29 @@ impl } } // Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.0.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal, + > for crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal +{ + fn into_into_dart( + self, + ) -> crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs impl flutter_rust_bridge::IntoDart for crate::api::misc_example::StructWithEnumTwinNormal { fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { [ @@ -43778,6 +43950,13 @@ impl SseEncode for backtrace::Backtrace { } } +impl SseEncode for char { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.to_string(), serializer); + } +} + impl SseEncode for chrono::Duration { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -50972,6 +51151,13 @@ impl SseEncode for crate::api::pseudo_manual::comment_twin_sync::StructWithComme } } +impl SseEncode for crate::api::misc_no_twin_example_a::StructWithCustomNameMethodTwinNormal { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.0, serializer); + } +} + impl SseEncode for crate::api::misc_example::StructWithEnumTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {