diff --git a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/field.rs b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/field.rs index 26ca8d865c..3220e5e017 100644 --- a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/field.rs +++ b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/field.rs @@ -2,7 +2,7 @@ use crate::codegen::ir::mir::default::MirDefaultValue; use crate::codegen::ir::mir::field::MirField; use crate::codegen::ir::mir::ty::delegate::MirTypeDelegate; use crate::codegen::ir::mir::ty::MirType; -use crate::utils::dart_keywords::make_string_keyword_safe; +use crate::utils::dart_keywords; use convert_case::{Case, Casing}; use std::borrow::Cow; @@ -61,7 +61,7 @@ fn default_value_to_dart_style(value: &str) -> String { format!( "{}.{}", enum_name, - make_string_keyword_safe(variant_name.to_string()).to_case(Case::Camel) + dart_keywords::escape(variant_name.to_case(Case::Camel)) ) } _ => value.to_string(), diff --git a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/ty/enumeration_complex.rs b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/ty/enumeration_complex.rs index fe968b5377..85cc0f96f4 100644 --- a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/ty/enumeration_complex.rs +++ b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/ty/enumeration_complex.rs @@ -130,7 +130,7 @@ impl<'a> EnumRefApiDartGenerator<'a> { fn generate_implements_exception(&self, variant: &MirEnumVariant) -> &str { let has_backtrace = matches!(&variant.kind, - MirVariantKind::Struct(MirStruct {is_fields_named: true, fields, ..}) if fields.iter().any(|field| field.name.raw == BACKTRACE_IDENT)); + MirVariantKind::Struct(MirStruct {is_fields_named: true, fields, ..}) if fields.iter().any(|field| field.name.rust_style() == BACKTRACE_IDENT)); if self.mir.is_exception && has_backtrace { "@Implements()" } else { diff --git a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/ty/enumeration_simple.rs b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/ty/enumeration_simple.rs index 4c97475b06..93f5fa8389 100644 --- a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/ty/enumeration_simple.rs +++ b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/ty/enumeration_simple.rs @@ -3,7 +3,7 @@ use crate::codegen::generator::api_dart::spec_generator::misc::generate_dart_com use crate::codegen::ir::mir::ty::enumeration::{MirEnum, MirEnumVariant}; use crate::library::codegen::generator::api_dart::spec_generator::base::*; use crate::utils::basic_code::dart_header_code::DartHeaderCode; -use crate::utils::dart_keywords::make_string_keyword_safe; +use crate::utils::dart_keywords; use itertools::Itertools; impl<'a> EnumRefApiDartGenerator<'a> { @@ -41,7 +41,7 @@ impl<'a> EnumRefApiDartGenerator<'a> { fn generate_mode_simple_variant(&self, variant: &MirEnumVariant) -> String { let variant_name = if self.context.config.dart_enums_style { - make_string_keyword_safe(variant.name.dart_style()) + dart_keywords::escape(variant.name.dart_style()) } else { variant.name.rust_style().to_string() }; 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 1d6d5fce88..7cc68e9973 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 @@ -86,6 +86,15 @@ impl<'a> ApiDartGeneratorInfoTrait for DelegateApiDartGenerator<'a> { ApiDartGenerator::new(*mir.inner_ok.clone(), self.context).dart_api_type(), ), MirTypeDelegate::BigPrimitive(_) => "BigInt".to_owned(), + MirTypeDelegate::CastedPrimitive(mir) => match mir.inner { + MirTypePrimitive::U64 + | MirTypePrimitive::I64 + | MirTypePrimitive::Usize + | MirTypePrimitive::Isize => "int".to_owned(), + // frb-coverage:ignore-start + _ => unreachable!(), + // frb-coverage:ignore-end + }, MirTypeDelegate::RustAutoOpaqueExplicit(mir) => { ApiDartGenerator::new(mir.inner.clone(), self.context).dart_api_type() } @@ -96,6 +105,7 @@ impl<'a> ApiDartGeneratorInfoTrait for DelegateApiDartGenerator<'a> { ApiDartGenerator::new(mir.original.clone(), self.context).dart_api_type() } MirTypeDelegate::DynTrait(mir) => mir.trait_def_name.name.clone(), + MirTypeDelegate::CustomSerDes(mir) => mir.info.dart_api_type.clone(), } } diff --git a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/mod.rs b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/mod.rs index 6c59a12bff..35524d2379 100644 --- a/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/mod.rs +++ b/frb_codegen/src/library/codegen/generator/api_dart/spec_generator/mod.rs @@ -155,7 +155,7 @@ fn compute_skips(mir_pack: &MirPack, namespace: &Namespace) -> Vec { .filter(|t| &t.namespace == namespace) .map(|name| MirSkip { name: name.clone(), - reason: MirSkipReason::IgnoredTypeNotUsedByPub, + reason: MirSkipReason::IgnoreBecauseTypeNotUsedByPub, }) .collect_vec(); diff --git a/frb_codegen/src/library/codegen/generator/api_dart/text_generator.rs b/frb_codegen/src/library/codegen/generator/api_dart/text_generator.rs index 0a7a3dc15d..fc01b87eb1 100644 --- a/frb_codegen/src/library/codegen/generator/api_dart/text_generator.rs +++ b/frb_codegen/src/library/codegen/generator/api_dart/text_generator.rs @@ -129,14 +129,15 @@ fn compute_skips(item: &ApiDartOutputSpecItem) -> String { .into_group_map_by(|t| t.reason) .into_iter() .sorted_by_key(|(reason, _)| *reason) - .map(|(reason, names)| { - format!( - "// {}: {}\n", - reason.explanation_prefix(), - (names.iter().map(|x| format!("`{}`", x.name.name))) - .sorted() - .join(", "), - ) + .filter_map(|(reason, names)| { + reason.explanation_prefix().map(|explanation_prefix| { + format!( + "// {explanation_prefix}: {}\n", + (names.iter().map(|x| format!("`{}`", x.name.name))) + .sorted() + .join(", "), + ) + }) }) .join("") } 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 e6ae29f304..8e23ccb050 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 @@ -44,6 +44,16 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> { generate_stream_sink_setup_and_serialize(mir, "self") } MirTypeDelegate::BigPrimitive(_) => "self.toString()".to_owned(), + MirTypeDelegate::CastedPrimitive(mir) => { + let postfix = match mir.inner { + MirTypePrimitive::Isize | MirTypePrimitive::I64 => "I64", + MirTypePrimitive::Usize | MirTypePrimitive::U64 => "U64", + // frb-coverage:ignore-start + _ => unreachable!(), + // frb-coverage:ignore-end + }; + format!("sseEncodeCastedPrimitive{postfix}(self)") + } MirTypeDelegate::RustAutoOpaqueExplicit(_ir) => "self".to_owned(), MirTypeDelegate::ProxyEnum(mir) => { generate_proxy_enum_dart_encode(mir, self.context.as_api_dart_context()) @@ -51,6 +61,9 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> { MirTypeDelegate::DynTrait(mir) => { generate_dyn_trait_dart_encode(mir, self.context.as_api_dart_context()) } + MirTypeDelegate::CustomSerDes(mir) => { + mir.info.dart2rust.dart_code.replace("{}", "self") + } }, Lang::RustLang(_) => match &self.mir { MirTypeDelegate::Array(_) => { @@ -97,7 +110,11 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> { } MirTypeDelegate::ProxyVariant(_) | MirTypeDelegate::ProxyEnum(_) - | MirTypeDelegate::DynTrait(_) => return None, + | MirTypeDelegate::DynTrait(_) + | MirTypeDelegate::CastedPrimitive(_) => return None, + MirTypeDelegate::CustomSerDes(mir) => { + format!("{}(self)", mir.info.rust2dart.rust_function.rust_style()) + } }, }; Some(simple_delegate_encode( @@ -155,10 +172,14 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> { return Some(format!("{};", lang.throw_unreachable(""))); } MirTypeDelegate::BigPrimitive(_) => "BigInt.parse(inner)".to_owned(), + MirTypeDelegate::CastedPrimitive(_) => "inner.toInt()".to_owned(), MirTypeDelegate::RustAutoOpaqueExplicit(_ir) => "inner".to_owned(), MirTypeDelegate::DynTrait(_) => { return Some(format!("{};", lang.throw_unimplemented(""))) } + MirTypeDelegate::CustomSerDes(mir) => { + mir.info.rust2dart.dart_code.replace("{}", "inner") + } } } Lang::RustLang(_) => match &self.mir { @@ -203,7 +224,11 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> { } MirTypeDelegate::ProxyVariant(_) | MirTypeDelegate::ProxyEnum(_) - | MirTypeDelegate::DynTrait(_) => return None, + | MirTypeDelegate::DynTrait(_) + | MirTypeDelegate::CastedPrimitive(_) => return None, + MirTypeDelegate::CustomSerDes(mir) => { + format!("{}(inner)", mir.info.dart2rust.rust_function.rust_style()) + } }, }; diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/codec/cst/encoder/ty/delegate.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/codec/cst/encoder/ty/delegate.rs index 51efd5e6b2..68af8f9920 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/codec/cst/encoder/ty/delegate.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/codec/cst/encoder/ty/delegate.rs @@ -139,7 +139,7 @@ impl<'a> WireDartCodecCstGeneratorEncoderTrait for DelegateWireDartCodecCstGener "return cst_encode_{}(raw);", self.mir.get_delegate().safe_ident(), ))), - MirTypeDelegate::ProxyVariant(_) | MirTypeDelegate::ProxyEnum(_) => + MirTypeDelegate::ProxyVariant(_) | MirTypeDelegate::ProxyEnum(_) | MirTypeDelegate::CastedPrimitive(_) | MirTypeDelegate::CustomSerDes(_) => Acc::distribute(Some("throw UnimplementedError('Not implemented in this codec, please use the other one');".to_string())) } } diff --git a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/codec/dco/decoder/ty/delegate.rs b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/codec/dco/decoder/ty/delegate.rs index 698c12f899..cdc1e414c8 100644 --- a/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/codec/dco/decoder/ty/delegate.rs +++ b/frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/codec/dco/decoder/ty/delegate.rs @@ -86,7 +86,7 @@ impl<'a> WireDartCodecDcoGeneratorDecoderTrait for DelegateWireDartCodecDcoGener "return BigInt.parse(raw);".to_owned() } MirTypeDelegate::RustAutoOpaqueExplicit(mir) => format!(r"return dco_decode_{}(raw);", mir.inner.safe_ident()), - MirTypeDelegate::ProxyVariant(_) | MirTypeDelegate::ProxyEnum(_) => + MirTypeDelegate::ProxyVariant(_) | MirTypeDelegate::ProxyEnum(_) | MirTypeDelegate::CastedPrimitive(_) | MirTypeDelegate::CustomSerDes(_) => "throw UnimplementedError('Not implemented in this codec, please use the other one');".into(), } } diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/codec/cst/decoder/ty/delegate.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/codec/cst/decoder/ty/delegate.rs index 492becd1bc..57e10b6b06 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/codec/cst/decoder/ty/delegate.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/codec/cst/decoder/ty/delegate.rs @@ -103,8 +103,12 @@ impl<'a> WireRustCodecCstGeneratorDecoderTrait for DelegateWireRustCodecCstGener io: Some("flutter_rust_bridge::for_generated::rust_auto_opaque_explicit_decode(self.cst_decode())".into()), ..Default::default() }, + // Do not care about these unimplemented things + // frb-coverage:ignore-start MirTypeDelegate::ProxyVariant(_) | MirTypeDelegate::ProxyEnum(_) => - Acc::distribute(Some(r#"unimplemented!("Not implemented in this codec, please use the other one")"#.to_string())) + Acc::distribute(Some(r#"unimplemented!("Not implemented in this codec, please use the other one")"#.to_string())), + MirTypeDelegate::CastedPrimitive(_) | MirTypeDelegate::CustomSerDes(_) => Acc::distribute(None), + // frb-coverage:ignore-end } } @@ -143,8 +147,12 @@ impl<'a> WireRustCodecCstGeneratorDecoderTrait for DelegateWireRustCodecCstGener MirTypeDelegate::BigPrimitive(_) => "CstDecode::::cst_decode(self).parse().unwrap()".into(), MirTypeDelegate::RustAutoOpaqueExplicit(_) => "flutter_rust_bridge::for_generated::rust_auto_opaque_explicit_decode(self.cst_decode())".into(), + // Do not care about these unimplemented things + // frb-coverage:ignore-start MirTypeDelegate::ProxyVariant(_) | MirTypeDelegate::ProxyEnum(_) => r#"unimplemented!("Not implemented in this codec, please use the other one")"#.into(), + MirTypeDelegate::CastedPrimitive(_) | MirTypeDelegate::CustomSerDes(_) => return None, + // frb-coverage:ignore-end }) } diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/function/lockable.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/function/lockable.rs index f4cbde389f..d9c2ce8221 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/function/lockable.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/function/lockable.rs @@ -78,7 +78,7 @@ fn generate_decode_statement( ) } -fn get_variable_name(field: &MirFuncInput) -> &str { +fn get_variable_name(field: &MirFuncInput) -> String { field.inner.name.rust_style() } diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/delegate.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/delegate.rs index 28fd7c7143..9e006f7d68 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/delegate.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/delegate.rs @@ -2,8 +2,22 @@ use crate::codegen::generator::wire::rust::spec_generator::base::*; use crate::codegen::generator::wire::rust::spec_generator::misc::ty::WireRustGeneratorMiscTrait; use crate::codegen::ir::mir::ty::delegate::MirTypeDelegate; use crate::library::codegen::ir::mir::ty::MirTypeTrait; +use itertools::Itertools; impl<'a> WireRustGeneratorMiscTrait for DelegateWireRustGenerator<'a> { + fn generate_imports(&self) -> Option> { + if let MirTypeDelegate::CustomSerDes(mir) = &self.mir { + Some( + [&mir.info.rust2dart, &mir.info.dart2rust] + .into_iter() + .map(|x| format!("use {}::*;", x.rust_function.namespace.joined_path)) + .collect_vec(), + ) + } else { + None + } + } + // the function signature is not covered while the whole body is covered - looks like a bug in coverage tool // frb-coverage:ignore-start fn wrapper_struct_name(&self) -> Option { diff --git a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/structure.rs b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/structure.rs index 394e8463fa..e28afe1a27 100644 --- a/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/structure.rs +++ b/frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/structure.rs @@ -26,7 +26,7 @@ impl<'a> WireRustGeneratorMiscTrait for StructRefWireRustGenerator<'a> { .enumerate() .map(|(i, field)| { let field_access = if src.is_fields_named { - field.name.raw.clone() + field.name.rust_style().to_owned() } else { i.to_string() }; diff --git a/frb_codegen/src/library/codegen/ir/mir/custom_ser_des.rs b/frb_codegen/src/library/codegen/ir/mir/custom_ser_des.rs new file mode 100644 index 0000000000..0e0aa5fd86 --- /dev/null +++ b/frb_codegen/src/library/codegen/ir/mir/custom_ser_des.rs @@ -0,0 +1,17 @@ +use crate::codegen::ir::mir::ty::MirType; +use crate::utils::namespace::NamespacedName; + +crate::mir! { +pub struct MirCustomSerDes { + pub inner_type: Box, + pub rust_api_type: Box, + pub dart_api_type: String, + pub dart2rust: MirCustomSerDesHalf, + pub rust2dart: MirCustomSerDesHalf, +} + +pub struct MirCustomSerDesHalf { + pub dart_code: String, + pub rust_function: NamespacedName, +} +} diff --git a/frb_codegen/src/library/codegen/ir/mir/ident.rs b/frb_codegen/src/library/codegen/ir/mir/ident.rs index 01753e8c75..e65408f814 100644 --- a/frb_codegen/src/library/codegen/ir/mir/ident.rs +++ b/frb_codegen/src/library/codegen/ir/mir/ident.rs @@ -1,28 +1,32 @@ use crate::codegen::generator::codec::sse::lang::Lang; -use crate::utils::cbindgen_keywords; +use crate::utils::{cbindgen_keywords, dart_keywords}; use convert_case::{Case, Casing}; + crate::mir! { -#[serde(transparent)] pub struct MirIdent { - pub raw: String, + rust_style: String, + dart_style: Option, } } impl MirIdent { - pub fn new(raw: String) -> MirIdent { - MirIdent { raw } + pub fn new(rust_style: String, dart_style: Option) -> MirIdent { + MirIdent { + rust_style, + dart_style, + } } - pub fn rust_style(&self) -> &str { - &self.raw + pub fn rust_style(&self) -> String { + self.rust_style.clone() } pub fn c_style(&self) -> String { - convert_rust_to_c_style(&self.raw) + convert_rust_to_c_style(&self.rust_style) } pub fn dart_style(&self) -> String { - (self.raw.strip_prefix("r#").unwrap_or(self.raw.as_str())).to_case(Case::Camel) + (self.dart_style.clone()).unwrap_or_else(|| convert_rust_to_dart_style(&self.rust_style)) } pub fn style(&self, lang: &Lang) -> String { @@ -35,24 +39,37 @@ impl MirIdent { impl std::fmt::Display for MirIdent { fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> { - fmt.write_str(&self.raw) + fmt.write_str(&self.rust_style)?; + if let Some(dart_style) = &self.dart_style { + write!(fmt, "(dart_style={})", dart_style)?; + } + Ok(()) } } fn convert_rust_to_c_style(raw: &str) -> String { - let mut ans = raw.to_owned(); - - if let Some(stripped) = ans.strip_prefix("r#") { - ans = stripped.to_owned(); - } + let mut ans = strip_prefix_rhash(raw).to_owned(); // match behavior of ffigen if &ans == "async" { ans = "async1".to_owned(); } + if &ans == "interface" { + ans = "interface1".to_owned(); + } // match behavior of cbindgen cbindgen_keywords::escape(&mut ans); ans } + +fn convert_rust_to_dart_style(raw: &str) -> String { + let ans = strip_prefix_rhash(raw).to_case(Case::Camel); + + dart_keywords::escape(ans) +} + +fn strip_prefix_rhash(raw: &str) -> &str { + raw.strip_prefix("r#").unwrap_or(raw) +} diff --git a/frb_codegen/src/library/codegen/ir/mir/mod.rs b/frb_codegen/src/library/codegen/ir/mir/mod.rs index cdbc75cc65..949105858e 100644 --- a/frb_codegen/src/library/codegen/ir/mir/mod.rs +++ b/frb_codegen/src/library/codegen/ir/mir/mod.rs @@ -1,5 +1,6 @@ pub(crate) mod annotation; pub(crate) mod comment; +pub(crate) mod custom_ser_des; pub(crate) mod default; pub(crate) mod field; pub(crate) mod func; diff --git a/frb_codegen/src/library/codegen/ir/mir/skip.rs b/frb_codegen/src/library/codegen/ir/mir/skip.rs index 1a0db7c3e1..2f12b60705 100644 --- a/frb_codegen/src/library/codegen/ir/mir/skip.rs +++ b/frb_codegen/src/library/codegen/ir/mir/skip.rs @@ -8,30 +8,37 @@ pub struct MirSkip { #[derive(Copy, PartialOrd, Ord)] pub(crate) enum MirSkipReason { - IgnoredFunctionNotPub, - IgnoredFunctionGeneric, - IgnoredTypeNotUsedByPub, - IgnoredMisc, + IgnoreBecauseFunctionNotPub, + IgnoreBecauseFunctionGeneric, + IgnoreBecauseTypeNotUsedByPub, + IgnoreBecauseExplicitAttribute, + IgnoreBecauseType, + IgnoreBecauseParseMethodOwnerTy, + IgnoreBecauseParseOwnerCannotFindTrait, + IgnoreBecauseNotAllowedOwner, + IgnoreBecauseOwnerTyShouldIgnore, + IgnoreSilently, Err, } } impl MirSkipReason { - pub(crate) fn explanation_prefix(&self) -> &'static str { - match self { - Self::IgnoredFunctionNotPub => { - "These functions are ignored because they are not marked as `pub`" + pub(crate) fn explanation_prefix(&self) -> Option { + Some(match self { + Self::IgnoreBecauseFunctionNotPub => { + "These functions are ignored because they are not marked as `pub`".to_owned() } - Self::IgnoredFunctionGeneric => { - "These functions are ignored because they have generic arguments" + Self::IgnoreBecauseFunctionGeneric => { + "These functions are ignored because they have generic arguments".to_owned() } - Self::IgnoredTypeNotUsedByPub => { - "These types are ignored because they are not used by any `pub` functions" + Self::IgnoreBecauseTypeNotUsedByPub => { + "These types are ignored because they are not used by any `pub` functions".to_owned() } - Self::IgnoredMisc => "These functions are ignored", + Self::IgnoreSilently => return None, Self::Err => { - "These functions have error during generation (see debug logs or enable `stop_on_error: true` for more details)" + "These functions have error during generation (see debug logs or enable `stop_on_error: true` for more details)".to_owned() } - } + _ => format!("These functions are ignored (category: {:?})", self) + }) } } diff --git a/frb_codegen/src/library/codegen/ir/mir/ty/delegate.rs b/frb_codegen/src/library/codegen/ir/mir/ty/delegate.rs index 6a7dc75e4e..998efd20fc 100644 --- a/frb_codegen/src/library/codegen/ir/mir/ty/delegate.rs +++ b/frb_codegen/src/library/codegen/ir/mir/ty/delegate.rs @@ -1,4 +1,5 @@ use crate::codegen::generator::codec::structs::CodecMode; +use crate::codegen::ir::mir::custom_ser_des::MirCustomSerDes; use crate::codegen::ir::mir::ty::enumeration::{MirEnumIdent, MirTypeEnumRef}; use crate::codegen::ir::mir::ty::general_list::{mir_list, MirTypeGeneralList}; use crate::codegen::ir::mir::ty::primitive::MirTypePrimitive; @@ -28,10 +29,12 @@ pub enum MirTypeDelegate { Set(MirTypeDelegateSet), StreamSink(MirTypeDelegateStreamSink), BigPrimitive(MirTypeDelegateBigPrimitive), + CastedPrimitive(MirTypeDelegateCastedPrimitive), RustAutoOpaqueExplicit(MirTypeDelegateRustAutoOpaqueExplicit), ProxyVariant(MirTypeDelegateProxyVariant), ProxyEnum(MirTypeDelegateProxyEnum), DynTrait(MirTypeDelegateDynTrait), + CustomSerDes(MirTypeDelegateCustomSerDes), } pub struct MirTypeDelegateArray { @@ -81,6 +84,10 @@ pub enum MirTypeDelegateBigPrimitive { U128, } +pub struct MirTypeDelegateCastedPrimitive { + pub inner: MirTypePrimitive, +} + pub struct MirTypeDelegateRustAutoOpaqueExplicit { pub inner: MirTypeRustOpaque, pub raw: MirRustAutoOpaqueRaw, @@ -112,6 +119,10 @@ pub struct MirTypeDelegateDynTraitData { pub struct MirTypeDelegateDynTraitVariant { pub ty: MirType, } + +pub struct MirTypeDelegateCustomSerDes { + pub info: MirCustomSerDes, +} } impl MirTypeTrait for MirTypeDelegate { @@ -157,6 +168,9 @@ impl MirTypeTrait for MirTypeDelegate { format!("StreamSink_{}_{}", mir.inner_ok.safe_ident(), mir.codec) } MirTypeDelegate::BigPrimitive(mir) => mir.to_string(), + MirTypeDelegate::CastedPrimitive(mir) => { + format!("CastedPrimitive_{}", mir.inner.safe_ident()) + } MirTypeDelegate::RustAutoOpaqueExplicit(mir) => { format!("AutoExplicit_{}", mir.inner.safe_ident()) } @@ -171,6 +185,9 @@ impl MirTypeTrait for MirTypeDelegate { MirTypeDelegate::ProxyEnum(mir) => { format!("ProxyEnum_{}", mir.get_delegate().safe_ident()) } + MirTypeDelegate::CustomSerDes(mir) => { + format!("CustomSerializer_{}", mir.info.rust_api_type.safe_ident()) + } } } @@ -230,12 +247,14 @@ impl MirTypeTrait for MirTypeDelegate { MirTypeDelegateBigPrimitive::I128 => "i128".to_owned(), MirTypeDelegateBigPrimitive::U128 => "u128".to_owned(), }, + MirTypeDelegate::CastedPrimitive(mir) => mir.inner.rust_api_type(), MirTypeDelegate::RustAutoOpaqueExplicit(mir) => { format!("RustAutoOpaque{}<{}>", mir.inner.codec, mir.raw.string) } MirTypeDelegate::DynTrait(mir) => format!("dyn {}", mir.trait_def_name.name), MirTypeDelegate::ProxyVariant(mir) => mir.inner.rust_api_type(), MirTypeDelegate::ProxyEnum(mir) => mir.original.rust_api_type(), + MirTypeDelegate::CustomSerDes(mir) => mir.info.rust_api_type.rust_api_type(), } } @@ -263,6 +282,7 @@ impl MirTypeTrait for MirTypeDelegate { | MirTypeDelegate::Char | MirTypeDelegate::PrimitiveEnum(_) | MirTypeDelegate::BigPrimitive(_) + | MirTypeDelegate::CastedPrimitive(_) | MirTypeDelegate::RustAutoOpaqueExplicit(_) ) } @@ -303,10 +323,12 @@ impl MirTypeDelegate { MirTypeDelegate::Set(mir) => mir_list(*mir.inner.to_owned(), true), MirTypeDelegate::StreamSink(_) => MirType::Delegate(MirTypeDelegate::String), MirTypeDelegate::BigPrimitive(_) => MirType::Delegate(MirTypeDelegate::String), + MirTypeDelegate::CastedPrimitive(mir) => MirType::Primitive(mir.inner.clone()), MirTypeDelegate::RustAutoOpaqueExplicit(mir) => MirType::RustOpaque(mir.inner.clone()), MirTypeDelegate::DynTrait(mir) => mir.get_delegate(), MirTypeDelegate::ProxyVariant(mir) => *mir.inner.clone(), MirTypeDelegate::ProxyEnum(mir) => mir.get_delegate(), + MirTypeDelegate::CustomSerDes(mir) => *mir.info.inner_type.clone(), } } } diff --git a/frb_codegen/src/library/codegen/parser/hir/flat/parser/syn_item/item_impl.rs b/frb_codegen/src/library/codegen/parser/hir/flat/parser/syn_item/item_impl.rs index bc61c9672e..b7f7e24f74 100644 --- a/frb_codegen/src/library/codegen/parser/hir/flat/parser/syn_item/item_impl.rs +++ b/frb_codegen/src/library/codegen/parser/hir/flat/parser/syn_item/item_impl.rs @@ -5,7 +5,7 @@ use crate::codegen::ir::hir::misc::item_fn::GeneralizedItemFn; use crate::codegen::ir::hir::naive_flat::item::HirNaiveFlatItemMeta; use crate::if_then_some; use itertools::Itertools; -use syn::{ImplItem, ItemImpl}; +use syn::{Attribute, ImplItem, ImplItemFn, ItemImpl}; pub(crate) fn parse_syn_item_impl( target: &mut HirFlatPack, @@ -29,6 +29,8 @@ fn parse_functions( meta: &HirNaiveFlatItemMeta, trait_def_name: &Option, ) -> Vec { + let attrs_item_impl = item_impl.attrs; + (item_impl.items.into_iter()) .filter_map(|item| if_then_some!(let ImplItem::Fn(impl_item_fn) = item, impl_item_fn)) .map(|impl_item_fn| HirFlatFunction { @@ -37,12 +39,17 @@ fn parse_functions( impl_ty: *item_impl.self_ty.clone(), trait_def_name: trait_def_name.clone(), }, - item_fn: GeneralizedItemFn::ImplItemFn(impl_item_fn), + item_fn: GeneralizedItemFn::ImplItemFn(add_attrs(impl_item_fn, &attrs_item_impl)), sources: meta.sources.clone(), }) .collect_vec() } +fn add_attrs(mut item: ImplItemFn, attrs: &[Attribute]) -> ImplItemFn { + item.attrs.extend(attrs.to_owned()); + item +} + fn parse_trait_impl(item_impl: &ItemImpl, trait_name: &str) -> HirFlatTraitImpl { HirFlatTraitImpl { trait_name: trait_name.to_owned(), diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/attribute.rs b/frb_codegen/src/library/codegen/parser/mir/parser/attribute.rs index 3d5d18a2bb..149fb12540 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/attribute.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/attribute.rs @@ -115,6 +115,10 @@ impl FrbAttributes { self.any_eq(&FrbAttribute::External) } + pub(crate) fn type_64bit_int(&self) -> bool { + self.any_eq(&FrbAttribute::Type64bitInt) + } + // pub(crate) fn generate_implementor_enum(&self) -> bool { // self.any_eq(&FrbAttribute::GenerateImplEnum) // } @@ -182,6 +186,22 @@ impl FrbAttributes { .filter_map(|item| if_then_some!(let FrbAttribute::Name(inner) = item, inner.0.clone())) .next() } + + pub(crate) fn dart2rust(&self) -> Option { + (self.0.iter()) + .filter_map( + |item| if_then_some!(let FrbAttribute::Dart2Rust(inner) = item, inner.clone()), + ) + .next() + } + + pub(crate) fn rust2dart(&self) -> Option { + (self.0.iter()) + .filter_map( + |item| if_then_some!(let FrbAttribute::Rust2Dart(inner) = item, inner.clone()), + ) + .next() + } } mod frb_keyword { @@ -200,6 +220,7 @@ mod frb_keyword { syn::custom_keyword!(positional); syn::custom_keyword!(proxy); syn::custom_keyword!(external); + syn::custom_keyword!(type_64bit_int); syn::custom_keyword!(generate_implementor_enum); syn::custom_keyword!(rust_opaque_codec_moi); syn::custom_keyword!(serialize); @@ -209,6 +230,9 @@ mod frb_keyword { syn::custom_keyword!(default); syn::custom_keyword!(dart_code); syn::custom_keyword!(name); + syn::custom_keyword!(rust2dart); + syn::custom_keyword!(dart2rust); + syn::custom_keyword!(dart_type); } struct FrbAttributesInner(Vec); @@ -240,6 +264,7 @@ enum FrbAttribute { Positional, Proxy, External, + Type64bitInt, // GenerateImplEnum, RustOpaqueCodecMoi, Serialize, @@ -249,6 +274,8 @@ enum FrbAttribute { Default(FrbAttributeDefaultValue), DartCode(FrbAttributeDartCode), Name(FrbAttributeName), + Dart2Rust(FrbAttributeSerDes), + Rust2Dart(FrbAttributeSerDes), } impl Parse for FrbAttribute { @@ -279,6 +306,9 @@ impl Parse for FrbAttribute { .or_else(|| parse_keyword::(input, &lookahead, positional, Positional)) .or_else(|| parse_keyword::(input, &lookahead, proxy, Proxy)) .or_else(|| parse_keyword::(input, &lookahead, external, External)) + .or_else(|| { + parse_keyword::(input, &lookahead, type_64bit_int, Type64bitInt) + }) // .or_else(|| { // parse_keyword::( // input, @@ -305,21 +335,27 @@ impl Parse for FrbAttribute { Ok(if lookahead.peek(frb_keyword::mirror) { input.parse::()?; - input.parse().map(FrbAttribute::Mirror)? + input.parse().map(Mirror)? } else if lookahead.peek(frb_keyword::dart_metadata) { - input.parse().map(FrbAttribute::Metadata)? + input.parse().map(Metadata)? } else if lookahead.peek(default) { input.parse::()?; input.parse::()?; - input.parse().map(FrbAttribute::Default)? + input.parse().map(Default)? } else if lookahead.peek(dart_code) { input.parse::()?; input.parse::()?; - input.parse().map(FrbAttribute::DartCode)? + input.parse().map(DartCode)? } else if lookahead.peek(name) { input.parse::()?; input.parse::()?; - input.parse().map(FrbAttribute::Name)? + input.parse().map(Name)? + } else if lookahead.peek(frb_keyword::dart2rust) { + input.parse::()?; + input.parse().map(Dart2Rust)? + } else if lookahead.peek(frb_keyword::rust2dart) { + input.parse::()?; + input.parse().map(Rust2Dart)? } else { return Err(lookahead.error()); }) @@ -550,12 +586,40 @@ impl Parse for FrbAttributeName { } } +#[derive(Clone, Serialize, Eq, PartialEq, Debug)] +pub(crate) struct FrbAttributeSerDes { + pub dart_type: String, + pub dart_code: String, +} + +impl Parse for FrbAttributeSerDes { + fn parse(input: ParseStream) -> Result { + let content; + parenthesized!(content in input); + + content.parse::()?; + content.parse::()?; + let dart_type = content.parse::()?.value(); + + content.parse::()?; + + content.parse::()?; + content.parse::()?; + let dart_code = content.parse::()?.value(); + + Ok(Self { + dart_type, + dart_code, + }) + } +} + #[cfg(test)] mod tests { use crate::codegen::ir::mir::default::MirDefaultValue; use crate::codegen::parser::mir::parser::attribute::{ FrbAttribute, FrbAttributeDartCode, FrbAttributeDefaultValue, FrbAttributeMirror, - FrbAttributeName, FrbAttributes, NamedOption, + FrbAttributeName, FrbAttributeSerDes, FrbAttributes, NamedOption, }; use crate::if_then_some; use quote::quote; @@ -687,6 +751,11 @@ mod tests { simple_keyword_tester("external", FrbAttribute::External); } + #[test] + fn test_type_64bit_int() { + simple_keyword_tester("type_64bit_int", FrbAttribute::Type64bitInt); + } + // #[test] // fn test_generate_implementor_enum() { // simple_keyword_tester("generate_implementor_enum", FrbAttribute::GenerateImplEnum); @@ -721,6 +790,34 @@ mod tests { Ok(()) } + #[test] + fn test_rust2dart() -> anyhow::Result<()> { + let parsed = + parse(r###"#[frb(rust2dart(dart_type = "my_type", dart_code = "my_code"))]"###)?; + assert_eq!( + parsed, + FrbAttributes(vec![FrbAttribute::Rust2Dart(FrbAttributeSerDes { + dart_type: "my_type".to_owned(), + dart_code: "my_code".to_owned(), + })]) + ); + Ok(()) + } + + #[test] + fn test_dart2rust() -> anyhow::Result<()> { + let parsed = + parse(r###"#[frb(dart2rust(dart_type = "my_type", dart_code = "my_code"))]"###)?; + assert_eq!( + parsed, + FrbAttributes(vec![FrbAttribute::Dart2Rust(FrbAttributeSerDes { + dart_type: "my_type".to_owned(), + dart_code: "my_code".to_owned(), + })]) + ); + Ok(()) + } + #[test] fn test_metadata() -> anyhow::Result<()> { let parsed = parse( diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/custom_ser_des.rs b/frb_codegen/src/library/codegen/parser/mir/parser/custom_ser_des.rs new file mode 100644 index 0000000000..982a2855fc --- /dev/null +++ b/frb_codegen/src/library/codegen/parser/mir/parser/custom_ser_des.rs @@ -0,0 +1,143 @@ +use crate::codegen::generator::codec::structs::CodecMode; +use crate::codegen::ir::hir::flat::function::HirFlatFunction; +use crate::codegen::ir::mir::custom_ser_des::{MirCustomSerDes, MirCustomSerDesHalf}; +use crate::codegen::ir::mir::ty::rust_opaque::RustOpaqueCodecMode; +use crate::codegen::ir::mir::ty::MirType; +use crate::codegen::parser::mir::parser::attribute::{FrbAttributeSerDes, FrbAttributes}; +use crate::codegen::parser::mir::parser::ty::{TypeParser, TypeParserParsingContext}; +use crate::codegen::parser::mir::ParseMode; +use crate::if_then_some; +use crate::utils::namespace::NamespacedName; +use anyhow::ensure; +use itertools::Itertools; +use syn::{FnArg, ReturnType}; + +pub(crate) struct PartialContext { + pub default_stream_sink_codec: CodecMode, + pub default_rust_opaque_codec: RustOpaqueCodecMode, + pub parse_mode: ParseMode, +} + +pub(crate) fn parse( + src_fns: &[HirFlatFunction], + type_parser: &mut TypeParser, + partial_context: &PartialContext, +) -> anyhow::Result> { + let infos = (src_fns.iter()) + .map(|f| parse_function(f, type_parser, partial_context)) + .collect::>>()? + .into_iter() + .flatten(); + + let ans = infos + .into_group_map_by(|info| *info.rust_api_type.clone()) + .into_values() + .map(merge_pair) + .collect_vec(); + + Ok(ans) +} + +fn parse_function( + func: &HirFlatFunction, + type_parser: &mut TypeParser, + partial_context: &PartialContext, +) -> anyhow::Result> { + let attrs = FrbAttributes::parse(func.item_fn.attrs())?; + + if let Some(info) = attrs.dart2rust() { + return Ok(Some(parse_function_inner( + func, + info, + Direction::Dart2Rust, + type_parser, + partial_context, + )?)); + } + if let Some(info) = attrs.rust2dart() { + return Ok(Some(parse_function_inner( + func, + info, + Direction::Rust2Dart, + type_parser, + partial_context, + )?)); + } + + Ok(None) +} + +fn parse_function_inner( + func: &HirFlatFunction, + attr_ser_des: FrbAttributeSerDes, + direction: Direction, + type_parser: &mut TypeParser, + partial_context: &PartialContext, +) -> anyhow::Result { + let sig = func.item_fn.sig(); + + ensure!(sig.inputs.len() == 1); + let input_ty = if_then_some!(let FnArg::Typed(pat_type) = sig.inputs.first().unwrap().clone(), *pat_type.ty).unwrap(); + let output_ty = if_then_some!(let ReturnType::Type(_, ty) = sig.output.clone(), *ty).unwrap(); + + let context = TypeParserParsingContext { + initiated_namespace: func.namespace.clone(), + func_attributes: FrbAttributes::parse(&[])?, + struct_or_enum_attributes: None, + owner: None, + default_stream_sink_codec: partial_context.default_stream_sink_codec, + default_rust_opaque_codec: partial_context.default_rust_opaque_codec, + parse_mode: partial_context.parse_mode, + }; + + let input_ty = Box::new(type_parser.parse_type(&input_ty, &context)?); + let output_ty = Box::new(type_parser.parse_type(&output_ty, &context)?); + + let (rust_api_type, inner_type) = match direction { + Direction::Rust2Dart => (input_ty, output_ty), + Direction::Dart2Rust => (output_ty, input_ty), + }; + + Ok(Info { + inner_type, + rust_api_type, + dart_api_type: attr_ser_des.dart_type, + direction, + half: MirCustomSerDesHalf { + dart_code: attr_ser_des.dart_code, + rust_function: NamespacedName::new(func.namespace.clone(), func.item_fn.name()), + }, + }) +} + +fn merge_pair(pair: Vec) -> MirCustomSerDes { + let [a, b]: [Info; 2] = (pair.try_into()) + .unwrap_or_else(|_| panic!("Expect a pair of serializer and deserializer")); + let (dart2rust, rust2dart) = if a.direction == Direction::Dart2Rust { + (a, b) + } else { + (b, a) + }; + + MirCustomSerDes { + inner_type: dart2rust.inner_type.clone(), + rust_api_type: dart2rust.rust_api_type.clone(), + dart_api_type: dart2rust.dart_api_type.clone(), + dart2rust: dart2rust.half, + rust2dart: rust2dart.half, + } +} + +struct Info { + inner_type: Box, + rust_api_type: Box, + dart_api_type: String, + direction: Direction, + half: MirCustomSerDesHalf, +} + +#[derive(Clone, Copy, PartialEq, Eq, Hash)] +enum Direction { + Rust2Dart, + Dart2Rust, +} diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/function/auto_accessor/field.rs b/frb_codegen/src/library/codegen/parser/mir/parser/function/auto_accessor/field.rs index 16586a6a7f..116122e6d8 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/function/auto_accessor/field.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/function/auto_accessor/field.rs @@ -28,12 +28,12 @@ pub(super) fn parse_auto_accessor_of_field( type_parser: &mut TypeParser, context: &TypeParserParsingContext, ) -> anyhow::Result { - let rust_method_name = format!("{}_{}", accessor_mode.verb_str(), field.name.raw); + let rust_method_name = format!("{}_{}", accessor_mode.verb_str(), field.name.rust_style()); let owner = MirFuncOwnerInfoMethod { owner_ty: ty_direct_parse.to_owned(), actual_method_name: rust_method_name, - actual_method_dart_name: Some(field.name.raw.clone()), + actual_method_dart_name: Some(field.name.rust_style().to_owned()), mode: MirFuncOwnerInfoMethodMode::Instance, trait_def: None, }; @@ -47,7 +47,7 @@ pub(super) fn parse_auto_accessor_of_field( if accessor_mode == MirFuncAccessorMode::Setter { inputs.push(MirFuncInput { ownership_mode: None, - inner: create_mir_field(field.ty.clone(), &field.name.raw), + inner: create_mir_field(field.ty.clone(), &field.name.rust_style()), }); } @@ -124,7 +124,7 @@ fn compute_self_arg( fn compute_src_lineno_pseudo(struct_name: &NamespacedName, field: &MirField) -> usize { let mut hasher = Sha1::new(); hasher.update(struct_name.rust_style().as_bytes()); - hasher.update(field.name.raw.as_bytes()); + hasher.update(field.name.rust_style().as_bytes()); let digest = hasher.finalize(); usize::from_le_bytes(digest[..8].try_into().unwrap()) } @@ -132,7 +132,7 @@ fn compute_src_lineno_pseudo(struct_name: &NamespacedName, field: &MirField) -> fn create_mir_field(ty: MirType, name: &str) -> MirField { MirField { ty, - name: MirIdent::new(name.to_owned()), + name: MirIdent::new(name.to_owned(), None), is_final: true, is_rust_public: None, comments: vec![], diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/function/auto_accessor/mod.rs b/frb_codegen/src/library/codegen/parser/mir/parser/function/auto_accessor/mod.rs index 9783ba9fa6..39a793ec2e 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/function/auto_accessor/mod.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/function/auto_accessor/mod.rs @@ -117,6 +117,7 @@ fn create_parsing_context( Ok(TypeParserParsingContext { initiated_namespace: struct_name.namespace.to_owned(), func_attributes: FrbAttributes::parse(&[])?, + struct_or_enum_attributes: None, default_stream_sink_codec, default_rust_opaque_codec, owner: None, diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/function/real/argument.rs b/frb_codegen/src/library/codegen/parser/mir/parser/function/real/argument.rs index bed040b50c..0e97a7dfa5 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/function/real/argument.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/function/real/argument.rs @@ -2,6 +2,7 @@ use crate::codegen::ir::mir::field::{MirField, MirFieldSettings}; use crate::codegen::ir::mir::func::{MirFuncInput, MirFuncOwnerInfo}; use crate::codegen::ir::mir::func::{MirFuncOwnerInfoMethod, OwnershipMode}; use crate::codegen::ir::mir::ident::MirIdent; +use crate::codegen::ir::mir::skip::MirSkipReason; use crate::codegen::ir::mir::ty::boxed::MirTypeBoxed; use crate::codegen::ir::mir::ty::delegate::{MirTypeDelegate, MirTypeDelegateProxyEnum}; use crate::codegen::ir::mir::ty::MirType; @@ -56,7 +57,7 @@ impl<'a, 'b> FunctionParser<'a, 'b> { if ty.should_ignore(self.type_parser) { return Ok(FunctionPartialInfo { - ignore_func: true, + ignore_func: Some(MirSkipReason::IgnoreBecauseType), ..Default::default() }); } @@ -69,7 +70,7 @@ impl<'a, 'b> FunctionParser<'a, 'b> { Ok(FunctionPartialInfo { inputs: vec![MirFuncInput { inner: MirField { - name: MirIdent::new(name), + name: MirIdent::new(name, None), ty, is_final: true, is_rust_public: None, diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/function/real/mod.rs b/frb_codegen/src/library/codegen/parser/mir/parser/function/real/mod.rs index 33a28eaedb..e21c599d23 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/function/real/mod.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/function/real/mod.rs @@ -5,7 +5,10 @@ use crate::codegen::ir::mir::func::{ MirFunc, MirFuncArgMode, MirFuncImplMode, MirFuncImplModeDartOnly, MirFuncInput, MirFuncMode, MirFuncOutput, MirFuncOwnerInfo, MirFuncOwnerInfoMethod, MirFuncOwnerInfoMethodMode, }; -use crate::codegen::ir::mir::skip::MirSkipReason::IgnoredFunctionGeneric; +use crate::codegen::ir::mir::skip::MirSkipReason::{ + IgnoreBecauseExplicitAttribute, IgnoreBecauseFunctionGeneric, IgnoreBecauseOwnerTyShouldIgnore, + IgnoreSilently, +}; use crate::codegen::ir::mir::skip::{MirSkip, MirSkipReason}; use crate::codegen::ir::mir::ty::delegate::MirTypeDelegate; use crate::codegen::ir::mir::ty::primitive::MirTypePrimitive; @@ -23,11 +26,11 @@ use crate::codegen::parser::mir::ParseMode; use crate::library::codegen::ir::mir::ty::MirTypeTrait; use crate::utils::namespace::{Namespace, NamespacedName}; use anyhow::{bail, Context}; -use itertools::{concat, Itertools}; +use itertools::concat; use log::{debug, warn}; use std::fmt::Debug; use syn::*; -use MirSkipReason::{IgnoredFunctionNotPub, IgnoredMisc}; +use MirSkipReason::IgnoreBecauseFunctionNotPub; use MirType::Primitive; pub(crate) mod argument; @@ -42,9 +45,6 @@ pub(crate) fn parse( ) -> anyhow::Result> { let mut function_parser = FunctionParser::new(type_parser); (src_fns.iter()) - // Sort to make things stable. The order of parsing functions will affect things like, e.g., - // which file an opaque type is put in. - .sorted_by_key(|f| f.owner_and_name_for_dedup()) .map(|f| { function_parser.parse_function( f, @@ -58,17 +58,17 @@ pub(crate) fn parse( .collect() } -struct FunctionParser<'a, 'b> { +pub(crate) struct FunctionParser<'a, 'b> { type_parser: &'a mut TypeParser<'b>, } impl<'a, 'b> FunctionParser<'a, 'b> { - fn new(type_parser: &'a mut TypeParser<'b>) -> Self { + pub(crate) fn new(type_parser: &'a mut TypeParser<'b>) -> Self { Self { type_parser } } #[allow(clippy::too_many_arguments)] - fn parse_function( + pub(crate) fn parse_function( &mut self, func: &HirFlatFunction, force_codec_mode_pack: &Option, @@ -118,20 +118,24 @@ impl<'a, 'b> FunctionParser<'a, 'b> { debug!("parse_function function name: {:?}", func.item_fn.name()); if func.is_public() == Some(false) { - return Ok(create_output_skip(func, IgnoredFunctionNotPub)); + return Ok(create_output_skip(func, IgnoreBecauseFunctionNotPub)); } if !func.item_fn.sig().generics.params.is_empty() { - return Ok(create_output_skip(func, IgnoredFunctionGeneric)); + return Ok(create_output_skip(func, IgnoreBecauseFunctionGeneric)); } let src_lineno = func.item_fn.span().start().line; let attributes = FrbAttributes::parse(func.item_fn.attrs())?; + if attributes.dart2rust().is_some() || attributes.rust2dart().is_some() { + return Ok(create_output_skip(func, IgnoreSilently)); + } let dart_name = parse_dart_name(&attributes, &func.item_fn.name()); let create_context = |owner: Option| TypeParserParsingContext { initiated_namespace: func.namespace.clone(), func_attributes: attributes.clone(), + struct_or_enum_attributes: None, default_stream_sink_codec, default_rust_opaque_codec, owner, @@ -139,18 +143,16 @@ impl<'a, 'b> FunctionParser<'a, 'b> { }; let is_owner_trait_def = matches!(func.owner, HirFlatFunctionOwner::TraitDef { .. }); - let owner = if let Some(owner) = - self.parse_owner(func, &create_context(None), dart_name.clone(), &attributes)? - { - owner - } else { - return Ok(create_output_skip(func, IgnoredMisc)); - }; + let owner = + match self.parse_owner(func, &create_context(None), dart_name.clone(), &attributes)? { + OwnerInfoOrSkip::Info(info) => info, + OwnerInfoOrSkip::Skip(reason) => return Ok(create_output_skip(func, reason)), + }; let func_name = parse_name(&func.item_fn.name(), &owner); if attributes.ignore() { - return Ok(create_output_skip(func, IgnoredMisc)); + return Ok(create_output_skip(func, IgnoreBecauseExplicitAttribute)); } let context = create_context(Some(owner.clone())); @@ -176,8 +178,8 @@ impl<'a, 'b> FunctionParser<'a, 'b> { let impl_mode = compute_impl_mode(is_owner_trait_def, &func_name, &attributes, &output); - if info.ignore_func { - return Ok(create_output_skip(func, IgnoredMisc)); + if let Some(ignore_func) = info.ignore_func { + return Ok(create_output_skip(func, ignore_func)); } Ok(MirFuncOrSkip::Func(MirFunc { @@ -211,9 +213,12 @@ impl<'a, 'b> FunctionParser<'a, 'b> { context: &TypeParserParsingContext, actual_method_dart_name: Option, attributes: &FrbAttributes, - ) -> anyhow::Result> { + ) -> anyhow::Result { + use MirSkipReason::*; + use OwnerInfoOrSkip::*; + match &func.owner { - HirFlatFunctionOwner::Function => Ok(Some(MirFuncOwnerInfo::Function)), + HirFlatFunctionOwner::Function => Ok(Info(MirFuncOwnerInfo::Function)), HirFlatFunctionOwner::StructOrEnum { impl_ty, trait_def_name, @@ -221,7 +226,7 @@ impl<'a, 'b> FunctionParser<'a, 'b> { let owner_ty = if let Some(x) = self.parse_method_owner_ty(impl_ty, context)? { x } else { - return Ok(None); + return Ok(Skip(IgnoreBecauseParseMethodOwnerTy)); }; let trait_def = if let Some(trait_def_name) = trait_def_name { @@ -229,14 +234,14 @@ impl<'a, 'b> FunctionParser<'a, 'b> { Some(ans) } else { // If cannot find the trait, we directly skip the function currently - return Ok(None); + return Ok(Skip(IgnoreBecauseParseOwnerCannotFindTrait)); } } else { None }; if !is_allowed_owner(&owner_ty, attributes) { - return Ok(None); + return Ok(Skip(IgnoreBecauseNotAllowedOwner)); } self.parse_method_owner_inner(func, actual_method_dart_name, owner_ty, trait_def) @@ -262,7 +267,9 @@ impl<'a, 'b> FunctionParser<'a, 'b> { actual_method_dart_name: Option, owner_ty: MirType, trait_def: Option, - ) -> anyhow::Result> { + ) -> anyhow::Result { + use OwnerInfoOrSkip::*; + let sig = func.item_fn.sig(); let mode = if matches!(sig.inputs.first(), Some(FnArg::Receiver(..))) { MirFuncOwnerInfoMethodMode::Instance @@ -271,12 +278,12 @@ impl<'a, 'b> FunctionParser<'a, 'b> { }; if owner_ty.should_ignore(self.type_parser) { - return Ok(None); + return Ok(Skip(IgnoreBecauseOwnerTyShouldIgnore)); } let actual_method_name = sig.ident.to_string(); - Ok(Some(MirFuncOwnerInfo::Method(MirFuncOwnerInfoMethod { + Ok(Info(MirFuncOwnerInfo::Method(MirFuncOwnerInfoMethod { owner_ty, actual_method_name, actual_method_dart_name, @@ -305,6 +312,11 @@ impl<'a, 'b> FunctionParser<'a, 'b> { } } +enum OwnerInfoOrSkip { + Info(MirFuncOwnerInfo), + Skip(MirSkipReason), +} + fn create_output_skip(func: &HirFlatFunction, reason: MirSkipReason) -> MirFuncOrSkip { MirFuncOrSkip::Skip(MirSkip { name: NamespacedName::new(func.namespace.clone(), func.item_fn.name().to_string()), @@ -341,7 +353,7 @@ struct FunctionPartialInfo { ok_output: Option, error_output: Option, mode: Option, - ignore_func: bool, + ignore_func: Option, } impl FunctionPartialInfo { @@ -352,7 +364,8 @@ impl FunctionPartialInfo { error_output: merge_option(self.error_output, other.error_output) .context("error_output type")?, mode: merge_option(self.mode, other.mode).context("mode")?, - ignore_func: self.ignore_func || other.ignore_func, + ignore_func: merge_option(self.ignore_func, other.ignore_func) + .context("ignore_func")?, }) } } diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/mod.rs b/frb_codegen/src/library/codegen/parser/mir/parser/mod.rs index 13abed12b3..6be1821ddc 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/mod.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/mod.rs @@ -1,4 +1,5 @@ pub(crate) mod attribute; +pub(crate) mod custom_ser_des; pub(crate) mod function; pub(crate) mod misc; pub(crate) mod trait_impl; @@ -31,6 +32,19 @@ pub(crate) fn parse( parse_mode, )?; + let custom_ser_des_infos = custom_ser_des::parse( + &hir_flat.functions, + &mut type_parser, + &custom_ser_des::PartialContext { + default_stream_sink_codec: config.default_stream_sink_codec, + default_rust_opaque_codec: config.default_rust_opaque_codec, + parse_mode, + }, + )?; + type_parser + .custom_ser_des_infos + .extend(custom_ser_des_infos); + let (funcs_all, skipped_functions) = function::parse( config, &hir_flat.functions, diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/trait_impl.rs b/frb_codegen/src/library/codegen/parser/mir/parser/trait_impl.rs index 52f5011d21..a7580e192d 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/trait_impl.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/trait_impl.rs @@ -21,6 +21,7 @@ pub(crate) fn parse( let context = TypeParserParsingContext { initiated_namespace: CrateName::self_crate().namespace(), // just a dummy value func_attributes: FrbAttributes::parse(&[])?, + struct_or_enum_attributes: None, default_stream_sink_codec, default_rust_opaque_codec, owner: None, diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/ty/custom_ser_des.rs b/frb_codegen/src/library/codegen/parser/mir/parser/ty/custom_ser_des.rs new file mode 100644 index 0000000000..2c0254e4d7 --- /dev/null +++ b/frb_codegen/src/library/codegen/parser/mir/parser/ty/custom_ser_des.rs @@ -0,0 +1,21 @@ +use crate::codegen::ir::mir::ty::delegate::{MirTypeDelegate, MirTypeDelegateCustomSerDes}; +use crate::codegen::ir::mir::ty::MirType; +use crate::codegen::parser::mir::parser::ty::unencodable::SplayedSegment; +use crate::codegen::parser::mir::parser::ty::TypeParserWithContext; +use crate::library::codegen::ir::mir::ty::MirTypeTrait; + +impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { + pub(crate) fn parse_type_path_data_custom_ser_des( + &mut self, + last_segment: &SplayedSegment, + ) -> anyhow::Result> { + // use HashMap etc later if too slow; here we use filter to remain flexibility of filtering strategy + Ok((self.inner.custom_ser_des_infos.iter()) + .find(|info| info.rust_api_type.rust_api_type() == last_segment.0) + .map(|info| { + MirType::Delegate(MirTypeDelegate::CustomSerDes(MirTypeDelegateCustomSerDes { + info: info.to_owned(), + })) + })) + } +} diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/ty/enumeration.rs b/frb_codegen/src/library/codegen/parser/mir/parser/ty/enumeration.rs index 0ce4b32233..c62f09e84f 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/ty/enumeration.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/ty/enumeration.rs @@ -66,10 +66,10 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { src_enum: &HirFlatEnum, variant: &Variant, ) -> anyhow::Result { - let variant_name = MirIdent::new(variant.ident.to_string()); + let variant_name = MirIdent::new(variant.ident.to_string(), None); Ok(MirEnumVariant { name: variant_name.clone(), - wrapper_name: MirIdent::new(format!("{}_{}", src_enum.name.name, variant.ident)), + wrapper_name: MirIdent::new(format!("{}_{}", src_enum.name.name, variant.ident), None), comments: parse_comments(&variant.attrs), kind: match variant.fields.iter().next() { None => MirVariantKind::Value, @@ -118,8 +118,11 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .as_ref() .map(ToString::to_string) .unwrap_or_else(|| format!("field{idx}")), + None, ), - ty: self.parse_type(&field.ty)?, + ty: self.parse_type_with_context(&field.ty, |c| { + c.with_struct_or_enum_attributes(attributes.clone()) + })?, is_final: true, is_rust_public: Some(matches!(field.vis, Visibility::Public(_))), comments: parse_comments(&field.attrs), @@ -139,7 +142,7 @@ pub(crate) fn compute_enum_variant_kind_struct_name( variant_name: &MirIdent, ) -> NamespacedName { let variant_namespace = enum_name.namespace.join(&enum_name.name); - NamespacedName::new(variant_namespace, variant_name.raw.clone()) + NamespacedName::new(variant_namespace, variant_name.rust_style().to_owned()) } struct EnumOrStructParserEnum<'a, 'b, 'c, 'd>(&'d mut TypeParserWithContext<'a, 'b, 'c>); diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/ty/mod.rs b/frb_codegen/src/library/codegen/parser/mir/parser/ty/mod.rs index 2881bded81..ae5f29f691 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/ty/mod.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/ty/mod.rs @@ -5,6 +5,7 @@ use crate::codegen::ir::early_generator::trait_def_info::IrEarlyGeneratorTraitDe use crate::codegen::ir::hir::flat::struct_or_enum::HirFlatEnum; use crate::codegen::ir::hir::flat::struct_or_enum::HirFlatStruct; use crate::codegen::ir::hir::flat::traits::HirFlatTrait; +use crate::codegen::ir::mir::custom_ser_des::MirCustomSerDes; use crate::codegen::ir::mir::func::MirFuncOwnerInfo; use crate::codegen::ir::mir::pack::{MirEnumPool, MirStructPool}; use crate::codegen::ir::mir::ty::enumeration::{MirEnum, MirEnumIdent}; @@ -23,9 +24,11 @@ use crate::utils::basic_code::general_code::GeneralDartCode; use crate::utils::namespace::Namespace; use std::collections::HashMap; use syn::Type; +use syn::__private::str; pub(crate) mod array; pub(crate) mod concrete; +pub(crate) mod custom_ser_des; mod dart_fn; mod enum_or_struct; pub(crate) mod enumeration; @@ -55,6 +58,7 @@ pub(crate) struct TypeParser<'a> { src_types: HashMap, pub(super) proxied_types: Vec, pub(super) trait_def_infos: Vec, + pub(super) custom_ser_des_infos: Vec, dart_code_of_type: HashMap, struct_parser_info: EnumOrStructParserInfo, enum_parser_info: EnumOrStructParserInfo, @@ -90,6 +94,7 @@ impl<'a> TypeParser<'a> { src_types, proxied_types, trait_def_infos, + custom_ser_des_infos: Default::default(), dart_code_of_type: HashMap::new(), struct_parser_info: EnumOrStructParserInfo::new(), enum_parser_info: EnumOrStructParserInfo::new(), @@ -136,15 +141,26 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { } } +#[derive(Clone)] pub(crate) struct TypeParserParsingContext { pub(crate) initiated_namespace: Namespace, pub(crate) func_attributes: FrbAttributes, + pub(crate) struct_or_enum_attributes: Option, pub(crate) default_stream_sink_codec: CodecMode, pub(crate) default_rust_opaque_codec: RustOpaqueCodecMode, pub(crate) owner: Option, pub(crate) parse_mode: ParseMode, } +impl TypeParserParsingContext { + pub(crate) fn with_struct_or_enum_attributes(&self, x: FrbAttributes) -> Self { + Self { + struct_or_enum_attributes: Some(x), + ..self.clone() + } + } +} + impl MirContext for TypeParser<'_> { fn struct_pool(&self) -> &MirStructPool { &self.struct_parser_info.object_pool diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/ty/path.rs b/frb_codegen/src/library/codegen/parser/mir/parser/ty/path.rs index b74668de8f..496f4dbd96 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/ty/path.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/ty/path.rs @@ -33,6 +33,9 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { let splayed_segments = splay_segments(&segments); if let Some(last_segment) = splayed_segments.last() { + if let Some(ans) = self.parse_type_path_data_custom_ser_des(last_segment)? { + return Ok(ans); + } if let Some(ans) = self.parse_type_path_data_primitive(last_segment)? { return Ok(ans); } diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/ty/primitive.rs b/frb_codegen/src/library/codegen/parser/mir/parser/ty/primitive.rs index a06cdd67ce..3729ad9673 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/ty/primitive.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/ty/primitive.rs @@ -1,9 +1,11 @@ -use crate::codegen::ir::mir::ty::delegate::{MirTypeDelegate, MirTypeDelegateBigPrimitive}; +use crate::codegen::ir::mir::ty::delegate::{ + MirTypeDelegate, MirTypeDelegateBigPrimitive, MirTypeDelegateCastedPrimitive, +}; use crate::codegen::ir::mir::ty::primitive::MirTypePrimitive; use crate::codegen::ir::mir::ty::MirType; use crate::codegen::ir::mir::ty::MirType::Primitive; use crate::codegen::parser::mir::parser::ty::unencodable::SplayedSegment; -use crate::codegen::parser::mir::parser::ty::TypeParserWithContext; +use crate::codegen::parser::mir::parser::ty::{TypeParserParsingContext, TypeParserWithContext}; impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { pub(crate) fn parse_type_path_data_primitive( @@ -12,8 +14,8 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { ) -> anyhow::Result> { Ok(Some(match last_segment { // TODO: change to "if let guard" https://github.com/rust-lang/rust/issues/51114 - (name, []) if matches!(parse_primitive(name), Some(..)) => { - Primitive(parse_primitive(name).unwrap()) + (name, []) if matches!(parse_primitive(name, self.context), Some(..)) => { + parse_primitive(name, self.context).unwrap() } (name, []) if matches!(parse_big_primitive(name), Some(..)) => { parse_big_primitive(name).unwrap() @@ -24,7 +26,11 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { } } -fn parse_primitive(s: &str) -> Option { +fn parse_primitive(s: &str, context: &TypeParserParsingContext) -> Option { + parse_primitive_raw(s).map(|primitive| transform_primitive(primitive, context)) +} + +fn parse_primitive_raw(s: &str) -> Option { Some(match s { "u8" => MirTypePrimitive::U8, "i8" => MirTypePrimitive::I8, @@ -44,6 +50,28 @@ fn parse_primitive(s: &str) -> Option { }) } +fn transform_primitive(inner: MirTypePrimitive, context: &TypeParserParsingContext) -> MirType { + if context.func_attributes.type_64bit_int() + || (context.struct_or_enum_attributes.as_ref()) + .map(|x| x.type_64bit_int()) + .unwrap_or_default() + { + match inner { + MirTypePrimitive::U64 + | MirTypePrimitive::I64 + | MirTypePrimitive::Usize + | MirTypePrimitive::Isize => { + return MirType::Delegate(MirTypeDelegate::CastedPrimitive( + MirTypeDelegateCastedPrimitive { inner }, + )) + } + _ => {} + } + } + + Primitive(inner) +} + fn parse_big_primitive(s: &str) -> Option { Some(MirType::Delegate(MirTypeDelegate::BigPrimitive(match s { "i128" => MirTypeDelegateBigPrimitive::I128, diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/ty/structure.rs b/frb_codegen/src/library/codegen/parser/mir/parser/ty/structure.rs index a9b6da3680..923513837e 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/ty/structure.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/ty/structure.rs @@ -43,17 +43,17 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { // frb-coverage:ignore-end }; + let attributes = FrbAttributes::parse(&src_struct.src.attrs)?; + let dart_metadata = attributes.dart_metadata(); + let fields = struct_fields .iter() .enumerate() - .map(|(idx, field)| self.parse_struct_field(idx, field)) + .map(|(idx, field)| self.parse_struct_field(idx, field, &attributes)) .collect::>>()?; let comments = parse_comments(&src_struct.src.attrs); - let attributes = FrbAttributes::parse(&src_struct.src.attrs)?; - let dart_metadata = attributes.dart_metadata(); - let ignore = parse_struct_or_enum_should_ignore(src_struct, &name.namespace.crate_name()); Ok(MirStruct { @@ -69,15 +69,22 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { }) } - fn parse_struct_field(&mut self, idx: usize, field: &Field) -> anyhow::Result { + fn parse_struct_field( + &mut self, + idx: usize, + field: &Field, + attributes: &FrbAttributes, + ) -> anyhow::Result { let field_name = field .ident .as_ref() .map_or(format!("field{idx}"), ToString::to_string); - let field_type = self.parse_type(&field.ty)?; + let field_type = self.parse_type_with_context(&field.ty, |c| { + c.with_struct_or_enum_attributes(attributes.clone()) + })?; let attributes = FrbAttributes::parse(&field.attrs)?; Ok(MirField { - name: MirIdent::new(field_name), + name: MirIdent::new(field_name, attributes.name()), ty: field_type, is_final: !attributes.non_final(), is_rust_public: Some(matches!(field.vis, Visibility::Public(_))), diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/ty/tuple.rs b/frb_codegen/src/library/codegen/parser/mir/parser/ty/tuple.rs index 4282833043..a0a40bc7e2 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/ty/tuple.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/ty/tuple.rs @@ -49,7 +49,7 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { .enumerate() .map(|(idx, ty)| MirField { ty: ty.clone(), - name: MirIdent::new(format!("field{idx}")), + name: MirIdent::new(format!("field{idx}"), None), is_final: true, is_rust_public: None, comments: vec![], diff --git a/frb_codegen/src/library/codegen/parser/mir/parser/ty/ty.rs b/frb_codegen/src/library/codegen/parser/mir/parser/ty/ty.rs index b3761ff623..b0634c429d 100644 --- a/frb_codegen/src/library/codegen/parser/mir/parser/ty/ty.rs +++ b/frb_codegen/src/library/codegen/parser/mir/parser/ty/ty.rs @@ -1,6 +1,6 @@ use crate::codegen::ir::mir::ty::MirType; use crate::codegen::parser::mir::parser::ty::misc::convert_ident_str; -use crate::codegen::parser::mir::parser::ty::TypeParserWithContext; +use crate::codegen::parser::mir::parser::ty::{TypeParserParsingContext, TypeParserWithContext}; use anyhow::Context; use syn::Type; @@ -10,6 +10,19 @@ impl<'a, 'b, 'c> TypeParserWithContext<'a, 'b, 'c> { self.parse_type_inner(&resolve_ty) } + pub(crate) fn parse_type_with_context( + &mut self, + ty: &Type, + context_modifier: impl FnOnce(&TypeParserParsingContext) -> TypeParserParsingContext, + ) -> anyhow::Result { + let new_context = context_modifier(self.context); + let mut self_with_context = TypeParserWithContext { + inner: self.inner, + context: &new_context, + }; + self_with_context.parse_type(ty) + } + fn parse_type_inner(&mut self, ty: &Type) -> anyhow::Result { Ok(match ty.clone() { Type::Path(x) => self.parse_type_path(&x)?, diff --git a/frb_codegen/src/library/utils/dart_keywords.rs b/frb_codegen/src/library/utils/dart_keywords.rs index 0c0fdde318..c209e62eac 100644 --- a/frb_codegen/src/library/utils/dart_keywords.rs +++ b/frb_codegen/src/library/utils/dart_keywords.rs @@ -1,28 +1,11 @@ -use anyhow::bail; -use convert_case::{Case, Casing}; - -/// If the given string is a Dart keyword, then -/// convert it to PascalCase to avoid issues. -/// If the string is not a keyword, then the original -/// is returned. -pub(crate) fn make_string_keyword_safe(input: String) -> String { - if check_for_keywords(&[input.clone()]).is_err() { - input.to_case(Case::Pascal) +pub(crate) fn escape(input: String) -> String { + if DART_KEYWORDS.contains(&input.as_str()) { + format!("{input}_") } else { input } } -// the function signature is not covered while the whole body is covered - looks like a bug in coverage tool -// frb-coverage:ignore-start -fn check_for_keywords(v: &[String]) -> anyhow::Result<()> { - // frb-coverage:ignore-end - if let Some(s) = v.iter().find(|s| DART_KEYWORDS.contains(&s.as_str())) { - bail!("Api name cannot be a dart keyword: {}", s); - }; - Ok(()) -} - // https://dart.dev/guides/language/language-tour#keywords const DART_KEYWORDS: [&str; 63] = [ "abstract", diff --git a/frb_dart/lib/src/manual_impl/_io.dart b/frb_dart/lib/src/manual_impl/_io.dart index 4329f8cf6e..5c6ed0b3c2 100644 --- a/frb_dart/lib/src/manual_impl/_io.dart +++ b/frb_dart/lib/src/manual_impl/_io.dart @@ -22,3 +22,9 @@ Int64List dcoDecodeInt64List($data.Int64List raw) => Int64List.raw(raw); /// {@macro flutter_rust_bridge.only_for_generated_code} Uint64List dcoDecodeUint64List($data.Uint64List raw) => Uint64List.raw(raw); + +/// {@macro flutter_rust_bridge.only_for_generated_code} +int sseEncodeCastedPrimitiveI64(int raw) => raw; + +/// {@macro flutter_rust_bridge.only_for_generated_code} +BigInt sseEncodeCastedPrimitiveU64(int raw) => BigInt.from(raw); diff --git a/frb_dart/lib/src/manual_impl/_web.dart b/frb_dart/lib/src/manual_impl/_web.dart index ff59b57fbe..0a3d9f0bbf 100644 --- a/frb_dart/lib/src/manual_impl/_web.dart +++ b/frb_dart/lib/src/manual_impl/_web.dart @@ -22,3 +22,9 @@ Uint64List dcoDecodeUint64List(List raw) => List _toListBigInt(List raw) => raw.map((x) => jsBigIntToDartBigInt(x!)).toList(); + +/// {@macro flutter_rust_bridge.only_for_generated_code} +BigInt sseEncodeCastedPrimitiveI64(int raw) => BigInt.from(raw); + +/// {@macro flutter_rust_bridge.only_for_generated_code} +BigInt sseEncodeCastedPrimitiveU64(int raw) => BigInt.from(raw); 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 e5e68aeeff..ae3e06b17a 100644 --- a/frb_example/dart_minimal/lib/src/rust/frb_generated.dart +++ b/frb_example/dart_minimal/lib/src/rust/frb_generated.dart @@ -45,7 +45,9 @@ class RustLib extends BaseEntrypoint { RustLibWire.fromExternalLibrary; @override - Future executeRustInitializers() async {} + Future executeRustInitializers() async { + await api.crateApiMinimalInitApp(); + } @override ExternalLibraryLoaderConfig get defaultExternalLibraryLoaderConfig => @@ -55,7 +57,7 @@ class RustLib extends BaseEntrypoint { String get codegenVersion => '2.0.0-dev.38'; @override - int get rustContentHash => 1483852093; + int get rustContentHash => -2119384465; static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig( @@ -66,8 +68,7 @@ class RustLib extends BaseEntrypoint { } abstract class RustLibApi extends BaseApi { - Future crateApiMinimalHandleComplexStructTwinNormal( - {required MyTreeNodeTwinNormal s}); + Future crateApiMinimalInitApp(); Future crateApiMinimalMinimalAdder({required int a, required int b}); } @@ -81,29 +82,26 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { }); @override - Future crateApiMinimalHandleComplexStructTwinNormal( - {required MyTreeNodeTwinNormal s}) { + Future crateApiMinimalInitApp() { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_box_autoadd_my_tree_node_twin_normal(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1, port: port_); }, codec: SseCodec( - decodeSuccessData: sse_decode_my_tree_node_twin_normal, + decodeSuccessData: sse_decode_unit, decodeErrorData: null, ), - constMeta: kCrateApiMinimalHandleComplexStructTwinNormalConstMeta, - argValues: [s], + constMeta: kCrateApiMinimalInitAppConstMeta, + argValues: [], apiImpl: this, )); } - TaskConstMeta get kCrateApiMinimalHandleComplexStructTwinNormalConstMeta => - const TaskConstMeta( - debugName: "handle_complex_struct_twin_normal", - argNames: ["s"], + TaskConstMeta get kCrateApiMinimalInitAppConstMeta => const TaskConstMeta( + debugName: "init_app", + argNames: [], ); @override @@ -132,142 +130,33 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["a", "b"], ); - @protected - bool dco_decode_bool(dynamic raw) { - // Codec=Dco (DartCObject based), see doc to use other codecs - return raw as bool; - } - - @protected - MyTreeNodeTwinNormal dco_decode_box_autoadd_my_tree_node_twin_normal( - dynamic raw) { - // Codec=Dco (DartCObject based), see doc to use other codecs - return dco_decode_my_tree_node_twin_normal(raw); - } - @protected int dco_decode_i_32(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs return raw as int; } - @protected - List dco_decode_list_my_tree_node_twin_normal( - dynamic raw) { - // Codec=Dco (DartCObject based), see doc to use other codecs - return (raw as List) - .map(dco_decode_my_tree_node_twin_normal) - .toList(); - } - - @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 - MyTreeNodeTwinNormal dco_decode_my_tree_node_twin_normal(dynamic raw) { - // Codec=Dco (DartCObject based), see doc to use other codecs - final arr = raw as List; - if (arr.length != 4) - throw Exception('unexpected arr length: expect 4 but see ${arr.length}'); - return MyTreeNodeTwinNormal( - valueI32: dco_decode_i_32(arr[0]), - valueVecU8: dco_decode_list_prim_u_8_strict(arr[1]), - valueBoolean: dco_decode_bool(arr[2]), - children: dco_decode_list_my_tree_node_twin_normal(arr[3]), - ); - } - - @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 - bool sse_decode_bool(SseDeserializer deserializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - return deserializer.buffer.getUint8() != 0; - } - - @protected - MyTreeNodeTwinNormal sse_decode_box_autoadd_my_tree_node_twin_normal( - SseDeserializer deserializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - return (sse_decode_my_tree_node_twin_normal(deserializer)); - } - @protected int sse_decode_i_32(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs return deserializer.buffer.getInt32(); } - @protected - List sse_decode_list_my_tree_node_twin_normal( - SseDeserializer deserializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - - var len_ = sse_decode_i_32(deserializer); - var ans_ = []; - for (var idx_ = 0; idx_ < len_; ++idx_) { - ans_.add(sse_decode_my_tree_node_twin_normal(deserializer)); - } - return ans_; - } - - @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 - MyTreeNodeTwinNormal sse_decode_my_tree_node_twin_normal( - SseDeserializer deserializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - var var_valueI32 = sse_decode_i_32(deserializer); - var var_valueVecU8 = sse_decode_list_prim_u_8_strict(deserializer); - var var_valueBoolean = sse_decode_bool(deserializer); - var var_children = sse_decode_list_my_tree_node_twin_normal(deserializer); - return MyTreeNodeTwinNormal( - valueI32: var_valueI32, - valueVecU8: var_valueVecU8, - valueBoolean: var_valueBoolean, - children: var_children); - } - - @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 - void sse_encode_bool(bool self, SseSerializer serializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - serializer.buffer.putUint8(self ? 1 : 0); - } - - @protected - void sse_encode_box_autoadd_my_tree_node_twin_normal( - MyTreeNodeTwinNormal self, SseSerializer serializer) { + bool sse_decode_bool(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs - sse_encode_my_tree_node_twin_normal(self, serializer); + return deserializer.buffer.getUint8() != 0; } @protected @@ -277,41 +166,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void sse_encode_list_my_tree_node_twin_normal( - List self, SseSerializer serializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - sse_encode_i_32(self.length, serializer); - for (final item in self) { - sse_encode_my_tree_node_twin_normal(item, serializer); - } - } - - @protected - void sse_encode_list_prim_u_8_strict( - Uint8List self, SseSerializer serializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - sse_encode_i_32(self.length, serializer); - serializer.buffer.putUint8List(self); - } - - @protected - void sse_encode_my_tree_node_twin_normal( - MyTreeNodeTwinNormal self, SseSerializer serializer) { - // Codec=Sse (Serialization based), see doc to use other codecs - sse_encode_i_32(self.valueI32, serializer); - sse_encode_list_prim_u_8_strict(self.valueVecU8, serializer); - sse_encode_bool(self.valueBoolean, serializer); - sse_encode_list_my_tree_node_twin_normal(self.children, serializer); - } - - @protected - void sse_encode_u_8(int self, SseSerializer serializer) { + void sse_encode_unit(void 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) { + void sse_encode_bool(bool self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs + serializer.buffer.putUint8(self ? 1 : 0); } } 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 34deceaa9e..72e4d2de80 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,86 +18,29 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { required super.portManager, }); - @protected - bool dco_decode_bool(dynamic raw); - - @protected - MyTreeNodeTwinNormal dco_decode_box_autoadd_my_tree_node_twin_normal( - dynamic raw); - @protected int dco_decode_i_32(dynamic raw); - @protected - List dco_decode_list_my_tree_node_twin_normal( - dynamic raw); - - @protected - Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); - - @protected - MyTreeNodeTwinNormal dco_decode_my_tree_node_twin_normal(dynamic raw); - - @protected - int dco_decode_u_8(dynamic raw); - @protected void dco_decode_unit(dynamic raw); - @protected - bool sse_decode_bool(SseDeserializer deserializer); - - @protected - MyTreeNodeTwinNormal sse_decode_box_autoadd_my_tree_node_twin_normal( - SseDeserializer deserializer); - @protected int sse_decode_i_32(SseDeserializer deserializer); - @protected - List sse_decode_list_my_tree_node_twin_normal( - SseDeserializer deserializer); - - @protected - Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); - - @protected - MyTreeNodeTwinNormal sse_decode_my_tree_node_twin_normal( - SseDeserializer deserializer); - - @protected - int sse_decode_u_8(SseDeserializer deserializer); - @protected void sse_decode_unit(SseDeserializer deserializer); @protected - void sse_encode_bool(bool self, SseSerializer serializer); - - @protected - void sse_encode_box_autoadd_my_tree_node_twin_normal( - MyTreeNodeTwinNormal self, SseSerializer serializer); + bool sse_decode_bool(SseDeserializer deserializer); @protected void sse_encode_i_32(int self, SseSerializer serializer); @protected - void sse_encode_list_my_tree_node_twin_normal( - List self, SseSerializer serializer); - - @protected - void sse_encode_list_prim_u_8_strict( - Uint8List self, SseSerializer serializer); - - @protected - void sse_encode_my_tree_node_twin_normal( - MyTreeNodeTwinNormal self, SseSerializer serializer); - - @protected - void sse_encode_u_8(int self, SseSerializer serializer); + void sse_encode_unit(void self, SseSerializer serializer); @protected - void sse_encode_unit(void self, SseSerializer serializer); + void sse_encode_bool(bool self, SseSerializer serializer); } // Section: wire_class 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 47cda86119..69e39a7a08 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 @@ -20,86 +20,29 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { required super.portManager, }); - @protected - bool dco_decode_bool(dynamic raw); - - @protected - MyTreeNodeTwinNormal dco_decode_box_autoadd_my_tree_node_twin_normal( - dynamic raw); - @protected int dco_decode_i_32(dynamic raw); - @protected - List dco_decode_list_my_tree_node_twin_normal( - dynamic raw); - - @protected - Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); - - @protected - MyTreeNodeTwinNormal dco_decode_my_tree_node_twin_normal(dynamic raw); - - @protected - int dco_decode_u_8(dynamic raw); - @protected void dco_decode_unit(dynamic raw); - @protected - bool sse_decode_bool(SseDeserializer deserializer); - - @protected - MyTreeNodeTwinNormal sse_decode_box_autoadd_my_tree_node_twin_normal( - SseDeserializer deserializer); - @protected int sse_decode_i_32(SseDeserializer deserializer); - @protected - List sse_decode_list_my_tree_node_twin_normal( - SseDeserializer deserializer); - - @protected - Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); - - @protected - MyTreeNodeTwinNormal sse_decode_my_tree_node_twin_normal( - SseDeserializer deserializer); - - @protected - int sse_decode_u_8(SseDeserializer deserializer); - @protected void sse_decode_unit(SseDeserializer deserializer); @protected - void sse_encode_bool(bool self, SseSerializer serializer); - - @protected - void sse_encode_box_autoadd_my_tree_node_twin_normal( - MyTreeNodeTwinNormal self, SseSerializer serializer); + bool sse_decode_bool(SseDeserializer deserializer); @protected void sse_encode_i_32(int self, SseSerializer serializer); @protected - void sse_encode_list_my_tree_node_twin_normal( - List self, SseSerializer serializer); - - @protected - void sse_encode_list_prim_u_8_strict( - Uint8List self, SseSerializer serializer); - - @protected - void sse_encode_my_tree_node_twin_normal( - MyTreeNodeTwinNormal self, SseSerializer serializer); - - @protected - void sse_encode_u_8(int self, SseSerializer serializer); + void sse_encode_unit(void self, SseSerializer serializer); @protected - void sse_encode_unit(void self, SseSerializer serializer); + void sse_encode_bool(bool self, SseSerializer serializer); } // Section: wire_class diff --git a/frb_example/dart_minimal/rust/src/frb_generated.rs b/frb_example/dart_minimal/rust/src/frb_generated.rs index cc4466fa38..361f76bac8 100644 --- a/frb_example/dart_minimal/rust/src/frb_generated.rs +++ b/frb_example/dart_minimal/rust/src/frb_generated.rs @@ -33,7 +33,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.38"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 1483852093; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -2119384465; // Section: executor @@ -41,15 +41,15 @@ flutter_rust_bridge::frb_generated_default_handler!(); // Section: wire_funcs -fn wire__crate__api__minimal__handle_complex_struct_twin_normal_impl( - port_: flutter_rust_bridge::for_generated::DartNativeSendPort, +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, data_len_: i32, ) { FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { - debug_name: "handle_complex_struct_twin_normal", + debug_name: "init_app", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, @@ -63,20 +63,19 @@ fn wire__crate__api__minimal__handle_complex_struct_twin_normal_impl( }; let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_s = ::sse_decode(&mut deserializer); deserializer.end(); move |context| { transform_result_sse((move || { - Result::<_, ()>::Ok(crate::api::minimal::handle_complex_struct_twin_normal( - api_s, - )) + Result::<_, ()>::Ok({ + crate::api::minimal::init_app(); + }) })()) } }, ) } fn wire__crate__api__minimal__minimal_adder_impl( - port_: flutter_rust_bridge::for_generated::DartNativeSendPort, + port_: flutter_rust_bridge::for_generated::MessagePort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, data_len_: i32, @@ -111,13 +110,6 @@ fn wire__crate__api__minimal__minimal_adder_impl( // Section: dart2rust -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 { - deserializer.cursor.read_u8().unwrap() != 0 - } -} - 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 { @@ -125,76 +117,28 @@ 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 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 crate::api::minimal::MyTreeNodeTwinNormal { +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 { - let mut var_valueI32 = ::sse_decode(deserializer); - let mut var_valueVecU8 = >::sse_decode(deserializer); - let mut var_valueBoolean = ::sse_decode(deserializer); - let mut var_children = - >::sse_decode(deserializer); - return crate::api::minimal::MyTreeNodeTwinNormal { - value_i32: var_valueI32, - value_vec_u8: var_valueVecU8, - value_boolean: var_valueBoolean, - children: var_children, - }; - } + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {} } -impl SseDecode for u8 { +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 { - deserializer.cursor.read_u8().unwrap() + deserializer.cursor.read_u8().unwrap() != 0 } } -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 {} -} - fn pde_ffi_dispatcher_primary_impl( func_id: i32, - port: flutter_rust_bridge::for_generated::DartNativeSendPort, + port: flutter_rust_bridge::for_generated::MessagePort, ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len: i32, data_len: i32, ) { // Codec=Pde (Serialization + dispatch), see doc to use other codecs match func_id { - 1 => wire__crate__api__minimal__handle_complex_struct_twin_normal_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), _ => unreachable!(), } @@ -214,37 +158,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::MyTreeNodeTwinNormal { - fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { - [ - self.value_i32.into_into_dart().into_dart(), - self.value_vec_u8.into_into_dart().into_dart(), - self.value_boolean.into_into_dart().into_dart(), - self.children.into_into_dart().into_dart(), - ] - .into_dart() - } -} -impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive - for crate::api::minimal::MyTreeNodeTwinNormal -{ -} -impl flutter_rust_bridge::IntoIntoDart - for crate::api::minimal::MyTreeNodeTwinNormal -{ - fn into_into_dart(self) -> crate::api::minimal::MyTreeNodeTwinNormal { - self - } -} - -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) { - serializer.cursor.write_u8(self as _).unwrap(); - } -} - 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) { @@ -252,48 +165,18 @@ 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 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 crate::api::minimal::MyTreeNodeTwinNormal { +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) { - ::sse_encode(self.value_i32, serializer); - >::sse_encode(self.value_vec_u8, serializer); - ::sse_encode(self.value_boolean, serializer); - >::sse_encode(self.children, serializer); - } + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {} } -impl SseEncode for u8 { +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) { - serializer.cursor.write_u8(self).unwrap(); + serializer.cursor.write_u8(self as _).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) {} -} - #[cfg(not(target_family = "wasm"))] #[path = "frb_generated.io.rs"] mod io; diff --git a/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api.dart b/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api.dart index 6f7ec4981e..ae2361540e 100644 --- a/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api.dart +++ b/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api.dart @@ -10,7 +10,7 @@ import 'web_audio_api/node.dart'; import 'web_audio_api/worklet.dart'; // These types are ignored because they are not used by any `pub` functions: `AtomicF32`, `AtomicF64`, `ErrorEvent`, `MediaElement`, `MessagePort` -// These functions are ignored: `load`, `load`, `new`, `new`, `store`, `store` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `load`, `load`, `new`, `new`, `store`, `store` // Rust type: RustOpaqueMoi> abstract class AudioBuffer implements RustOpaqueInterface { diff --git a/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/context.dart b/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/context.dart index 6b665b2d64..36dd5fbb27 100644 --- a/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/context.dart +++ b/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/context.dart @@ -816,7 +816,7 @@ class AudioContextOptions { /// Currently, only the default value is available enum AudioContextRenderSizeCategory { /// The default value of 128 frames - Default, + default_, ; } diff --git a/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/media_devices.dart b/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/media_devices.dart index f1e09aa3ce..bc37f54036 100644 --- a/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/media_devices.dart +++ b/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/media_devices.dart @@ -8,7 +8,8 @@ import 'media_streams.dart'; import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; // These types are ignored because they are not used by any `pub` functions: `DeviceId`, `MediaDeviceInfoKind`, `MediaDeviceInfo`, `MediaTrackConstraints` -// These functions are ignored: `device_id`, `enumerate_devices_sync`, `group_id`, `kind`, `label` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `enumerate_devices_sync` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `device_id`, `group_id`, `kind`, `label` /// Prompt for permission to use a media input (audio only) /// diff --git a/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/node.dart b/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/node.dart index 9560b63eba..1f3759f219 100644 --- a/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/node.dart +++ b/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/node.dart @@ -11,7 +11,8 @@ import 'worklet.dart'; // These functions are ignored because they have generic arguments: `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect_from_output_to_input`, `connect`, `connect`, `connect`, `set_onended`, `set_onended`, `set_onended`, `set_onended` // These types are ignored because they are not used by any `pub` functions: `AnalyserOptions`, `AudioBufferSourceOptions`, `AudioNodeOptions`, `BiquadFilterOptions`, `ChannelConfig`, `ChannelMergerOptions`, `ChannelSplitterOptions`, `ConstantSourceOptions`, `ConvolverOptions`, `DelayOptions`, `DynamicsCompressorOptions`, `GainOptions`, `IIRFilterOptions`, `MediaElementAudioSourceOptions`, `MediaStreamAudioSourceOptions`, `MediaStreamRenderer`, `MediaStreamTrackAudioSourceOptions`, `OscillatorOptions`, `PannerOptions`, `ScriptProcessorOptions`, `StereoPannerOptions`, `WaveShaperOptions` -// These functions are ignored: `channel_config`, `channel_count_mode`, `channel_count`, `channel_interpretation`, `clear_onprocessorerror`, `context`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_output`, `disconnect`, `number_of_inputs`, `number_of_outputs`, `registration`, `set_channel_count_mode`, `set_channel_count`, `set_channel_interpretation`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest_from_output`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `disconnect_dest`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror`, `set_onprocessorerror` +// These functions are ignored (category: IgnoreBecauseNotAllowedOwner): `channel_config`, `channel_count_mode`, `channel_count`, `channel_interpretation`, `clear_onprocessorerror`, `context`, `disconnect_dest_from_output_to_input`, `disconnect_dest_from_output`, `disconnect_dest`, `disconnect_output`, `disconnect`, `number_of_inputs`, `number_of_outputs`, `registration`, `set_channel_count_mode`, `set_channel_count`, `set_channel_interpretation`, `set_onprocessorerror` // Rust type: RustOpaqueMoi> abstract class AnalyserNode diff --git a/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/worklet.dart b/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/worklet.dart index 53a6cfd595..6b345cb70f 100644 --- a/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/worklet.dart +++ b/frb_example/integrate_third_party/lib/src/rust/third_party/web_audio_api/worklet.dart @@ -9,7 +9,7 @@ import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; // These functions are ignored because they have generic arguments: `new`, `process` // These types are ignored because they are not used by any `pub` functions: `AudioParamValues`, `AudioWorkletNodeOptions`, `AudioWorkletRenderer`, `Processor` -// These functions are ignored: `constructor`, `onmessage`, `port` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `constructor`, `onmessage`, `port` // Rust type: RustOpaqueMoi> abstract class AudioWorkletNode implements RustOpaqueInterface, AudioNode { diff --git a/frb_example/pure_dart/frb_generated.h b/frb_example/pure_dart/frb_generated.h index 76995660a5..f2a1de09c3 100644 --- a/frb_example/pure_dart/frb_generated.h +++ b/frb_example/pure_dart/frb_generated.h @@ -2343,6 +2343,15 @@ typedef struct wire_cst_list_StreamSink_i_32_Dco { int32_t len; } wire_cst_list_StreamSink_i_32_Dco; +typedef struct wire_cst_struct_with_dart_keyword_field_twin_rust_async { + int32_t class_; + int64_t interface; +} wire_cst_struct_with_dart_keyword_field_twin_rust_async; + +typedef struct wire_cst_struct_with_field_rename_twin_rust_async { + int32_t class_; +} wire_cst_struct_with_field_rename_twin_rust_async; + typedef struct wire_cst_struct_with_one_field_twin_rust_async { int32_t a; } wire_cst_struct_with_one_field_twin_rust_async; @@ -2365,6 +2374,15 @@ typedef struct wire_cst_tuple_struct_with_two_field_twin_rust_async { int32_t field1; } wire_cst_tuple_struct_with_two_field_twin_rust_async; +typedef struct wire_cst_struct_with_dart_keyword_field_twin_sync { + int32_t class_; + int64_t interface; +} wire_cst_struct_with_dart_keyword_field_twin_sync; + +typedef struct wire_cst_struct_with_field_rename_twin_sync { + int32_t class_; +} wire_cst_struct_with_field_rename_twin_sync; + typedef struct wire_cst_struct_with_one_field_twin_sync { int32_t a; } wire_cst_struct_with_one_field_twin_sync; @@ -2492,6 +2510,15 @@ typedef struct wire_cst_my_struct_containing_stream_sink_twin_normal { struct wire_cst_list_prim_u_8_strict *b; } wire_cst_my_struct_containing_stream_sink_twin_normal; +typedef struct wire_cst_struct_with_dart_keyword_field_twin_normal { + int32_t class_; + int64_t interface; +} wire_cst_struct_with_dart_keyword_field_twin_normal; + +typedef struct wire_cst_struct_with_field_rename_twin_normal { + int32_t class_; +} wire_cst_struct_with_field_rename_twin_normal; + typedef struct wire_cst_struct_with_one_field_twin_normal { int32_t a; } wire_cst_struct_with_one_field_twin_normal; @@ -3392,6 +3419,36 @@ void frbgen_frb_example_pure_dart_wire__crate__api__attribute__next_user_id_twin WireSyncRust2DartSse frbgen_frb_example_pure_dart_wire__crate__api__benchmark_misc__benchmark_void_semi_serialize(void); +void frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal(int64_t port_, + uint8_t *ptr_, + int32_t rust_vec_len_, + int32_t data_len_); + +void frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal(int64_t port_, + uint8_t *ptr_, + int32_t rust_vec_len_, + int32_t data_len_); + +void frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal(int64_t port_, + uint8_t *ptr_, + int32_t rust_vec_len_, + int32_t data_len_); + +void frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal(int64_t port_, + uint8_t *ptr_, + int32_t rust_vec_len_, + int32_t data_len_); + +void frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal(int64_t port_, + uint8_t *ptr_, + int32_t rust_vec_len_, + int32_t data_len_); + +void frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal(int64_t port_, + uint8_t *ptr_, + int32_t rust_vec_len_, + int32_t data_len_); + void frbgen_frb_example_pure_dart_wire__crate__api__chrono_type__datetime_local_twin_normal(int64_t port_, int64_t d); @@ -3455,6 +3512,11 @@ void frbgen_frb_example_pure_dart_wire__crate__api__constructor__constructor_tra WireSyncRust2DartDco frbgen_frb_example_pure_dart_wire__crate__api__constructor__constructor_translatable_sync_struct_twin_normal_new(void); +void frbgen_frb_example_pure_dart_wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer(int64_t port_, + uint8_t *ptr_, + int32_t rust_vec_len_, + int32_t data_len_); + void frbgen_frb_example_pure_dart_wire__crate__api__customization__check_init_done(int64_t port_); void frbgen_frb_example_pure_dart_wire__crate__api__customization__init_app(int64_t port_); @@ -3724,6 +3786,11 @@ void frbgen_frb_example_pure_dart_wire__crate__api__exception__stream_sink_throw void frbgen_frb_example_pure_dart_wire__crate__api__exception__throw_anyhow_twin_normal(int64_t port_); +WireSyncRust2DartDco frbgen_frb_example_pure_dart_wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new(struct wire_cst_list_prim_u_8_strict *a); + +void frbgen_frb_example_pure_dart_wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method(int64_t port_, + uintptr_t that); + void frbgen_frb_example_pure_dart_wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method(int64_t port_, struct wire_cst_simple_translatable_external_struct_with_method *that); @@ -12592,6 +12659,12 @@ void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__stream_twin_s int32_t rust_vec_len_, int32_t data_len_); +void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async(int64_t port_, + struct wire_cst_struct_with_dart_keyword_field_twin_rust_async *arg); + +void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async(int64_t port_, + struct wire_cst_struct_with_field_rename_twin_rust_async *arg); + void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async(int64_t port_, struct wire_cst_struct_with_one_field_twin_rust_async *arg); @@ -12607,6 +12680,16 @@ void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twi void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_two_field_twin_rust_async(int64_t port_, struct wire_cst_tuple_struct_with_two_field_twin_rust_async *arg); +void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_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__structure_twin_rust_async_sse__func_for_struct_with_field_rename_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__structure_twin_rust_async_sse__func_struct_with_one_field_twin_rust_async_sse(int64_t port_, uint8_t *ptr_, int32_t rust_vec_len_, @@ -12632,6 +12715,16 @@ void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twi int32_t rust_vec_len_, int32_t data_len_); +void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_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__structure_twin_sse__func_for_struct_with_field_rename_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__structure_twin_sse__func_struct_with_one_field_twin_sse(int64_t port_, uint8_t *ptr_, int32_t rust_vec_len_, @@ -12657,6 +12750,10 @@ void frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twi int32_t rust_vec_len_, int32_t data_len_); +WireSyncRust2DartDco frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync(struct wire_cst_struct_with_dart_keyword_field_twin_sync *arg); + +WireSyncRust2DartDco frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync(struct wire_cst_struct_with_field_rename_twin_sync *arg); + WireSyncRust2DartDco frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync(struct wire_cst_struct_with_one_field_twin_sync *arg); WireSyncRust2DartDco frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_two_field_twin_sync(struct wire_cst_struct_with_two_field_twin_sync *arg); @@ -12667,6 +12764,14 @@ WireSyncRust2DartDco frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manua WireSyncRust2DartDco frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync(struct wire_cst_tuple_struct_with_two_field_twin_sync *arg); +WireSyncRust2DartSse frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse(uint8_t *ptr_, + int32_t rust_vec_len_, + int32_t data_len_); + +WireSyncRust2DartSse frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse(uint8_t *ptr_, + int32_t rust_vec_len_, + int32_t data_len_); + WireSyncRust2DartSse frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_struct_with_one_field_twin_sync_sse(uint8_t *ptr_, int32_t rust_vec_len_, int32_t data_len_); @@ -13074,6 +13179,12 @@ void frbgen_frb_example_pure_dart_wire__crate__api__stream_misc__func_stream_rea void frbgen_frb_example_pure_dart_wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal(int64_t port_, struct wire_cst_list_prim_u_8_strict *sink); +void frbgen_frb_example_pure_dart_wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal(int64_t port_, + struct wire_cst_struct_with_dart_keyword_field_twin_normal *arg); + +void frbgen_frb_example_pure_dart_wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal(int64_t port_, + struct wire_cst_struct_with_field_rename_twin_normal *arg); + void frbgen_frb_example_pure_dart_wire__crate__api__structure__func_struct_with_one_field_twin_normal(int64_t port_, struct wire_cst_struct_with_one_field_twin_normal *arg); @@ -13785,6 +13896,10 @@ void frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flu void frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi(const void *ptr); +void frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod(const void *ptr); + +void frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod(const void *ptr); + void frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal(const void *ptr); void frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal(const void *ptr); @@ -14307,6 +14422,12 @@ struct wire_cst_struct_with_comments_twin_sync *frbgen_frb_example_pure_dart_cst struct wire_cst_struct_with_custom_name_method_twin_normal *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_custom_name_method_twin_normal(void); +struct wire_cst_struct_with_dart_keyword_field_twin_normal *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_normal(void); + +struct wire_cst_struct_with_dart_keyword_field_twin_rust_async *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_rust_async(void); + +struct wire_cst_struct_with_dart_keyword_field_twin_sync *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_sync(void); + struct wire_cst_struct_with_enum_twin_normal *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_enum_twin_normal(void); struct wire_cst_struct_with_enum_twin_rust_async *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_enum_twin_rust_async(void); @@ -14325,6 +14446,12 @@ struct wire_cst_struct_with_explicit_auto_opaque_field_twin_sync *frbgen_frb_exa struct wire_cst_struct_with_explicit_auto_opaque_field_twin_sync_moi *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync_moi(void); +struct wire_cst_struct_with_field_rename_twin_normal *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_normal(void); + +struct wire_cst_struct_with_field_rename_twin_rust_async *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_rust_async(void); + +struct wire_cst_struct_with_field_rename_twin_sync *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_sync(void); + struct wire_cst_struct_with_good_and_opaque_field_twin_moi *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_good_and_opaque_field_twin_moi(void); struct wire_cst_struct_with_good_and_opaque_field_twin_normal *frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_good_and_opaque_field_twin_normal(void); @@ -14931,6 +15058,9 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_comments_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_comments_twin_sync); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_custom_name_method_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_rust_async); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_sync); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_enum_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_enum_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_enum_twin_sync); @@ -14940,6 +15070,9 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_explicit_auto_opaque_field_twin_rust_async_moi); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync_moi); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_rust_async); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_sync); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_good_and_opaque_field_twin_moi); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_good_and_opaque_field_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_good_and_opaque_field_twin_rust_async); @@ -15314,6 +15447,7 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncMoi); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinRustAsync); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinRustAsyncSse); @@ -15516,6 +15650,7 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncMoi); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinRustAsync); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinRustAsyncSse); @@ -15569,6 +15704,12 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__attribute__handle_customized_struct_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__attribute__next_user_id_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__benchmark_misc__benchmark_void_semi_serialize); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__chrono_type__datetime_local_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__chrono_type__datetime_utc_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__chrono_type__duration_twin_normal); @@ -15594,6 +15735,7 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__constructor__ConstructorOpaqueSyncStructTwinNormal_set_one); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__constructor__constructor_translatable_struct_twin_normal_new); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__constructor__constructor_translatable_sync_struct_twin_normal_new); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__customization__check_init_done); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__customization__init_app); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__customization__my_init_one); @@ -15689,6 +15831,8 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__exception__some_struct_twin_normal_static_return_ok_custom_error_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__exception__stream_sink_throw_anyhow_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__exception__throw_anyhow_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__external_type_in_crate__call_new_module_system_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__external_type_in_crate__call_old_module_system_twin_normal); @@ -18074,26 +18218,36 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__stream_twin_sse__stream_sink_fixed_sized_primitive_array_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__stream_twin_sse__stream_sink_inside_struct_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__stream_twin_sse__stream_sink_inside_vec_twin_sse); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_two_field_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_zero_field_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_one_field_twin_rust_async); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_two_field_twin_rust_async); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_sse); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_struct_with_one_field_twin_rust_async_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_struct_with_two_field_twin_rust_async_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_struct_with_zero_field_twin_rust_async_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_tuple_struct_with_one_field_twin_rust_async_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_tuple_struct_with_two_field_twin_rust_async_sse); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_sse); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sse__func_struct_with_one_field_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sse__func_struct_with_two_field_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sse__func_struct_with_zero_field_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sse__func_tuple_struct_with_one_field_twin_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sse__func_tuple_struct_with_two_field_twin_sse); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_two_field_twin_sync); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_zero_field_twin_sync); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_one_field_twin_sync); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_struct_with_one_field_twin_sync_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_struct_with_two_field_twin_sync_sse); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_struct_with_zero_field_twin_sync_sse); @@ -18219,6 +18373,8 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__stream__stream_sink_inside_vec_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__stream_misc__func_stream_realistic_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal); + dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__structure__func_struct_with_one_field_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__structure__func_struct_with_two_field_twin_normal); dummy_var ^= ((int64_t) (void*) frbgen_frb_example_pure_dart_wire__crate__api__structure__func_struct_with_zero_field_twin_normal); diff --git a/frb_example/pure_dart/lib/src/rust/api/attribute.dart b/frb_example/pure_dart/lib/src/rust/api/attribute.dart index ec4c6bb1ec..e20ea28f85 100644 --- a/frb_example/pure_dart/lib/src/rust/api/attribute.dart +++ b/frb_example/pure_dart/lib/src/rust/api/attribute.dart @@ -10,7 +10,8 @@ import 'package:meta/meta.dart' as meta; part 'attribute.freezed.dart'; // These types are ignored because they are not used by any `pub` functions: `IgnoredStructTwinNormal`, `StructWithOnlyIgnoredMethodTwinNormal` -// These functions are ignored: `func_should_not_exist_in_dart_twin_normal`, `method_should_not_exist_in_dart_twin_normal`, `method_should_not_exist_in_dart_twin_normal` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `func_should_not_exist_in_dart_twin_normal`, `method_should_not_exist_in_dart_twin_normal` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `method_should_not_exist_in_dart_twin_normal` Future handleCustomizedStructTwinNormal( {required CustomizedTwinNormal val}) => diff --git a/frb_example/pure_dart/lib/src/rust/api/casted_primitive.dart b/frb_example/pure_dart/lib/src/rust/api/casted_primitive.dart new file mode 100644 index 0000000000..49f6249ef8 --- /dev/null +++ b/frb_example/pure_dart/lib/src/rust/api/casted_primitive.dart @@ -0,0 +1,67 @@ +// This file is automatically generated, so please do not edit it. +// Generated by `flutter_rust_bridge`@ 2.0.0-dev.38. + +// ignore_for_file: invalid_use_of_internal_member, unused_import, unnecessary_import + +import '../frb_generated.dart'; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; + +Future castedPrimitiveI64TwinNormal({required int arg}) => + RustLib.instance.api + .crateApiCastedPrimitiveCastedPrimitiveI64TwinNormal(arg: arg); + +Future castedPrimitiveU64TwinNormal({required int arg}) => + RustLib.instance.api + .crateApiCastedPrimitiveCastedPrimitiveU64TwinNormal(arg: arg); + +Future castedPrimitiveIsizeTwinNormal({required int arg}) => + RustLib.instance.api + .crateApiCastedPrimitiveCastedPrimitiveIsizeTwinNormal(arg: arg); + +Future castedPrimitiveUsizeTwinNormal({required int arg}) => + RustLib.instance.api + .crateApiCastedPrimitiveCastedPrimitiveUsizeTwinNormal(arg: arg); + +Future castedPrimitiveMultiArgTwinNormal( + {required int a, required int b, required int c, required BigInt d}) => + RustLib.instance.api + .crateApiCastedPrimitiveCastedPrimitiveMultiArgTwinNormal( + a: a, b: b, c: c, d: d); + +Future + functionForStructWithCastedPrimitiveTwinNormal( + {required StructWithCastedPrimitiveTwinNormal arg}) => + RustLib.instance.api + .crateApiCastedPrimitiveFunctionForStructWithCastedPrimitiveTwinNormal( + arg: arg); + +class StructWithCastedPrimitiveTwinNormal { + final int fieldI64; + final int fieldU64; + final int fieldI32; + final Uint8List fieldVecU8; + + const StructWithCastedPrimitiveTwinNormal({ + required this.fieldI64, + required this.fieldU64, + required this.fieldI32, + required this.fieldVecU8, + }); + + @override + int get hashCode => + fieldI64.hashCode ^ + fieldU64.hashCode ^ + fieldI32.hashCode ^ + fieldVecU8.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithCastedPrimitiveTwinNormal && + runtimeType == other.runtimeType && + fieldI64 == other.fieldI64 && + fieldU64 == other.fieldU64 && + fieldI32 == other.fieldI32 && + fieldVecU8 == other.fieldVecU8; +} diff --git a/frb_example/pure_dart/lib/src/rust/api/custom_ser_des.dart b/frb_example/pure_dart/lib/src/rust/api/custom_ser_des.dart new file mode 100644 index 0000000000..9c9e0b3d69 --- /dev/null +++ b/frb_example/pure_dart/lib/src/rust/api/custom_ser_des.dart @@ -0,0 +1,13 @@ +// This file is automatically generated, so please do not edit it. +// Generated by `flutter_rust_bridge`@ 2.0.0-dev.38. + +// ignore_for_file: invalid_use_of_internal_member, unused_import, unnecessary_import + +import '../frb_generated.dart'; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; + +// These types are ignored because they are not used by any `pub` functions: `MessageWithCustomSerializerTwinNormal` + +Future functionUsingTypeWithCustomSerializer({required int arg}) => + RustLib.instance.api + .crateApiCustomSerDesFunctionUsingTypeWithCustomSerializer(arg: arg); diff --git a/frb_example/pure_dart/lib/src/rust/api/external_impl.dart b/frb_example/pure_dart/lib/src/rust/api/external_impl.dart index 88d4c53891..ab8ff9db89 100644 --- a/frb_example/pure_dart/lib/src/rust/api/external_impl.dart +++ b/frb_example/pure_dart/lib/src/rust/api/external_impl.dart @@ -6,7 +6,15 @@ import '../frb_generated.dart'; import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; -// These functions are ignored: `new`, `simple_external_method` +// Rust type: RustOpaqueNom> +abstract class SimpleOpaqueExternalStructWithMethod + implements RustOpaqueInterface { + factory SimpleOpaqueExternalStructWithMethod({required String a}) => + RustLib.instance.api + .crateApiExternalImplSimpleOpaqueExternalStructWithMethodNew(a: a); + + Future simpleExternalMethod(); +} class SimpleTranslatableExternalStructWithMethod { final String a; diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async.dart index bfb60ca396..9ee6415fe3 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async.dart @@ -10,7 +10,8 @@ import 'package:meta/meta.dart' as meta; part 'attribute_twin_rust_async.freezed.dart'; // These types are ignored because they are not used by any `pub` functions: `IgnoredStructTwinRustAsync`, `StructWithOnlyIgnoredMethodTwinRustAsync` -// These functions are ignored: `func_should_not_exist_in_dart_twin_rust_async`, `method_should_not_exist_in_dart_twin_rust_async`, `method_should_not_exist_in_dart_twin_rust_async` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `func_should_not_exist_in_dart_twin_rust_async`, `method_should_not_exist_in_dart_twin_rust_async` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `method_should_not_exist_in_dart_twin_rust_async` Future handleCustomizedStructTwinRustAsync( {required CustomizedTwinRustAsync val}) => diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async_sse.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async_sse.dart index 8b4334e538..5f470a74b4 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async_sse.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async_sse.dart @@ -10,7 +10,8 @@ import 'package:meta/meta.dart' as meta; part 'attribute_twin_rust_async_sse.freezed.dart'; // These types are ignored because they are not used by any `pub` functions: `IgnoredStructTwinRustAsyncSse`, `StructWithOnlyIgnoredMethodTwinRustAsyncSse` -// These functions are ignored: `func_should_not_exist_in_dart_twin_rust_async_sse`, `method_should_not_exist_in_dart_twin_rust_async_sse`, `method_should_not_exist_in_dart_twin_rust_async_sse` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `func_should_not_exist_in_dart_twin_rust_async_sse`, `method_should_not_exist_in_dart_twin_rust_async_sse` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `method_should_not_exist_in_dart_twin_rust_async_sse` Future handleCustomizedStructTwinRustAsyncSse( {required CustomizedTwinRustAsyncSse val}) => diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sse.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sse.dart index e5262da6e6..a859ac4f8a 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sse.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sse.dart @@ -10,7 +10,8 @@ import 'package:meta/meta.dart' as meta; part 'attribute_twin_sse.freezed.dart'; // These types are ignored because they are not used by any `pub` functions: `IgnoredStructTwinSse`, `StructWithOnlyIgnoredMethodTwinSse` -// These functions are ignored: `func_should_not_exist_in_dart_twin_sse`, `method_should_not_exist_in_dart_twin_sse`, `method_should_not_exist_in_dart_twin_sse` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `func_should_not_exist_in_dart_twin_sse`, `method_should_not_exist_in_dart_twin_sse` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `method_should_not_exist_in_dart_twin_sse` Future handleCustomizedStructTwinSse({required CustomizedTwinSse val}) => RustLib.instance.api diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sync.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sync.dart index 76b145c22b..aa54d94265 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sync.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sync.dart @@ -10,7 +10,8 @@ import 'package:meta/meta.dart' as meta; part 'attribute_twin_sync.freezed.dart'; // These types are ignored because they are not used by any `pub` functions: `IgnoredStructTwinSync`, `StructWithOnlyIgnoredMethodTwinSync` -// These functions are ignored: `func_should_not_exist_in_dart_twin_sync`, `method_should_not_exist_in_dart_twin_sync`, `method_should_not_exist_in_dart_twin_sync` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `func_should_not_exist_in_dart_twin_sync`, `method_should_not_exist_in_dart_twin_sync` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `method_should_not_exist_in_dart_twin_sync` void handleCustomizedStructTwinSync({required CustomizedTwinSync val}) => RustLib.instance.api diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sync_sse.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sync_sse.dart index f1996264e2..e02d8b7714 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sync_sse.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/attribute_twin_sync_sse.dart @@ -10,7 +10,8 @@ import 'package:meta/meta.dart' as meta; part 'attribute_twin_sync_sse.freezed.dart'; // These types are ignored because they are not used by any `pub` functions: `IgnoredStructTwinSyncSse`, `StructWithOnlyIgnoredMethodTwinSyncSse` -// These functions are ignored: `func_should_not_exist_in_dart_twin_sync_sse`, `method_should_not_exist_in_dart_twin_sync_sse`, `method_should_not_exist_in_dart_twin_sync_sse` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `func_should_not_exist_in_dart_twin_sync_sse`, `method_should_not_exist_in_dart_twin_sync_sse` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `method_should_not_exist_in_dart_twin_sync_sse` void handleCustomizedStructTwinSyncSse({required CustomizedTwinSyncSse val}) => RustLib.instance.api diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async.dart index dc10bfb660..c12bed0826 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async.dart @@ -17,19 +17,19 @@ Future class MoreThanJustOneRawStringStructTwinRustAsync { final String regular; final String type; - final bool async; + final bool async_; final String another; const MoreThanJustOneRawStringStructTwinRustAsync({ required this.regular, required this.type, - required this.async, + required this.async_, required this.another, }); @override int get hashCode => - regular.hashCode ^ type.hashCode ^ async.hashCode ^ another.hashCode; + regular.hashCode ^ type.hashCode ^ async_.hashCode ^ another.hashCode; @override bool operator ==(Object other) => @@ -38,7 +38,7 @@ class MoreThanJustOneRawStringStructTwinRustAsync { runtimeType == other.runtimeType && regular == other.regular && type == other.type && - async == other.async && + async_ == other.async_ && another == other.another; } diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async_sse.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async_sse.dart index 4c8c4742c0..0f9e944111 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async_sse.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async_sse.dart @@ -17,19 +17,19 @@ Future class MoreThanJustOneRawStringStructTwinRustAsyncSse { final String regular; final String type; - final bool async; + final bool async_; final String another; const MoreThanJustOneRawStringStructTwinRustAsyncSse({ required this.regular, required this.type, - required this.async, + required this.async_, required this.another, }); @override int get hashCode => - regular.hashCode ^ type.hashCode ^ async.hashCode ^ another.hashCode; + regular.hashCode ^ type.hashCode ^ async_.hashCode ^ another.hashCode; @override bool operator ==(Object other) => @@ -38,7 +38,7 @@ class MoreThanJustOneRawStringStructTwinRustAsyncSse { runtimeType == other.runtimeType && regular == other.regular && type == other.type && - async == other.async && + async_ == other.async_ && another == other.another; } diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sse.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sse.dart index 7b51142ec8..81df216498 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sse.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sse.dart @@ -17,19 +17,19 @@ Future class MoreThanJustOneRawStringStructTwinSse { final String regular; final String type; - final bool async; + final bool async_; final String another; const MoreThanJustOneRawStringStructTwinSse({ required this.regular, required this.type, - required this.async, + required this.async_, required this.another, }); @override int get hashCode => - regular.hashCode ^ type.hashCode ^ async.hashCode ^ another.hashCode; + regular.hashCode ^ type.hashCode ^ async_.hashCode ^ another.hashCode; @override bool operator ==(Object other) => @@ -38,7 +38,7 @@ class MoreThanJustOneRawStringStructTwinSse { runtimeType == other.runtimeType && regular == other.regular && type == other.type && - async == other.async && + async_ == other.async_ && another == other.another; } diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sync.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sync.dart index bbc0a804f6..cf424756b3 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sync.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sync.dart @@ -17,19 +17,19 @@ MoreThanJustOneRawStringStructTwinSync class MoreThanJustOneRawStringStructTwinSync { final String regular; final String type; - final bool async; + final bool async_; final String another; const MoreThanJustOneRawStringStructTwinSync({ required this.regular, required this.type, - required this.async, + required this.async_, required this.another, }); @override int get hashCode => - regular.hashCode ^ type.hashCode ^ async.hashCode ^ another.hashCode; + regular.hashCode ^ type.hashCode ^ async_.hashCode ^ another.hashCode; @override bool operator ==(Object other) => @@ -38,7 +38,7 @@ class MoreThanJustOneRawStringStructTwinSync { runtimeType == other.runtimeType && regular == other.regular && type == other.type && - async == other.async && + async_ == other.async_ && another == other.another; } diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sync_sse.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sync_sse.dart index 8bc3f33bdc..940aa461b7 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sync_sse.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/raw_string_twin_sync_sse.dart @@ -17,19 +17,19 @@ MoreThanJustOneRawStringStructTwinSyncSse class MoreThanJustOneRawStringStructTwinSyncSse { final String regular; final String type; - final bool async; + final bool async_; final String another; const MoreThanJustOneRawStringStructTwinSyncSse({ required this.regular, required this.type, - required this.async, + required this.async_, required this.another, }); @override int get hashCode => - regular.hashCode ^ type.hashCode ^ async.hashCode ^ another.hashCode; + regular.hashCode ^ type.hashCode ^ async_.hashCode ^ another.hashCode; @override bool operator ==(Object other) => @@ -38,7 +38,7 @@ class MoreThanJustOneRawStringStructTwinSyncSse { runtimeType == other.runtimeType && regular == other.regular && type == other.type && - async == other.async && + async_ == other.async_ && another == other.another; } diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/rust_auto_opaque_twin_moi.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/rust_auto_opaque_twin_moi.dart index b350590953..bdbc373598 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/rust_auto_opaque_twin_moi.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/rust_auto_opaque_twin_moi.dart @@ -8,7 +8,7 @@ import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; import 'package:freezed_annotation/freezed_annotation.dart' hide protected; part 'rust_auto_opaque_twin_moi.freezed.dart'; -// These functions are ignored: `f` +// These functions are ignored (category: IgnoreBecauseNotAllowedOwner): `f` Future rustAutoOpaqueArgOwnTwinMoi( {required NonCloneSimpleTwinMoi arg, required int expect}) => diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_rust_async.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_rust_async.dart index acf711226b..3e61eb324d 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_rust_async.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_rust_async.dart @@ -38,6 +38,59 @@ Future< .crateApiPseudoManualStructureTwinRustAsyncFuncTupleStructWithTwoFieldTwinRustAsync( arg: arg); +Future< + StructWithFieldRenameTwinRustAsync> funcForStructWithFieldRenameTwinRustAsync( + {required StructWithFieldRenameTwinRustAsync arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithFieldRenameTwinRustAsync( + arg: arg); + +Future + funcForStructWithDartKeywordFieldTwinRustAsync( + {required StructWithDartKeywordFieldTwinRustAsync arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithDartKeywordFieldTwinRustAsync( + arg: arg); + +class StructWithDartKeywordFieldTwinRustAsync { + final int class_; + final PlatformInt64 interface_; + + const StructWithDartKeywordFieldTwinRustAsync({ + required this.class_, + required this.interface_, + }); + + @override + int get hashCode => class_.hashCode ^ interface_.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithDartKeywordFieldTwinRustAsync && + runtimeType == other.runtimeType && + class_ == other.class_ && + interface_ == other.interface_; +} + +class StructWithFieldRenameTwinRustAsync { + final int renamed_field; + + const StructWithFieldRenameTwinRustAsync({ + required this.renamed_field, + }); + + @override + int get hashCode => renamed_field.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithFieldRenameTwinRustAsync && + runtimeType == other.runtimeType && + renamed_field == other.renamed_field; +} + class StructWithOneFieldTwinRustAsync { final int a; diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_rust_async_sse.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_rust_async_sse.dart index 3b001e1bbe..6d2c0805e0 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_rust_async_sse.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_rust_async_sse.dart @@ -41,6 +41,59 @@ Future .crateApiPseudoManualStructureTwinRustAsyncSseFuncTupleStructWithTwoFieldTwinRustAsyncSse( arg: arg); +Future + funcForStructWithFieldRenameTwinRustAsyncSse( + {required StructWithFieldRenameTwinRustAsyncSse arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinRustAsyncSseFuncForStructWithFieldRenameTwinRustAsyncSse( + arg: arg); + +Future + funcForStructWithDartKeywordFieldTwinRustAsyncSse( + {required StructWithDartKeywordFieldTwinRustAsyncSse arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinRustAsyncSseFuncForStructWithDartKeywordFieldTwinRustAsyncSse( + arg: arg); + +class StructWithDartKeywordFieldTwinRustAsyncSse { + final int class_; + final PlatformInt64 interface_; + + const StructWithDartKeywordFieldTwinRustAsyncSse({ + required this.class_, + required this.interface_, + }); + + @override + int get hashCode => class_.hashCode ^ interface_.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithDartKeywordFieldTwinRustAsyncSse && + runtimeType == other.runtimeType && + class_ == other.class_ && + interface_ == other.interface_; +} + +class StructWithFieldRenameTwinRustAsyncSse { + final int renamed_field; + + const StructWithFieldRenameTwinRustAsyncSse({ + required this.renamed_field, + }); + + @override + int get hashCode => renamed_field.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithFieldRenameTwinRustAsyncSse && + runtimeType == other.runtimeType && + renamed_field == other.renamed_field; +} + class StructWithOneFieldTwinRustAsyncSse { final int a; diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sse.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sse.dart index cd22e84f2f..fef63d3336 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sse.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sse.dart @@ -36,6 +36,58 @@ Future funcTupleStructWithTwoFieldTwinSse( .crateApiPseudoManualStructureTwinSseFuncTupleStructWithTwoFieldTwinSse( arg: arg); +Future funcForStructWithFieldRenameTwinSse( + {required StructWithFieldRenameTwinSse arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinSseFuncForStructWithFieldRenameTwinSse( + arg: arg); + +Future< + StructWithDartKeywordFieldTwinSse> funcForStructWithDartKeywordFieldTwinSse( + {required StructWithDartKeywordFieldTwinSse arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinSseFuncForStructWithDartKeywordFieldTwinSse( + arg: arg); + +class StructWithDartKeywordFieldTwinSse { + final int class_; + final PlatformInt64 interface_; + + const StructWithDartKeywordFieldTwinSse({ + required this.class_, + required this.interface_, + }); + + @override + int get hashCode => class_.hashCode ^ interface_.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithDartKeywordFieldTwinSse && + runtimeType == other.runtimeType && + class_ == other.class_ && + interface_ == other.interface_; +} + +class StructWithFieldRenameTwinSse { + final int renamed_field; + + const StructWithFieldRenameTwinSse({ + required this.renamed_field, + }); + + @override + int get hashCode => renamed_field.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithFieldRenameTwinSse && + runtimeType == other.runtimeType && + renamed_field == other.renamed_field; +} + class StructWithOneFieldTwinSse { final int a; diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sync.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sync.dart index 15b4c73266..ab90a6c7fc 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sync.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sync.dart @@ -36,6 +36,57 @@ TupleStructWithTwoFieldTwinSync funcTupleStructWithTwoFieldTwinSync( .crateApiPseudoManualStructureTwinSyncFuncTupleStructWithTwoFieldTwinSync( arg: arg); +StructWithFieldRenameTwinSync funcForStructWithFieldRenameTwinSync( + {required StructWithFieldRenameTwinSync arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinSyncFuncForStructWithFieldRenameTwinSync( + arg: arg); + +StructWithDartKeywordFieldTwinSync funcForStructWithDartKeywordFieldTwinSync( + {required StructWithDartKeywordFieldTwinSync arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinSyncFuncForStructWithDartKeywordFieldTwinSync( + arg: arg); + +class StructWithDartKeywordFieldTwinSync { + final int class_; + final PlatformInt64 interface_; + + const StructWithDartKeywordFieldTwinSync({ + required this.class_, + required this.interface_, + }); + + @override + int get hashCode => class_.hashCode ^ interface_.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithDartKeywordFieldTwinSync && + runtimeType == other.runtimeType && + class_ == other.class_ && + interface_ == other.interface_; +} + +class StructWithFieldRenameTwinSync { + final int renamed_field; + + const StructWithFieldRenameTwinSync({ + required this.renamed_field, + }); + + @override + int get hashCode => renamed_field.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithFieldRenameTwinSync && + runtimeType == other.runtimeType && + renamed_field == other.renamed_field; +} + class StructWithOneFieldTwinSync { final int a; diff --git a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sync_sse.dart b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sync_sse.dart index b3e282c7e3..73c5308271 100644 --- a/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sync_sse.dart +++ b/frb_example/pure_dart/lib/src/rust/api/pseudo_manual/structure_twin_sync_sse.dart @@ -36,6 +36,57 @@ TupleStructWithTwoFieldTwinSyncSse funcTupleStructWithTwoFieldTwinSyncSse( .crateApiPseudoManualStructureTwinSyncSseFuncTupleStructWithTwoFieldTwinSyncSse( arg: arg); +StructWithFieldRenameTwinSyncSse funcForStructWithFieldRenameTwinSyncSse( + {required StructWithFieldRenameTwinSyncSse arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinSyncSseFuncForStructWithFieldRenameTwinSyncSse( + arg: arg); + +StructWithDartKeywordFieldTwinSyncSse funcForStructWithDartKeywordFieldTwinSyncSse( + {required StructWithDartKeywordFieldTwinSyncSse arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinSyncSseFuncForStructWithDartKeywordFieldTwinSyncSse( + arg: arg); + +class StructWithDartKeywordFieldTwinSyncSse { + final int class_; + final PlatformInt64 interface_; + + const StructWithDartKeywordFieldTwinSyncSse({ + required this.class_, + required this.interface_, + }); + + @override + int get hashCode => class_.hashCode ^ interface_.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithDartKeywordFieldTwinSyncSse && + runtimeType == other.runtimeType && + class_ == other.class_ && + interface_ == other.interface_; +} + +class StructWithFieldRenameTwinSyncSse { + final int renamed_field; + + const StructWithFieldRenameTwinSyncSse({ + required this.renamed_field, + }); + + @override + int get hashCode => renamed_field.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithFieldRenameTwinSyncSse && + runtimeType == other.runtimeType && + renamed_field == other.renamed_field; +} + class StructWithOneFieldTwinSyncSse { final int a; diff --git a/frb_example/pure_dart/lib/src/rust/api/raw_string.dart b/frb_example/pure_dart/lib/src/rust/api/raw_string.dart index 35fe807e52..efafd4bfb6 100644 --- a/frb_example/pure_dart/lib/src/rust/api/raw_string.dart +++ b/frb_example/pure_dart/lib/src/rust/api/raw_string.dart @@ -16,19 +16,19 @@ Future class MoreThanJustOneRawStringStructTwinNormal { final String regular; final String type; - final bool async; + final bool async_; final String another; const MoreThanJustOneRawStringStructTwinNormal({ required this.regular, required this.type, - required this.async, + required this.async_, required this.another, }); @override int get hashCode => - regular.hashCode ^ type.hashCode ^ async.hashCode ^ another.hashCode; + regular.hashCode ^ type.hashCode ^ async_.hashCode ^ another.hashCode; @override bool operator ==(Object other) => @@ -37,7 +37,7 @@ class MoreThanJustOneRawStringStructTwinNormal { runtimeType == other.runtimeType && regular == other.regular && type == other.type && - async == other.async && + async_ == other.async_ && another == other.another; } diff --git a/frb_example/pure_dart/lib/src/rust/api/structure.dart b/frb_example/pure_dart/lib/src/rust/api/structure.dart index 0803ab4251..b025b9a653 100644 --- a/frb_example/pure_dart/lib/src/rust/api/structure.dart +++ b/frb_example/pure_dart/lib/src/rust/api/structure.dart @@ -31,6 +31,57 @@ Future funcTupleStructWithTwoFieldTwinNormal( RustLib.instance.api .crateApiStructureFuncTupleStructWithTwoFieldTwinNormal(arg: arg); +Future funcForStructWithFieldRenameTwinNormal( + {required StructWithFieldRenameTwinNormal arg}) => + RustLib.instance.api + .crateApiStructureFuncForStructWithFieldRenameTwinNormal(arg: arg); + +Future + funcForStructWithDartKeywordFieldTwinNormal( + {required StructWithDartKeywordFieldTwinNormal arg}) => + RustLib.instance.api + .crateApiStructureFuncForStructWithDartKeywordFieldTwinNormal( + arg: arg); + +class StructWithDartKeywordFieldTwinNormal { + final int class_; + final PlatformInt64 interface_; + + const StructWithDartKeywordFieldTwinNormal({ + required this.class_, + required this.interface_, + }); + + @override + int get hashCode => class_.hashCode ^ interface_.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithDartKeywordFieldTwinNormal && + runtimeType == other.runtimeType && + class_ == other.class_ && + interface_ == other.interface_; +} + +class StructWithFieldRenameTwinNormal { + final int renamed_field; + + const StructWithFieldRenameTwinNormal({ + required this.renamed_field, + }); + + @override + int get hashCode => renamed_field.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithFieldRenameTwinNormal && + runtimeType == other.runtimeType && + renamed_field == other.renamed_field; +} + class StructWithOneFieldTwinNormal { final int a; diff --git a/frb_example/pure_dart/lib/src/rust/auxiliary/sample_types.dart b/frb_example/pure_dart/lib/src/rust/auxiliary/sample_types.dart index aaa36f603a..2610dda2fd 100644 --- a/frb_example/pure_dart/lib/src/rust/auxiliary/sample_types.dart +++ b/frb_example/pure_dart/lib/src/rust/auxiliary/sample_types.dart @@ -7,8 +7,8 @@ import '../frb_generated.dart'; import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; enum MyEnum { - False, - True, + false_, + true_, ; } 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 46961daa30..a159f92828 100644 --- a/frb_example/pure_dart/lib/src/rust/frb_generated.dart +++ b/frb_example/pure_dart/lib/src/rust/frb_generated.dart @@ -13,9 +13,11 @@ import 'api/async_misc.dart'; import 'api/async_spawn.dart'; import 'api/attribute.dart'; import 'api/benchmark_misc.dart'; +import 'api/casted_primitive.dart'; import 'api/chrono_type.dart'; import 'api/comment.dart'; import 'api/constructor.dart'; +import 'api/custom_ser_des.dart'; import 'api/customization.dart'; import 'api/dart_code.dart'; import 'api/dart_dynamic.dart'; @@ -322,7 +324,7 @@ class RustLib extends BaseEntrypoint { String get codegenVersion => '2.0.0-dev.38'; @override - int get rustContentHash => -1702726439; + int get rustContentHash => -2031266698; static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig( @@ -386,6 +388,25 @@ abstract class RustLibApi extends BaseApi { void crateApiBenchmarkMiscBenchmarkVoidSemiSerialize(); + Future crateApiCastedPrimitiveCastedPrimitiveI64TwinNormal( + {required int arg}); + + Future crateApiCastedPrimitiveCastedPrimitiveIsizeTwinNormal( + {required int arg}); + + Future crateApiCastedPrimitiveCastedPrimitiveMultiArgTwinNormal( + {required int a, required int b, required int c, required BigInt d}); + + Future crateApiCastedPrimitiveCastedPrimitiveU64TwinNormal( + {required int arg}); + + Future crateApiCastedPrimitiveCastedPrimitiveUsizeTwinNormal( + {required int arg}); + + Future + crateApiCastedPrimitiveFunctionForStructWithCastedPrimitiveTwinNormal( + {required StructWithCastedPrimitiveTwinNormal arg}); + Future crateApiChronoTypeDatetimeLocalTwinNormal( {required DateTime d}); @@ -459,6 +480,9 @@ abstract class RustLibApi extends BaseApi { ConstructorTranslatableSyncStructTwinNormal crateApiConstructorConstructorTranslatableSyncStructTwinNormalNew(); + Future crateApiCustomSerDesFunctionUsingTypeWithCustomSerializer( + {required int arg}); + Future crateApiCustomizationCheckInitDone(); Future crateApiCustomizationInitApp(); @@ -742,6 +766,14 @@ abstract class RustLibApi extends BaseApi { Future crateApiExceptionThrowAnyhowTwinNormal(); + SimpleOpaqueExternalStructWithMethod + crateApiExternalImplSimpleOpaqueExternalStructWithMethodNew( + {required String a}); + + Future + crateApiExternalImplSimpleOpaqueExternalStructWithMethodSimpleExternalMethod( + {required SimpleOpaqueExternalStructWithMethod that}); + Future crateApiExternalImplSimpleTranslatableExternalStructWithMethodSimpleExternalMethod( {required SimpleTranslatableExternalStructWithMethod that}); @@ -9391,6 +9423,14 @@ abstract class RustLibApi extends BaseApi { Future crateApiPseudoManualStreamTwinSseStreamSinkInsideVecTwinSse( {required List> arg}); + Future + crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithDartKeywordFieldTwinRustAsync( + {required StructWithDartKeywordFieldTwinRustAsync arg}); + + Future + crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithFieldRenameTwinRustAsync( + {required StructWithFieldRenameTwinRustAsync arg}); + Future crateApiPseudoManualStructureTwinRustAsyncFuncStructWithOneFieldTwinRustAsync( {required StructWithOneFieldTwinRustAsync arg}); @@ -9411,6 +9451,14 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualStructureTwinRustAsyncFuncTupleStructWithTwoFieldTwinRustAsync( {required TupleStructWithTwoFieldTwinRustAsync arg}); + Future + crateApiPseudoManualStructureTwinRustAsyncSseFuncForStructWithDartKeywordFieldTwinRustAsyncSse( + {required StructWithDartKeywordFieldTwinRustAsyncSse arg}); + + Future + crateApiPseudoManualStructureTwinRustAsyncSseFuncForStructWithFieldRenameTwinRustAsyncSse( + {required StructWithFieldRenameTwinRustAsyncSse arg}); + Future crateApiPseudoManualStructureTwinRustAsyncSseFuncStructWithOneFieldTwinRustAsyncSse( {required StructWithOneFieldTwinRustAsyncSse arg}); @@ -9431,6 +9479,14 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualStructureTwinRustAsyncSseFuncTupleStructWithTwoFieldTwinRustAsyncSse( {required TupleStructWithTwoFieldTwinRustAsyncSse arg}); + Future + crateApiPseudoManualStructureTwinSseFuncForStructWithDartKeywordFieldTwinSse( + {required StructWithDartKeywordFieldTwinSse arg}); + + Future + crateApiPseudoManualStructureTwinSseFuncForStructWithFieldRenameTwinSse( + {required StructWithFieldRenameTwinSse arg}); + Future crateApiPseudoManualStructureTwinSseFuncStructWithOneFieldTwinSse( {required StructWithOneFieldTwinSse arg}); @@ -9451,6 +9507,14 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualStructureTwinSseFuncTupleStructWithTwoFieldTwinSse( {required TupleStructWithTwoFieldTwinSse arg}); + StructWithDartKeywordFieldTwinSync + crateApiPseudoManualStructureTwinSyncFuncForStructWithDartKeywordFieldTwinSync( + {required StructWithDartKeywordFieldTwinSync arg}); + + StructWithFieldRenameTwinSync + crateApiPseudoManualStructureTwinSyncFuncForStructWithFieldRenameTwinSync( + {required StructWithFieldRenameTwinSync arg}); + StructWithOneFieldTwinSync crateApiPseudoManualStructureTwinSyncFuncStructWithOneFieldTwinSync( {required StructWithOneFieldTwinSync arg}); @@ -9471,6 +9535,14 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualStructureTwinSyncFuncTupleStructWithTwoFieldTwinSync( {required TupleStructWithTwoFieldTwinSync arg}); + StructWithDartKeywordFieldTwinSyncSse + crateApiPseudoManualStructureTwinSyncSseFuncForStructWithDartKeywordFieldTwinSyncSse( + {required StructWithDartKeywordFieldTwinSyncSse arg}); + + StructWithFieldRenameTwinSyncSse + crateApiPseudoManualStructureTwinSyncSseFuncForStructWithFieldRenameTwinSyncSse( + {required StructWithFieldRenameTwinSyncSse arg}); + StructWithOneFieldTwinSyncSse crateApiPseudoManualStructureTwinSyncSseFuncStructWithOneFieldTwinSyncSse( {required StructWithOneFieldTwinSyncSse arg}); @@ -9887,6 +9959,14 @@ abstract class RustLibApi extends BaseApi { Future> crateApiStreamMiscStreamSinkDartAsyncTwinNormal(); + Future + crateApiStructureFuncForStructWithDartKeywordFieldTwinNormal( + {required StructWithDartKeywordFieldTwinNormal arg}); + + Future + crateApiStructureFuncForStructWithFieldRenameTwinNormal( + {required StructWithFieldRenameTwinNormal arg}); + Future crateApiStructureFuncStructWithOneFieldTwinNormal( {required StructWithOneFieldTwinNormal arg}); @@ -11443,6 +11523,15 @@ abstract class RustLibApi extends BaseApi { CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_OpaqueTwoTwinSyncSseMoiPtr; + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_SimpleOpaqueExternalStructWithMethod; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethod; + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethodPtr; + RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_StaticGetterOnlyTwinNormal; @@ -12244,6 +12333,189 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + Future crateApiCastedPrimitiveCastedPrimitiveI64TwinNormal( + {required int arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_CastedPrimitive_i_64(arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_CastedPrimitive_i_64, + decodeErrorData: null, + ), + constMeta: kCrateApiCastedPrimitiveCastedPrimitiveI64TwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveCastedPrimitiveI64TwinNormalConstMeta => + const TaskConstMeta( + debugName: "casted_primitive_i64_twin_normal", + argNames: ["arg"], + ); + + @override + Future crateApiCastedPrimitiveCastedPrimitiveIsizeTwinNormal( + {required int arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_CastedPrimitive_isize(arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_CastedPrimitive_isize, + decodeErrorData: null, + ), + constMeta: + kCrateApiCastedPrimitiveCastedPrimitiveIsizeTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveCastedPrimitiveIsizeTwinNormalConstMeta => + const TaskConstMeta( + debugName: "casted_primitive_isize_twin_normal", + argNames: ["arg"], + ); + + @override + Future crateApiCastedPrimitiveCastedPrimitiveMultiArgTwinNormal( + {required int a, required int b, required int c, required BigInt d}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_i_32(a, serializer); + sse_encode_CastedPrimitive_i_64(b, serializer); + sse_encode_CastedPrimitive_usize(c, serializer); + sse_encode_I128(d, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: + kCrateApiCastedPrimitiveCastedPrimitiveMultiArgTwinNormalConstMeta, + argValues: [a, b, c, d], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveCastedPrimitiveMultiArgTwinNormalConstMeta => + const TaskConstMeta( + debugName: "casted_primitive_multi_arg_twin_normal", + argNames: ["a", "b", "c", "d"], + ); + + @override + Future crateApiCastedPrimitiveCastedPrimitiveU64TwinNormal( + {required int arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_CastedPrimitive_u_64(arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_CastedPrimitive_u_64, + decodeErrorData: null, + ), + constMeta: kCrateApiCastedPrimitiveCastedPrimitiveU64TwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveCastedPrimitiveU64TwinNormalConstMeta => + const TaskConstMeta( + debugName: "casted_primitive_u64_twin_normal", + argNames: ["arg"], + ); + + @override + Future crateApiCastedPrimitiveCastedPrimitiveUsizeTwinNormal( + {required int arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_CastedPrimitive_usize(arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_CastedPrimitive_usize, + decodeErrorData: null, + ), + constMeta: + kCrateApiCastedPrimitiveCastedPrimitiveUsizeTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveCastedPrimitiveUsizeTwinNormalConstMeta => + const TaskConstMeta( + debugName: "casted_primitive_usize_twin_normal", + argNames: ["arg"], + ); + + @override + Future + crateApiCastedPrimitiveFunctionForStructWithCastedPrimitiveTwinNormal( + {required StructWithCastedPrimitiveTwinNormal arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_casted_primitive_twin_normal( + arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_struct_with_casted_primitive_twin_normal, + decodeErrorData: null, + ), + constMeta: + kCrateApiCastedPrimitiveFunctionForStructWithCastedPrimitiveTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveFunctionForStructWithCastedPrimitiveTwinNormalConstMeta => + const TaskConstMeta( + debugName: "function_for_struct_with_casted_primitive_twin_normal", + argNames: ["arg"], + ); + @override Future crateApiChronoTypeDatetimeLocalTwinNormal( {required DateTime d}) { @@ -12930,6 +13202,38 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + Future crateApiCustomSerDesFunctionUsingTypeWithCustomSerializer( + {required int arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: + sse_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal, + decodeErrorData: null, + ), + constMeta: + kCrateApiCustomSerDesFunctionUsingTypeWithCustomSerializerConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCustomSerDesFunctionUsingTypeWithCustomSerializerConstMeta => + const TaskConstMeta( + debugName: "function_using_type_with_custom_serializer", + argNames: ["arg"], + ); + @override Future crateApiCustomizationCheckInitDone() { return handler.executeNormal(NormalTask( @@ -15516,6 +15820,68 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + SimpleOpaqueExternalStructWithMethod + crateApiExternalImplSimpleOpaqueExternalStructWithMethodNew( + {required String a}) { + return handler.executeSync(SyncTask( + callFfi: () { + var arg0 = cst_encode_String(a); + return wire + .wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new( + arg0); + }, + codec: DcoCodec( + decodeSuccessData: + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod, + decodeErrorData: null, + ), + constMeta: + kCrateApiExternalImplSimpleOpaqueExternalStructWithMethodNewConstMeta, + argValues: [a], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiExternalImplSimpleOpaqueExternalStructWithMethodNewConstMeta => + const TaskConstMeta( + debugName: "SimpleOpaqueExternalStructWithMethod_new", + argNames: ["a"], + ); + + @override + Future + crateApiExternalImplSimpleOpaqueExternalStructWithMethodSimpleExternalMethod( + {required SimpleOpaqueExternalStructWithMethod that}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + that); + return wire + .wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method( + port_, arg0); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_String, + decodeErrorData: null, + ), + constMeta: + kCrateApiExternalImplSimpleOpaqueExternalStructWithMethodSimpleExternalMethodConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiExternalImplSimpleOpaqueExternalStructWithMethodSimpleExternalMethodConstMeta => + const TaskConstMeta( + debugName: + "SimpleOpaqueExternalStructWithMethod_simple_external_method", + argNames: ["that"], + ); + @override Future crateApiExternalImplSimpleTranslatableExternalStructWithMethodSimpleExternalMethod( @@ -87862,6 +88228,70 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["arg"], ); + @override + Future + crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithDartKeywordFieldTwinRustAsync( + {required StructWithDartKeywordFieldTwinRustAsync arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + var arg0 = + cst_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + arg); + return wire + .wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async( + port_, arg0); + }, + codec: DcoCodec( + decodeSuccessData: + dco_decode_struct_with_dart_keyword_field_twin_rust_async, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinRustAsyncFuncForStructWithDartKeywordFieldTwinRustAsyncConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinRustAsyncFuncForStructWithDartKeywordFieldTwinRustAsyncConstMeta => + const TaskConstMeta( + debugName: + "func_for_struct_with_dart_keyword_field_twin_rust_async", + argNames: ["arg"], + ); + + @override + Future + crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithFieldRenameTwinRustAsync( + {required StructWithFieldRenameTwinRustAsync arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + var arg0 = + cst_encode_box_autoadd_struct_with_field_rename_twin_rust_async( + arg); + return wire + .wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async( + port_, arg0); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_struct_with_field_rename_twin_rust_async, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinRustAsyncFuncForStructWithFieldRenameTwinRustAsyncConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinRustAsyncFuncForStructWithFieldRenameTwinRustAsyncConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_field_rename_twin_rust_async", + argNames: ["arg"], + ); + @override Future crateApiPseudoManualStructureTwinRustAsyncFuncStructWithOneFieldTwinRustAsync( @@ -88016,6 +88446,73 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["arg"], ); + @override + Future + crateApiPseudoManualStructureTwinRustAsyncSseFuncForStructWithDartKeywordFieldTwinRustAsyncSse( + {required StructWithDartKeywordFieldTwinRustAsyncSse arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async_sse( + arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_sse( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: + sse_decode_struct_with_dart_keyword_field_twin_rust_async_sse, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinRustAsyncSseFuncForStructWithDartKeywordFieldTwinRustAsyncSseConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinRustAsyncSseFuncForStructWithDartKeywordFieldTwinRustAsyncSseConstMeta => + const TaskConstMeta( + debugName: + "func_for_struct_with_dart_keyword_field_twin_rust_async_sse", + argNames: ["arg"], + ); + + @override + Future + crateApiPseudoManualStructureTwinRustAsyncSseFuncForStructWithFieldRenameTwinRustAsyncSse( + {required StructWithFieldRenameTwinRustAsyncSse arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_field_rename_twin_rust_async_sse( + arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_sse( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: + sse_decode_struct_with_field_rename_twin_rust_async_sse, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinRustAsyncSseFuncForStructWithFieldRenameTwinRustAsyncSseConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinRustAsyncSseFuncForStructWithFieldRenameTwinRustAsyncSseConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_field_rename_twin_rust_async_sse", + argNames: ["arg"], + ); + @override Future crateApiPseudoManualStructureTwinRustAsyncSseFuncStructWithOneFieldTwinRustAsyncSse( @@ -88179,6 +88676,70 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["arg"], ); + @override + Future + crateApiPseudoManualStructureTwinSseFuncForStructWithDartKeywordFieldTwinSse( + {required StructWithDartKeywordFieldTwinSse arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sse( + arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_sse( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_struct_with_dart_keyword_field_twin_sse, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinSseFuncForStructWithDartKeywordFieldTwinSseConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinSseFuncForStructWithDartKeywordFieldTwinSseConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_dart_keyword_field_twin_sse", + argNames: ["arg"], + ); + + @override + Future + crateApiPseudoManualStructureTwinSseFuncForStructWithFieldRenameTwinSse( + {required StructWithFieldRenameTwinSse arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_field_rename_twin_sse( + arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_twin_sse( + port_, raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_struct_with_field_rename_twin_sse, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinSseFuncForStructWithFieldRenameTwinSseConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinSseFuncForStructWithFieldRenameTwinSseConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_field_rename_twin_sse", + argNames: ["arg"], + ); + @override Future crateApiPseudoManualStructureTwinSseFuncStructWithOneFieldTwinSse( @@ -88336,6 +88897,67 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["arg"], ); + @override + StructWithDartKeywordFieldTwinSync + crateApiPseudoManualStructureTwinSyncFuncForStructWithDartKeywordFieldTwinSync( + {required StructWithDartKeywordFieldTwinSync arg}) { + return handler.executeSync(SyncTask( + callFfi: () { + var arg0 = + cst_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + arg); + return wire + .wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync( + arg0); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_struct_with_dart_keyword_field_twin_sync, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinSyncFuncForStructWithDartKeywordFieldTwinSyncConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinSyncFuncForStructWithDartKeywordFieldTwinSyncConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_dart_keyword_field_twin_sync", + argNames: ["arg"], + ); + + @override + StructWithFieldRenameTwinSync + crateApiPseudoManualStructureTwinSyncFuncForStructWithFieldRenameTwinSync( + {required StructWithFieldRenameTwinSync arg}) { + return handler.executeSync(SyncTask( + callFfi: () { + var arg0 = + cst_encode_box_autoadd_struct_with_field_rename_twin_sync(arg); + return wire + .wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync( + arg0); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_struct_with_field_rename_twin_sync, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinSyncFuncForStructWithFieldRenameTwinSyncConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinSyncFuncForStructWithFieldRenameTwinSyncConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_field_rename_twin_sync", + argNames: ["arg"], + ); + @override StructWithOneFieldTwinSync crateApiPseudoManualStructureTwinSyncFuncStructWithOneFieldTwinSync( @@ -88483,6 +89105,71 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["arg"], ); + @override + StructWithDartKeywordFieldTwinSyncSse + crateApiPseudoManualStructureTwinSyncSseFuncForStructWithDartKeywordFieldTwinSyncSse( + {required StructWithDartKeywordFieldTwinSyncSse arg}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync_sse( + arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse( + raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: + sse_decode_struct_with_dart_keyword_field_twin_sync_sse, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinSyncSseFuncForStructWithDartKeywordFieldTwinSyncSseConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinSyncSseFuncForStructWithDartKeywordFieldTwinSyncSseConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_dart_keyword_field_twin_sync_sse", + argNames: ["arg"], + ); + + @override + StructWithFieldRenameTwinSyncSse + crateApiPseudoManualStructureTwinSyncSseFuncForStructWithFieldRenameTwinSyncSse( + {required StructWithFieldRenameTwinSyncSse arg}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_field_rename_twin_sync_sse( + arg, serializer); + final raw_ = serializer.intoRaw(); + return wire + .wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse( + raw_.ptr, raw_.rustVecLen, raw_.dataLen); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_struct_with_field_rename_twin_sync_sse, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinSyncSseFuncForStructWithFieldRenameTwinSyncSseConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinSyncSseFuncForStructWithFieldRenameTwinSyncSseConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_field_rename_twin_sync_sse", + argNames: ["arg"], + ); + @override StructWithOneFieldTwinSyncSse crateApiPseudoManualStructureTwinSyncSseFuncStructWithOneFieldTwinSyncSse( @@ -92137,6 +92824,68 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["sink"], ); + @override + Future + crateApiStructureFuncForStructWithDartKeywordFieldTwinNormal( + {required StructWithDartKeywordFieldTwinNormal arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + var arg0 = + cst_encode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + arg); + return wire + .wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal( + port_, arg0); + }, + codec: DcoCodec( + decodeSuccessData: + dco_decode_struct_with_dart_keyword_field_twin_normal, + decodeErrorData: null, + ), + constMeta: + kCrateApiStructureFuncForStructWithDartKeywordFieldTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiStructureFuncForStructWithDartKeywordFieldTwinNormalConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_dart_keyword_field_twin_normal", + argNames: ["arg"], + ); + + @override + Future + crateApiStructureFuncForStructWithFieldRenameTwinNormal( + {required StructWithFieldRenameTwinNormal arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + var arg0 = + cst_encode_box_autoadd_struct_with_field_rename_twin_normal(arg); + return wire + .wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal( + port_, arg0); + }, + codec: DcoCodec( + decodeSuccessData: dco_decode_struct_with_field_rename_twin_normal, + decodeErrorData: null, + ), + constMeta: + kCrateApiStructureFuncForStructWithFieldRenameTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiStructureFuncForStructWithFieldRenameTwinNormalConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_field_rename_twin_normal", + argNames: ["arg"], + ); + @override Future crateApiStructureFuncStructWithOneFieldTwinNormal( @@ -94328,6 +95077,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { get rust_arc_decrement_strong_count_OpaqueTwoTwinSyncSseMoi => wire .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi; + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_SimpleOpaqueExternalStructWithMethod => + wire.rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethod => + wire.rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod; + RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_StaticGetterOnlyTwinNormal => wire .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal; @@ -95508,6 +96265,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { raw as List); } + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalDcoDecode( + raw as List); + } + @protected StaticGetterOnlyTwinNormal dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -96521,6 +97287,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { raw as List); } + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalDcoDecode( + raw as List); + } + @protected StructInMiscNoTwinExampleA dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -96761,6 +97536,34 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return raw as String; } + @protected + int dco_decode_CastedPrimitive_i_64(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError( + 'Not implemented in this codec, please use the other one'); + } + + @protected + int dco_decode_CastedPrimitive_isize(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError( + 'Not implemented in this codec, please use the other one'); + } + + @protected + int dco_decode_CastedPrimitive_u_64(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError( + 'Not implemented in this codec, please use the other one'); + } + + @protected + int dco_decode_CastedPrimitive_usize(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError( + 'Not implemented in this codec, please use the other one'); + } + @protected String dco_decode_Char(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs @@ -96791,6 +97594,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return dcoDecodeTimestamp(ts: dco_decode_i_64(raw).toInt(), isUtc: true); } + @protected + int dco_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError( + 'Not implemented in this codec, please use the other one'); + } + @protected FutureOr Function(Object) dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( @@ -98863,6 +99674,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { raw as List); } + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalDcoDecode( + raw as List); + } + @protected StaticGetterOnlyTwinNormal dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -103204,6 +104024,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return dco_decode_struct_in_lower_level(raw); } + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_casted_primitive_twin_normal(raw); + } + @protected StructWithCommentsTwinNormal dco_decode_box_autoadd_struct_with_comments_twin_normal(dynamic raw) { @@ -103255,6 +104083,54 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return dco_decode_struct_with_custom_name_method_twin_normal(raw); } + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_dart_keyword_field_twin_normal(raw); + } + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_dart_keyword_field_twin_rust_async(raw); + } + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async_sse( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_dart_keyword_field_twin_rust_async_sse(raw); + } + + @protected + StructWithDartKeywordFieldTwinSse + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sse( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_dart_keyword_field_twin_sse(raw); + } + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_dart_keyword_field_twin_sync(raw); + } + + @protected + StructWithDartKeywordFieldTwinSyncSse + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync_sse( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_dart_keyword_field_twin_sync_sse(raw); + } + @protected StructWithEnumTwinNormal dco_decode_box_autoadd_struct_with_enum_twin_normal( dynamic raw) { @@ -103398,6 +104274,51 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { raw); } + @protected + StructWithFieldRenameTwinNormal + dco_decode_box_autoadd_struct_with_field_rename_twin_normal(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_field_rename_twin_normal(raw); + } + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_field_rename_twin_rust_async(raw); + } + + @protected + StructWithFieldRenameTwinRustAsyncSse + dco_decode_box_autoadd_struct_with_field_rename_twin_rust_async_sse( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_field_rename_twin_rust_async_sse(raw); + } + + @protected + StructWithFieldRenameTwinSse + dco_decode_box_autoadd_struct_with_field_rename_twin_sse(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_field_rename_twin_sse(raw); + } + + @protected + StructWithFieldRenameTwinSync + dco_decode_box_autoadd_struct_with_field_rename_twin_sync(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_field_rename_twin_sync(raw); + } + + @protected + StructWithFieldRenameTwinSyncSse + dco_decode_box_autoadd_struct_with_field_rename_twin_sync_sse( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_field_rename_twin_sync_sse(raw); + } + @protected StructWithGoodAndOpaqueFieldTwinMoi dco_decode_box_autoadd_struct_with_good_and_opaque_field_twin_moi( @@ -109886,7 +110807,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return MoreThanJustOneRawStringStructTwinNormal( regular: dco_decode_String(arr[0]), type: dco_decode_String(arr[1]), - async: dco_decode_bool(arr[2]), + async_: dco_decode_bool(arr[2]), another: dco_decode_String(arr[3]), ); } @@ -109902,7 +110823,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return MoreThanJustOneRawStringStructTwinRustAsync( regular: dco_decode_String(arr[0]), type: dco_decode_String(arr[1]), - async: dco_decode_bool(arr[2]), + async_: dco_decode_bool(arr[2]), another: dco_decode_String(arr[3]), ); } @@ -109918,7 +110839,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return MoreThanJustOneRawStringStructTwinRustAsyncSse( regular: dco_decode_String(arr[0]), type: dco_decode_String(arr[1]), - async: dco_decode_bool(arr[2]), + async_: dco_decode_bool(arr[2]), another: dco_decode_String(arr[3]), ); } @@ -109933,7 +110854,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return MoreThanJustOneRawStringStructTwinSse( regular: dco_decode_String(arr[0]), type: dco_decode_String(arr[1]), - async: dco_decode_bool(arr[2]), + async_: dco_decode_bool(arr[2]), another: dco_decode_String(arr[3]), ); } @@ -109948,7 +110869,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return MoreThanJustOneRawStringStructTwinSync( regular: dco_decode_String(arr[0]), type: dco_decode_String(arr[1]), - async: dco_decode_bool(arr[2]), + async_: dco_decode_bool(arr[2]), another: dco_decode_String(arr[3]), ); } @@ -109964,7 +110885,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return MoreThanJustOneRawStringStructTwinSyncSse( regular: dco_decode_String(arr[0]), type: dco_decode_String(arr[1]), - async: dco_decode_bool(arr[2]), + async_: dco_decode_bool(arr[2]), another: dco_decode_String(arr[3]), ); } @@ -113690,6 +114611,21 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); } + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_struct_with_casted_primitive_twin_normal(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 4) + throw Exception('unexpected arr length: expect 4 but see ${arr.length}'); + return StructWithCastedPrimitiveTwinNormal( + fieldI64: dco_decode_CastedPrimitive_i_64(arr[0]), + fieldU64: dco_decode_CastedPrimitive_u_64(arr[1]), + fieldI32: dco_decode_i_32(arr[2]), + fieldVecU8: dco_decode_list_prim_u_8_strict(arr[3]), + ); + } + @protected StructWithCommentsTwinNormal dco_decode_struct_with_comments_twin_normal( dynamic raw) { @@ -113774,6 +114710,85 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); } + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_struct_with_dart_keyword_field_twin_normal(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return StructWithDartKeywordFieldTwinNormal( + class_: dco_decode_i_32(arr[0]), + interface_: dco_decode_i_64(arr[1]), + ); + } + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_struct_with_dart_keyword_field_twin_rust_async(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return StructWithDartKeywordFieldTwinRustAsync( + class_: dco_decode_i_32(arr[0]), + interface_: dco_decode_i_64(arr[1]), + ); + } + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + dco_decode_struct_with_dart_keyword_field_twin_rust_async_sse( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return StructWithDartKeywordFieldTwinRustAsyncSse( + class_: dco_decode_i_32(arr[0]), + interface_: dco_decode_i_64(arr[1]), + ); + } + + @protected + StructWithDartKeywordFieldTwinSse + dco_decode_struct_with_dart_keyword_field_twin_sse(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return StructWithDartKeywordFieldTwinSse( + class_: dco_decode_i_32(arr[0]), + interface_: dco_decode_i_64(arr[1]), + ); + } + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_struct_with_dart_keyword_field_twin_sync(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return StructWithDartKeywordFieldTwinSync( + class_: dco_decode_i_32(arr[0]), + interface_: dco_decode_i_64(arr[1]), + ); + } + + @protected + StructWithDartKeywordFieldTwinSyncSse + dco_decode_struct_with_dart_keyword_field_twin_sync_sse(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return StructWithDartKeywordFieldTwinSyncSse( + class_: dco_decode_i_32(arr[0]), + interface_: dco_decode_i_64(arr[1]), + ); + } + @protected StructWithEnumTwinNormal dco_decode_struct_with_enum_twin_normal( dynamic raw) { @@ -114039,6 +115054,78 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); } + @protected + StructWithFieldRenameTwinNormal + dco_decode_struct_with_field_rename_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 StructWithFieldRenameTwinNormal( + renamed_field: dco_decode_i_32(arr[0]), + ); + } + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_struct_with_field_rename_twin_rust_async(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 StructWithFieldRenameTwinRustAsync( + renamed_field: dco_decode_i_32(arr[0]), + ); + } + + @protected + StructWithFieldRenameTwinRustAsyncSse + dco_decode_struct_with_field_rename_twin_rust_async_sse(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 StructWithFieldRenameTwinRustAsyncSse( + renamed_field: dco_decode_i_32(arr[0]), + ); + } + + @protected + StructWithFieldRenameTwinSse dco_decode_struct_with_field_rename_twin_sse( + 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 StructWithFieldRenameTwinSse( + renamed_field: dco_decode_i_32(arr[0]), + ); + } + + @protected + StructWithFieldRenameTwinSync dco_decode_struct_with_field_rename_twin_sync( + 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 StructWithFieldRenameTwinSync( + renamed_field: dco_decode_i_32(arr[0]), + ); + } + + @protected + StructWithFieldRenameTwinSyncSse + dco_decode_struct_with_field_rename_twin_sync_sse(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 StructWithFieldRenameTwinSyncSse( + renamed_field: dco_decode_i_32(arr[0]), + ); + } + @protected StructWithGoodAndOpaqueFieldTwinMoi dco_decode_struct_with_good_and_opaque_field_twin_moi(dynamic raw) { @@ -116386,6 +117473,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); } + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + @protected StaticGetterOnlyTwinNormal sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -117436,6 +118532,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); } + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + @protected StructInMiscNoTwinExampleA sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -117689,6 +118794,34 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return inner; } + @protected + int sse_decode_CastedPrimitive_i_64(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_i_64(deserializer); + return inner.toInt(); + } + + @protected + int sse_decode_CastedPrimitive_isize(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_isize(deserializer); + return inner.toInt(); + } + + @protected + int sse_decode_CastedPrimitive_u_64(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_u_64(deserializer); + return inner.toInt(); + } + + @protected + int sse_decode_CastedPrimitive_usize(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_usize(deserializer); + return inner.toInt(); + } + @protected String sse_decode_Char(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -117724,6 +118857,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return DateTime.fromMicrosecondsSinceEpoch(inner.toInt(), isUtc: true); } + @protected + int sse_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_String(deserializer); + return int.parse(inner); + } + @protected Object sse_decode_DartOpaque(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -119800,6 +120941,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); } + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + @protected StaticGetterOnlyTwinNormal sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -124109,6 +125259,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return (sse_decode_struct_in_lower_level(deserializer)); } + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_casted_primitive_twin_normal(deserializer)); + } + @protected StructWithCommentsTwinNormal sse_decode_box_autoadd_struct_with_comments_twin_normal( @@ -124166,6 +125324,58 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { deserializer)); } + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_dart_keyword_field_twin_normal( + deserializer)); + } + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_dart_keyword_field_twin_rust_async( + deserializer)); + } + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_dart_keyword_field_twin_rust_async_sse( + deserializer)); + } + + @protected + StructWithDartKeywordFieldTwinSse + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_dart_keyword_field_twin_sse(deserializer)); + } + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_dart_keyword_field_twin_sync(deserializer)); + } + + @protected + StructWithDartKeywordFieldTwinSyncSse + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_dart_keyword_field_twin_sync_sse( + deserializer)); + } + @protected StructWithEnumTwinNormal sse_decode_box_autoadd_struct_with_enum_twin_normal( SseDeserializer deserializer) { @@ -124319,6 +125529,55 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { deserializer)); } + @protected + StructWithFieldRenameTwinNormal + sse_decode_box_autoadd_struct_with_field_rename_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_field_rename_twin_normal(deserializer)); + } + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_field_rename_twin_rust_async(deserializer)); + } + + @protected + StructWithFieldRenameTwinRustAsyncSse + sse_decode_box_autoadd_struct_with_field_rename_twin_rust_async_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_field_rename_twin_rust_async_sse( + deserializer)); + } + + @protected + StructWithFieldRenameTwinSse + sse_decode_box_autoadd_struct_with_field_rename_twin_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_field_rename_twin_sse(deserializer)); + } + + @protected + StructWithFieldRenameTwinSync + sse_decode_box_autoadd_struct_with_field_rename_twin_sync( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_field_rename_twin_sync(deserializer)); + } + + @protected + StructWithFieldRenameTwinSyncSse + sse_decode_box_autoadd_struct_with_field_rename_twin_sync_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_field_rename_twin_sync_sse(deserializer)); + } + @protected StructWithGoodAndOpaqueFieldTwinMoi sse_decode_box_autoadd_struct_with_good_and_opaque_field_twin_moi( @@ -131789,12 +133048,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs var var_regular = sse_decode_String(deserializer); var var_type = sse_decode_String(deserializer); - var var_async = sse_decode_bool(deserializer); + var var_async_ = sse_decode_bool(deserializer); var var_another = sse_decode_String(deserializer); return MoreThanJustOneRawStringStructTwinNormal( regular: var_regular, type: var_type, - async: var_async, + async_: var_async_, another: var_another); } @@ -131805,12 +133064,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs var var_regular = sse_decode_String(deserializer); var var_type = sse_decode_String(deserializer); - var var_async = sse_decode_bool(deserializer); + var var_async_ = sse_decode_bool(deserializer); var var_another = sse_decode_String(deserializer); return MoreThanJustOneRawStringStructTwinRustAsync( regular: var_regular, type: var_type, - async: var_async, + async_: var_async_, another: var_another); } @@ -131821,12 +133080,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs var var_regular = sse_decode_String(deserializer); var var_type = sse_decode_String(deserializer); - var var_async = sse_decode_bool(deserializer); + var var_async_ = sse_decode_bool(deserializer); var var_another = sse_decode_String(deserializer); return MoreThanJustOneRawStringStructTwinRustAsyncSse( regular: var_regular, type: var_type, - async: var_async, + async_: var_async_, another: var_another); } @@ -131837,12 +133096,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs var var_regular = sse_decode_String(deserializer); var var_type = sse_decode_String(deserializer); - var var_async = sse_decode_bool(deserializer); + var var_async_ = sse_decode_bool(deserializer); var var_another = sse_decode_String(deserializer); return MoreThanJustOneRawStringStructTwinSse( regular: var_regular, type: var_type, - async: var_async, + async_: var_async_, another: var_another); } @@ -131853,12 +133112,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs var var_regular = sse_decode_String(deserializer); var var_type = sse_decode_String(deserializer); - var var_async = sse_decode_bool(deserializer); + var var_async_ = sse_decode_bool(deserializer); var var_another = sse_decode_String(deserializer); return MoreThanJustOneRawStringStructTwinSync( regular: var_regular, type: var_type, - async: var_async, + async_: var_async_, another: var_another); } @@ -131869,12 +133128,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs var var_regular = sse_decode_String(deserializer); var var_type = sse_decode_String(deserializer); - var var_async = sse_decode_bool(deserializer); + var var_async_ = sse_decode_bool(deserializer); var var_another = sse_decode_String(deserializer); return MoreThanJustOneRawStringStructTwinSyncSse( regular: var_regular, type: var_type, - async: var_async, + async_: var_async_, another: var_another); } @@ -135732,6 +136991,22 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return StructInUpperLevel(upper: var_upper); } + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_fieldI64 = sse_decode_CastedPrimitive_i_64(deserializer); + var var_fieldU64 = sse_decode_CastedPrimitive_u_64(deserializer); + var var_fieldI32 = sse_decode_i_32(deserializer); + var var_fieldVecU8 = sse_decode_list_prim_u_8_strict(deserializer); + return StructWithCastedPrimitiveTwinNormal( + fieldI64: var_fieldI64, + fieldU64: var_fieldU64, + fieldI32: var_fieldI32, + fieldVecU8: var_fieldVecU8); + } + @protected StructWithCommentsTwinNormal sse_decode_struct_with_comments_twin_normal( SseDeserializer deserializer) { @@ -135795,6 +137070,72 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return StructWithCustomNameMethodTwinNormal(field0: var_field0); } + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_class_ = sse_decode_i_32(deserializer); + var var_interface_ = sse_decode_i_64(deserializer); + return StructWithDartKeywordFieldTwinNormal( + class_: var_class_, interface_: var_interface_); + } + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_class_ = sse_decode_i_32(deserializer); + var var_interface_ = sse_decode_i_64(deserializer); + return StructWithDartKeywordFieldTwinRustAsync( + class_: var_class_, interface_: var_interface_); + } + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + sse_decode_struct_with_dart_keyword_field_twin_rust_async_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_class_ = sse_decode_i_32(deserializer); + var var_interface_ = sse_decode_i_64(deserializer); + return StructWithDartKeywordFieldTwinRustAsyncSse( + class_: var_class_, interface_: var_interface_); + } + + @protected + StructWithDartKeywordFieldTwinSse + sse_decode_struct_with_dart_keyword_field_twin_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_class_ = sse_decode_i_32(deserializer); + var var_interface_ = sse_decode_i_64(deserializer); + return StructWithDartKeywordFieldTwinSse( + class_: var_class_, interface_: var_interface_); + } + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_class_ = sse_decode_i_32(deserializer); + var var_interface_ = sse_decode_i_64(deserializer); + return StructWithDartKeywordFieldTwinSync( + class_: var_class_, interface_: var_interface_); + } + + @protected + StructWithDartKeywordFieldTwinSyncSse + sse_decode_struct_with_dart_keyword_field_twin_sync_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_class_ = sse_decode_i_32(deserializer); + var var_interface_ = sse_decode_i_64(deserializer); + return StructWithDartKeywordFieldTwinSyncSse( + class_: var_class_, interface_: var_interface_); + } + @protected StructWithEnumTwinNormal sse_decode_struct_with_enum_twin_normal( SseDeserializer deserializer) { @@ -136006,6 +137347,59 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { autoOpaque: var_autoOpaque, normal: var_normal); } + @protected + StructWithFieldRenameTwinNormal + sse_decode_struct_with_field_rename_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_renamed_field = sse_decode_i_32(deserializer); + return StructWithFieldRenameTwinNormal(renamed_field: var_renamed_field); + } + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_renamed_field = sse_decode_i_32(deserializer); + return StructWithFieldRenameTwinRustAsync(renamed_field: var_renamed_field); + } + + @protected + StructWithFieldRenameTwinRustAsyncSse + sse_decode_struct_with_field_rename_twin_rust_async_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_renamed_field = sse_decode_i_32(deserializer); + return StructWithFieldRenameTwinRustAsyncSse( + renamed_field: var_renamed_field); + } + + @protected + StructWithFieldRenameTwinSse sse_decode_struct_with_field_rename_twin_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_renamed_field = sse_decode_i_32(deserializer); + return StructWithFieldRenameTwinSse(renamed_field: var_renamed_field); + } + + @protected + StructWithFieldRenameTwinSync sse_decode_struct_with_field_rename_twin_sync( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_renamed_field = sse_decode_i_32(deserializer); + return StructWithFieldRenameTwinSync(renamed_field: var_renamed_field); + } + + @protected + StructWithFieldRenameTwinSyncSse + sse_decode_struct_with_field_rename_twin_sync_sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_renamed_field = sse_decode_i_32(deserializer); + return StructWithFieldRenameTwinSyncSse(renamed_field: var_renamed_field); + } + @protected StructWithGoodAndOpaqueFieldTwinMoi sse_decode_struct_with_good_and_opaque_field_twin_moi( @@ -137627,6 +139021,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return (raw as OpaqueTwoTwinSyncMoiImpl).frbInternalCstEncode(move: true); } + @protected + int cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod raw) { + // Codec=Cst (C-struct based), see doc to use other codecs +// ignore: invalid_use_of_internal_member + return (raw as SimpleOpaqueExternalStructWithMethodImpl) + .frbInternalCstEncode(move: true); + } + @protected int cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( StaticGetterOnlyTwinNormal raw) { @@ -138392,6 +139795,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { .frbInternalCstEncode(move: false); } + @protected + int cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod raw) { + // Codec=Cst (C-struct based), see doc to use other codecs +// ignore: invalid_use_of_internal_member + return (raw as SimpleOpaqueExternalStructWithMethodImpl) + .frbInternalCstEncode(move: false); + } + @protected int cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( StructInMiscNoTwinExampleA raw) { @@ -139432,6 +140844,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return (raw as OpaqueTwoTwinSyncMoiImpl).frbInternalCstEncode(); } + @protected + int cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod raw) { + // Codec=Cst (C-struct based), see doc to use other codecs +// ignore: invalid_use_of_internal_member + return (raw as SimpleOpaqueExternalStructWithMethodImpl) + .frbInternalCstEncode(); + } + @protected int cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( StaticGetterOnlyTwinNormal raw) { @@ -140957,6 +142378,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { serializer); } + @protected + void + sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as SimpleOpaqueExternalStructWithMethodImpl) + .frbInternalSseEncode(move: true), + serializer); + } + @protected void sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -142218,6 +143650,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { serializer); } + @protected + void + sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as SimpleOpaqueExternalStructWithMethodImpl) + .frbInternalSseEncode(move: false), + serializer); + } + @protected void sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -142522,6 +143965,30 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { throw UnimplementedError('Unreachable ()'); } + @protected + void sse_encode_CastedPrimitive_i_64(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_64(sseEncodeCastedPrimitiveI64(self), serializer); + } + + @protected + void sse_encode_CastedPrimitive_isize(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_isize(sseEncodeCastedPrimitiveI64(self), serializer); + } + + @protected + void sse_encode_CastedPrimitive_u_64(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_u_64(sseEncodeCastedPrimitiveU64(self), serializer); + } + + @protected + void sse_encode_CastedPrimitive_usize(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize(sseEncodeCastedPrimitiveU64(self), serializer); + } + @protected void sse_encode_Char(String self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -142555,6 +144022,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { PlatformInt64Util.from(self.microsecondsSinceEpoch), serializer); } + @protected + void + sse_encode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String(self.toString(), serializer); + } + @protected void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer) { @@ -144989,6 +146464,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { serializer); } + @protected + void + sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as SimpleOpaqueExternalStructWithMethodImpl) + .frbInternalSseEncode(move: null), + serializer); + } + @protected void sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -149498,6 +150984,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_struct_in_lower_level(self, serializer); } + @protected + void sse_encode_box_autoadd_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_casted_primitive_twin_normal(self, serializer); + } + @protected void sse_encode_box_autoadd_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer) { @@ -149547,6 +151040,51 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_struct_with_custom_name_method_twin_normal(self, serializer); } + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_dart_keyword_field_twin_normal(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_dart_keyword_field_twin_rust_async(self, serializer); + } + + @protected + void + sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async_sse( + StructWithDartKeywordFieldTwinRustAsyncSse self, + SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_dart_keyword_field_twin_rust_async_sse( + self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sse( + StructWithDartKeywordFieldTwinSse self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_dart_keyword_field_twin_sse(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_dart_keyword_field_twin_sync(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync_sse( + StructWithDartKeywordFieldTwinSyncSse self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_dart_keyword_field_twin_sync_sse(self, serializer); + } + @protected void sse_encode_box_autoadd_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer) { @@ -149704,6 +151242,48 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { self, serializer); } + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_field_rename_twin_normal(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_field_rename_twin_rust_async(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_rust_async_sse( + StructWithFieldRenameTwinRustAsyncSse self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_field_rename_twin_rust_async_sse(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sse( + StructWithFieldRenameTwinSse self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_field_rename_twin_sse(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_field_rename_twin_sync(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sync_sse( + StructWithFieldRenameTwinSyncSse self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_field_rename_twin_sync_sse(self, serializer); + } + @protected void sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_moi( StructWithGoodAndOpaqueFieldTwinMoi self, SseSerializer serializer) { @@ -156002,7 +157582,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_String(self.regular, serializer); sse_encode_String(self.type, serializer); - sse_encode_bool(self.async, serializer); + sse_encode_bool(self.async_, serializer); sse_encode_String(self.another, serializer); } @@ -156013,7 +157593,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_String(self.regular, serializer); sse_encode_String(self.type, serializer); - sse_encode_bool(self.async, serializer); + sse_encode_bool(self.async_, serializer); sse_encode_String(self.another, serializer); } @@ -156024,7 +157604,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_String(self.regular, serializer); sse_encode_String(self.type, serializer); - sse_encode_bool(self.async, serializer); + sse_encode_bool(self.async_, serializer); sse_encode_String(self.another, serializer); } @@ -156034,7 +157614,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_String(self.regular, serializer); sse_encode_String(self.type, serializer); - sse_encode_bool(self.async, serializer); + sse_encode_bool(self.async_, serializer); sse_encode_String(self.another, serializer); } @@ -156044,7 +157624,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_String(self.regular, serializer); sse_encode_String(self.type, serializer); - sse_encode_bool(self.async, serializer); + sse_encode_bool(self.async_, serializer); sse_encode_String(self.another, serializer); } @@ -156055,7 +157635,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_String(self.regular, serializer); sse_encode_String(self.type, serializer); - sse_encode_bool(self.async, serializer); + sse_encode_bool(self.async_, serializer); sse_encode_String(self.another, serializer); } @@ -159359,6 +160939,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_usize(self.upper, serializer); } + @protected + void sse_encode_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_CastedPrimitive_i_64(self.fieldI64, serializer); + sse_encode_CastedPrimitive_u_64(self.fieldU64, serializer); + sse_encode_i_32(self.fieldI32, serializer); + sse_encode_list_prim_u_8_strict(self.fieldVecU8, serializer); + } + @protected void sse_encode_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer) { @@ -159408,6 +160998,55 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(self.field0, serializer); } + @protected + void sse_encode_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.class_, serializer); + sse_encode_i_64(self.interface_, serializer); + } + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.class_, serializer); + sse_encode_i_64(self.interface_, serializer); + } + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_rust_async_sse( + StructWithDartKeywordFieldTwinRustAsyncSse self, + SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.class_, serializer); + sse_encode_i_64(self.interface_, serializer); + } + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sse( + StructWithDartKeywordFieldTwinSse self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.class_, serializer); + sse_encode_i_64(self.interface_, serializer); + } + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.class_, serializer); + sse_encode_i_64(self.interface_, serializer); + } + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sync_sse( + StructWithDartKeywordFieldTwinSyncSse self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.class_, serializer); + sse_encode_i_64(self.interface_, serializer); + } + @protected void sse_encode_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer) { @@ -159575,6 +161214,48 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(self.normal, serializer); } + @protected + void sse_encode_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.renamed_field, serializer); + } + + @protected + void sse_encode_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.renamed_field, serializer); + } + + @protected + void sse_encode_struct_with_field_rename_twin_rust_async_sse( + StructWithFieldRenameTwinRustAsyncSse self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.renamed_field, serializer); + } + + @protected + void sse_encode_struct_with_field_rename_twin_sse( + StructWithFieldRenameTwinSse self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.renamed_field, serializer); + } + + @protected + void sse_encode_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.renamed_field, serializer); + } + + @protected + void sse_encode_struct_with_field_rename_twin_sync_sse( + StructWithFieldRenameTwinSyncSse self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.renamed_field, serializer); + } + @protected void sse_encode_struct_with_good_and_opaque_field_twin_moi( StructWithGoodAndOpaqueFieldTwinMoi self, SseSerializer serializer) { @@ -164790,6 +166471,34 @@ class RwLockHideDataTwinSyncSseMoiImpl extends RustOpaque ); } +@sealed +class SimpleOpaqueExternalStructWithMethodImpl extends RustOpaque + implements SimpleOpaqueExternalStructWithMethod { + // Not to be used by end users + SimpleOpaqueExternalStructWithMethodImpl.frbInternalDcoDecode( + List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + SimpleOpaqueExternalStructWithMethodImpl.frbInternalSseDecode( + BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: RustLib.instance.api + .rust_arc_increment_strong_count_SimpleOpaqueExternalStructWithMethod, + rustArcDecrementStrongCount: RustLib.instance.api + .rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethod, + rustArcDecrementStrongCountPtr: RustLib.instance.api + .rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethodPtr, + ); + + Future simpleExternalMethod() => RustLib.instance.api + .crateApiExternalImplSimpleOpaqueExternalStructWithMethodSimpleExternalMethod( + that: this, + ); +} + @sealed class StaticGetterOnlyTwinNormalImpl extends RustOpaque implements StaticGetterOnlyTwinNormal { 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 71d7b39f90..1fe1b4d303 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 @@ -9,9 +9,11 @@ import 'api/async_misc.dart'; import 'api/async_spawn.dart'; import 'api/attribute.dart'; import 'api/benchmark_misc.dart'; +import 'api/casted_primitive.dart'; import 'api/chrono_type.dart'; import 'api/comment.dart'; import 'api/constructor.dart'; +import 'api/custom_ser_des.dart'; import 'api/customization.dart'; import 'api/dart_code.dart'; import 'api/dart_dynamic.dart'; @@ -947,6 +949,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { get rust_arc_decrement_strong_count_OpaqueTwoTwinSyncSseMoiPtr => wire ._rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoiPtr; + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethodPtr => + wire._rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethodPtr; + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_StaticGetterOnlyTwinNormalPtr => wire ._rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormalPtr; @@ -1604,6 +1610,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StaticGetterOnlyTwinNormal dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -2174,6 +2185,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StructInMiscNoTwinExampleA dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -2307,6 +2323,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String dco_decode_Backtrace(dynamic raw); + @protected + int dco_decode_CastedPrimitive_i_64(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_isize(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_u_64(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_usize(dynamic raw); + @protected String dco_decode_Char(dynamic raw); @@ -2322,6 +2350,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected DateTime dco_decode_Chrono_Utc(dynamic raw); + @protected + int dco_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + dynamic raw); + @protected FutureOr Function(Object) dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( @@ -3401,6 +3433,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StaticGetterOnlyTwinNormal dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -5503,6 +5540,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected StructInLowerLevel dco_decode_box_autoadd_struct_in_lower_level(dynamic raw); + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + dynamic raw); + @protected StructWithCommentsTwinNormal dco_decode_box_autoadd_struct_with_comments_twin_normal(dynamic raw); @@ -5533,6 +5575,36 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_box_autoadd_struct_with_custom_name_method_twin_normal( dynamic raw); + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async_sse( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSse + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sse( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSyncSse + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync_sse( + dynamic raw); + @protected StructWithEnumTwinNormal dco_decode_box_autoadd_struct_with_enum_twin_normal( dynamic raw); @@ -5617,6 +5689,33 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync_sse_moi( dynamic raw); + @protected + StructWithFieldRenameTwinNormal + dco_decode_box_autoadd_struct_with_field_rename_twin_normal(dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsyncSse + dco_decode_box_autoadd_struct_with_field_rename_twin_rust_async_sse( + dynamic raw); + + @protected + StructWithFieldRenameTwinSse + dco_decode_box_autoadd_struct_with_field_rename_twin_sse(dynamic raw); + + @protected + StructWithFieldRenameTwinSync + dco_decode_box_autoadd_struct_with_field_rename_twin_sync(dynamic raw); + + @protected + StructWithFieldRenameTwinSyncSse + dco_decode_box_autoadd_struct_with_field_rename_twin_sync_sse( + dynamic raw); + @protected StructWithGoodAndOpaqueFieldTwinMoi dco_decode_box_autoadd_struct_with_good_and_opaque_field_twin_moi( @@ -9072,6 +9171,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected StructInUpperLevel dco_decode_struct_in_upper_level(dynamic raw); + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_struct_with_casted_primitive_twin_normal(dynamic raw); + @protected StructWithCommentsTwinNormal dco_decode_struct_with_comments_twin_normal( dynamic raw); @@ -9100,6 +9203,31 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithCustomNameMethodTwinNormal dco_decode_struct_with_custom_name_method_twin_normal(dynamic raw); + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_struct_with_dart_keyword_field_twin_normal(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_struct_with_dart_keyword_field_twin_rust_async(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + dco_decode_struct_with_dart_keyword_field_twin_rust_async_sse( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSse + dco_decode_struct_with_dart_keyword_field_twin_sse(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_struct_with_dart_keyword_field_twin_sync(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSyncSse + dco_decode_struct_with_dart_keyword_field_twin_sync_sse(dynamic raw); + @protected StructWithEnumTwinNormal dco_decode_struct_with_enum_twin_normal(dynamic raw); @@ -9178,6 +9306,30 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_struct_with_explicit_auto_opaque_field_twin_sync_sse_moi( dynamic raw); + @protected + StructWithFieldRenameTwinNormal + dco_decode_struct_with_field_rename_twin_normal(dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_struct_with_field_rename_twin_rust_async(dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsyncSse + dco_decode_struct_with_field_rename_twin_rust_async_sse(dynamic raw); + + @protected + StructWithFieldRenameTwinSse dco_decode_struct_with_field_rename_twin_sse( + dynamic raw); + + @protected + StructWithFieldRenameTwinSync dco_decode_struct_with_field_rename_twin_sync( + dynamic raw); + + @protected + StructWithFieldRenameTwinSyncSse + dco_decode_struct_with_field_rename_twin_sync_sse(dynamic raw); + @protected StructWithGoodAndOpaqueFieldTwinMoi dco_decode_struct_with_good_and_opaque_field_twin_moi(dynamic raw); @@ -10116,6 +10268,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StaticGetterOnlyTwinNormal sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -10686,6 +10843,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StructInMiscNoTwinExampleA sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -10819,6 +10981,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String sse_decode_Backtrace(SseDeserializer deserializer); + @protected + int sse_decode_CastedPrimitive_i_64(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_isize(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_u_64(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_usize(SseDeserializer deserializer); + @protected String sse_decode_Char(SseDeserializer deserializer); @@ -10834,6 +11008,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected DateTime sse_decode_Chrono_Utc(SseDeserializer deserializer); + @protected + int sse_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + SseDeserializer deserializer); + @protected Object sse_decode_DartOpaque(SseDeserializer deserializer); @@ -11913,6 +12091,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StaticGetterOnlyTwinNormal sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -14207,6 +14390,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructInLowerLevel sse_decode_box_autoadd_struct_in_lower_level( SseDeserializer deserializer); + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer); + @protected StructWithCommentsTwinNormal sse_decode_box_autoadd_struct_with_comments_twin_normal( @@ -14242,6 +14430,36 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_box_autoadd_struct_with_custom_name_method_twin_normal( SseDeserializer deserializer); + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async_sse( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSse + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sse( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSyncSse + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync_sse( + SseDeserializer deserializer); + @protected StructWithEnumTwinNormal sse_decode_box_autoadd_struct_with_enum_twin_normal( SseDeserializer deserializer); @@ -14329,6 +14547,36 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync_sse_moi( SseDeserializer deserializer); + @protected + StructWithFieldRenameTwinNormal + sse_decode_box_autoadd_struct_with_field_rename_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsyncSse + sse_decode_box_autoadd_struct_with_field_rename_twin_rust_async_sse( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSse + sse_decode_box_autoadd_struct_with_field_rename_twin_sse( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSync + sse_decode_box_autoadd_struct_with_field_rename_twin_sync( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSyncSse + sse_decode_box_autoadd_struct_with_field_rename_twin_sync_sse( + SseDeserializer deserializer); + @protected StructWithGoodAndOpaqueFieldTwinMoi sse_decode_box_autoadd_struct_with_good_and_opaque_field_twin_moi( @@ -18269,6 +18517,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructInUpperLevel sse_decode_struct_in_upper_level( SseDeserializer deserializer); + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer); + @protected StructWithCommentsTwinNormal sse_decode_struct_with_comments_twin_normal( SseDeserializer deserializer); @@ -18300,6 +18553,36 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_struct_with_custom_name_method_twin_normal( SseDeserializer deserializer); + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + sse_decode_struct_with_dart_keyword_field_twin_rust_async_sse( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSse + sse_decode_struct_with_dart_keyword_field_twin_sse( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSyncSse + sse_decode_struct_with_dart_keyword_field_twin_sync_sse( + SseDeserializer deserializer); + @protected StructWithEnumTwinNormal sse_decode_struct_with_enum_twin_normal( SseDeserializer deserializer); @@ -18385,6 +18668,34 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_struct_with_explicit_auto_opaque_field_twin_sync_sse_moi( SseDeserializer deserializer); + @protected + StructWithFieldRenameTwinNormal + sse_decode_struct_with_field_rename_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsyncSse + sse_decode_struct_with_field_rename_twin_rust_async_sse( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSse sse_decode_struct_with_field_rename_twin_sse( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSync sse_decode_struct_with_field_rename_twin_sync( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSyncSse + sse_decode_struct_with_field_rename_twin_sync_sse( + SseDeserializer deserializer); + @protected StructWithGoodAndOpaqueFieldTwinMoi sse_decode_struct_with_good_and_opaque_field_twin_moi( @@ -21616,6 +21927,41 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { return ptr; } + @protected + ffi.Pointer + cst_encode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + final ptr = + wire.cst_new_box_autoadd_struct_with_dart_keyword_field_twin_normal(); + cst_api_fill_to_wire_struct_with_dart_keyword_field_twin_normal( + raw, ptr.ref); + return ptr; + } + + @protected + ffi.Pointer + cst_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + final ptr = wire + .cst_new_box_autoadd_struct_with_dart_keyword_field_twin_rust_async(); + cst_api_fill_to_wire_struct_with_dart_keyword_field_twin_rust_async( + raw, ptr.ref); + return ptr; + } + + @protected + ffi.Pointer + cst_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + final ptr = + wire.cst_new_box_autoadd_struct_with_dart_keyword_field_twin_sync(); + cst_api_fill_to_wire_struct_with_dart_keyword_field_twin_sync(raw, ptr.ref); + return ptr; + } + @protected ffi.Pointer cst_encode_box_autoadd_struct_with_enum_twin_normal( @@ -21719,6 +22065,37 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { return ptr; } + @protected + ffi.Pointer + cst_encode_box_autoadd_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + final ptr = wire.cst_new_box_autoadd_struct_with_field_rename_twin_normal(); + cst_api_fill_to_wire_struct_with_field_rename_twin_normal(raw, ptr.ref); + return ptr; + } + + @protected + ffi.Pointer + cst_encode_box_autoadd_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + final ptr = + wire.cst_new_box_autoadd_struct_with_field_rename_twin_rust_async(); + cst_api_fill_to_wire_struct_with_field_rename_twin_rust_async(raw, ptr.ref); + return ptr; + } + + @protected + ffi.Pointer + cst_encode_box_autoadd_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + final ptr = wire.cst_new_box_autoadd_struct_with_field_rename_twin_sync(); + cst_api_fill_to_wire_struct_with_field_rename_twin_sync(raw, ptr.ref); + return ptr; + } + @protected ffi.Pointer cst_encode_box_autoadd_struct_with_good_and_opaque_field_twin_moi( @@ -26533,6 +26910,36 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { apiObj, wireObj.ref); } + @protected + void + cst_api_fill_to_wire_box_autoadd_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal apiObj, + ffi.Pointer + wireObj) { + cst_api_fill_to_wire_struct_with_dart_keyword_field_twin_normal( + apiObj, wireObj.ref); + } + + @protected + void + cst_api_fill_to_wire_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync apiObj, + ffi.Pointer + wireObj) { + cst_api_fill_to_wire_struct_with_dart_keyword_field_twin_rust_async( + apiObj, wireObj.ref); + } + + @protected + void + cst_api_fill_to_wire_box_autoadd_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync apiObj, + ffi.Pointer + wireObj) { + cst_api_fill_to_wire_struct_with_dart_keyword_field_twin_sync( + apiObj, wireObj.ref); + } + @protected void cst_api_fill_to_wire_box_autoadd_struct_with_enum_twin_normal( StructWithEnumTwinNormal apiObj, @@ -26616,6 +27023,32 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { apiObj, wireObj.ref); } + @protected + void cst_api_fill_to_wire_box_autoadd_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal apiObj, + ffi.Pointer wireObj) { + cst_api_fill_to_wire_struct_with_field_rename_twin_normal( + apiObj, wireObj.ref); + } + + @protected + void + cst_api_fill_to_wire_box_autoadd_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync apiObj, + ffi.Pointer + wireObj) { + cst_api_fill_to_wire_struct_with_field_rename_twin_rust_async( + apiObj, wireObj.ref); + } + + @protected + void cst_api_fill_to_wire_box_autoadd_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync apiObj, + ffi.Pointer wireObj) { + cst_api_fill_to_wire_struct_with_field_rename_twin_sync( + apiObj, wireObj.ref); + } + @protected void cst_api_fill_to_wire_box_autoadd_struct_with_good_and_opaque_field_twin_moi( @@ -28725,7 +29158,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { wire_cst_more_than_just_one_raw_string_struct_twin_normal wireObj) { wireObj.regular = cst_encode_String(apiObj.regular); wireObj.type = cst_encode_String(apiObj.type); - wireObj.async1 = cst_encode_bool(apiObj.async); + wireObj.async1 = cst_encode_bool(apiObj.async_); wireObj.another = cst_encode_String(apiObj.another); } @@ -28737,7 +29170,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { wireObj) { wireObj.regular = cst_encode_String(apiObj.regular); wireObj.type = cst_encode_String(apiObj.type); - wireObj.async1 = cst_encode_bool(apiObj.async); + wireObj.async1 = cst_encode_bool(apiObj.async_); wireObj.another = cst_encode_String(apiObj.another); } @@ -28747,7 +29180,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { wire_cst_more_than_just_one_raw_string_struct_twin_sync wireObj) { wireObj.regular = cst_encode_String(apiObj.regular); wireObj.type = cst_encode_String(apiObj.type); - wireObj.async1 = cst_encode_bool(apiObj.async); + wireObj.async1 = cst_encode_bool(apiObj.async_); wireObj.another = cst_encode_String(apiObj.another); } @@ -29709,6 +30142,30 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { wireObj.field0 = cst_encode_i_32(apiObj.field0); } + @protected + void cst_api_fill_to_wire_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal apiObj, + wire_cst_struct_with_dart_keyword_field_twin_normal wireObj) { + wireObj.class_ = cst_encode_i_32(apiObj.class_); + wireObj.interface1 = cst_encode_i_64(apiObj.interface_); + } + + @protected + void cst_api_fill_to_wire_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync apiObj, + wire_cst_struct_with_dart_keyword_field_twin_rust_async wireObj) { + wireObj.class_ = cst_encode_i_32(apiObj.class_); + wireObj.interface1 = cst_encode_i_64(apiObj.interface_); + } + + @protected + void cst_api_fill_to_wire_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync apiObj, + wire_cst_struct_with_dart_keyword_field_twin_sync wireObj) { + wireObj.class_ = cst_encode_i_32(apiObj.class_); + wireObj.interface1 = cst_encode_i_64(apiObj.interface_); + } + @protected void cst_api_fill_to_wire_struct_with_enum_twin_normal( StructWithEnumTwinNormal apiObj, @@ -29799,6 +30256,27 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { wireObj.normal = cst_encode_i_32(apiObj.normal); } + @protected + void cst_api_fill_to_wire_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal apiObj, + wire_cst_struct_with_field_rename_twin_normal wireObj) { + wireObj.class_ = cst_encode_i_32(apiObj.renamed_field); + } + + @protected + void cst_api_fill_to_wire_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync apiObj, + wire_cst_struct_with_field_rename_twin_rust_async wireObj) { + wireObj.class_ = cst_encode_i_32(apiObj.renamed_field); + } + + @protected + void cst_api_fill_to_wire_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync apiObj, + wire_cst_struct_with_field_rename_twin_sync wireObj) { + wireObj.class_ = cst_encode_i_32(apiObj.renamed_field); + } + @protected void cst_api_fill_to_wire_struct_with_good_and_opaque_field_twin_moi( StructWithGoodAndOpaqueFieldTwinMoi apiObj, @@ -30353,6 +30831,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { int cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncMoi( OpaqueTwoTwinSyncMoi raw); + @protected + int cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod raw); + @protected int cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( StaticGetterOnlyTwinNormal raw); @@ -30693,6 +31175,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { int cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( OpaqueStructWithDartCodeTwinNormal raw); + @protected + int cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod raw); + @protected int cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( StructInMiscNoTwinExampleA raw); @@ -31188,6 +31674,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { int cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncMoi( OpaqueTwoTwinSyncMoi raw); + @protected + int cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod raw); + @protected int cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( StaticGetterOnlyTwinNormal raw); @@ -31935,6 +32425,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( OpaqueTwoTwinSyncSseMoi self, SseSerializer serializer); + @protected + void + sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -32529,6 +33024,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( OpaqueStructWithDartCodeTwinNormal self, SseSerializer serializer); + @protected + void + sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -32674,6 +33174,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_Backtrace(String self, SseSerializer serializer); + @protected + void sse_encode_CastedPrimitive_i_64(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_isize(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_u_64(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_usize(int self, SseSerializer serializer); + @protected void sse_encode_Char(String self, SseSerializer serializer); @@ -32689,6 +33201,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_Chrono_Utc(DateTime self, SseSerializer serializer); + @protected + void + sse_encode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + int self, SseSerializer serializer); + @protected void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer); @@ -33827,6 +34344,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( OpaqueTwoTwinSyncSseMoi self, SseSerializer serializer); + @protected + void + sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -36013,6 +36535,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_box_autoadd_struct_in_lower_level( StructInLowerLevel self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer); @@ -36041,6 +36567,32 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_box_autoadd_struct_with_custom_name_method_twin_normal( StructWithCustomNameMethodTwinNormal self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer); + + @protected + void + sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async_sse( + StructWithDartKeywordFieldTwinRustAsyncSse self, + SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sse( + StructWithDartKeywordFieldTwinSse self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync_sse( + StructWithDartKeywordFieldTwinSyncSse self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer); @@ -36131,6 +36683,30 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithExplicitAutoOpaqueFieldTwinSyncSseMoi self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_rust_async_sse( + StructWithFieldRenameTwinRustAsyncSse self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sse( + StructWithFieldRenameTwinSse self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sync_sse( + StructWithFieldRenameTwinSyncSse self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_moi( StructWithGoodAndOpaqueFieldTwinMoi self, SseSerializer serializer); @@ -39885,6 +40461,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_struct_in_upper_level( StructInUpperLevel self, SseSerializer serializer); + @protected + void sse_encode_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer); + @protected void sse_encode_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer); @@ -39913,6 +40493,31 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_struct_with_custom_name_method_twin_normal( StructWithCustomNameMethodTwinNormal self, SseSerializer serializer); + @protected + void sse_encode_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_rust_async_sse( + StructWithDartKeywordFieldTwinRustAsyncSse self, + SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sse( + StructWithDartKeywordFieldTwinSse self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sync_sse( + StructWithDartKeywordFieldTwinSyncSse self, SseSerializer serializer); + @protected void sse_encode_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer); @@ -39995,6 +40600,30 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithExplicitAutoOpaqueFieldTwinSyncSseMoi self, SseSerializer serializer); + @protected + void sse_encode_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_rust_async_sse( + StructWithFieldRenameTwinRustAsyncSse self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_sse( + StructWithFieldRenameTwinSse self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_sync_sse( + StructWithFieldRenameTwinSyncSse self, SseSerializer serializer); + @protected void sse_encode_struct_with_good_and_opaque_field_twin_moi( StructWithGoodAndOpaqueFieldTwinMoi self, SseSerializer serializer); @@ -40931,6 +41560,152 @@ class RustLibWire implements BaseWire { _wire__crate__api__benchmark_misc__benchmark_void_semi_serializePtr .asFunction(); + void wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__casted_primitive__casted_primitive_i64_twin_normalPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.Pointer, + ffi.Int32, ffi.Int32)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal'); + late final _wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal = + _wire__crate__api__casted_primitive__casted_primitive_i64_twin_normalPtr + .asFunction, int, int)>(); + + void wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__casted_primitive__casted_primitive_isize_twin_normalPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.Pointer, + ffi.Int32, ffi.Int32)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal'); + late final _wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal = + _wire__crate__api__casted_primitive__casted_primitive_isize_twin_normalPtr + .asFunction, int, int)>(); + + void + wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normalPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.Pointer, + ffi.Int32, ffi.Int32)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal'); + late final _wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal = + _wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normalPtr + .asFunction, int, int)>(); + + void wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__casted_primitive__casted_primitive_u64_twin_normalPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.Pointer, + ffi.Int32, ffi.Int32)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal'); + late final _wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal = + _wire__crate__api__casted_primitive__casted_primitive_u64_twin_normalPtr + .asFunction, int, int)>(); + + void wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__casted_primitive__casted_primitive_usize_twin_normalPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.Pointer, + ffi.Int32, ffi.Int32)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal'); + late final _wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal = + _wire__crate__api__casted_primitive__casted_primitive_usize_twin_normalPtr + .asFunction, int, int)>(); + + void + wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normalPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.Pointer, + ffi.Int32, ffi.Int32)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal'); + late final _wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal = + _wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normalPtr + .asFunction, int, int)>(); + void wire__crate__api__chrono_type__datetime_local_twin_normal( int port_, int d, @@ -41370,6 +42145,31 @@ class RustLibWire implements BaseWire { _wire__crate__api__constructor__constructor_translatable_sync_struct_twin_normal_newPtr .asFunction(); + void + wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__custom_ser_des__function_using_type_with_custom_serializerPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.Pointer, + ffi.Int32, ffi.Int32)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer'); + late final _wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer = + _wire__crate__api__custom_ser_des__function_using_type_with_custom_serializerPtr + .asFunction, int, int)>(); + void wire__crate__api__customization__check_init_done( int port_, ) { @@ -43198,6 +43998,45 @@ class RustLibWire implements BaseWire { _wire__crate__api__exception__throw_anyhow_twin_normalPtr .asFunction(); + WireSyncRust2DartDco + wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new( + ffi.Pointer a, + ) { + return _wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new( + a, + ); + } + + late final _wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_newPtr = + _lookup< + ffi.NativeFunction< + WireSyncRust2DartDco Function( + ffi.Pointer)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new'); + late final _wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new = + _wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_newPtr + .asFunction< + WireSyncRust2DartDco Function( + ffi.Pointer)>(); + + void + wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method( + int port_, + int that, + ) { + return _wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method( + port_, + that, + ); + } + + late final _wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_methodPtr = + _lookup>( + 'frbgen_frb_example_pure_dart_wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method'); + late final _wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method = + _wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_methodPtr + .asFunction(); + void wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method( int port_, @@ -96842,6 +97681,60 @@ class RustLibWire implements BaseWire { _wire__crate__api__pseudo_manual__stream_twin_sse__stream_sink_inside_vec_twin_ssePtr .asFunction, int, int)>(); + void + wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async( + int port_, + ffi.Pointer arg, + ) { + return _wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async( + port_, + arg, + ); + } + + late final _wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_asyncPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer< + wire_cst_struct_with_dart_keyword_field_twin_rust_async>)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async'); + late final _wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async = + _wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_asyncPtr + .asFunction< + void Function( + int, + ffi.Pointer< + wire_cst_struct_with_dart_keyword_field_twin_rust_async>)>(); + + void + wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async( + int port_, + ffi.Pointer arg, + ) { + return _wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async( + port_, + arg, + ); + } + + late final _wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_asyncPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer< + wire_cst_struct_with_field_rename_twin_rust_async>)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async'); + late final _wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async = + _wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_asyncPtr + .asFunction< + void Function( + int, + ffi.Pointer< + wire_cst_struct_with_field_rename_twin_rust_async>)>(); + void wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async( int port_, @@ -96977,6 +97870,56 @@ class RustLibWire implements BaseWire { ffi.Pointer< wire_cst_tuple_struct_with_two_field_twin_rust_async>)>(); + void + wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_sse( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_sse( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_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__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_sse'); + late final _wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_sse = + _wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_ssePtr + .asFunction, int, int)>(); + + void + wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_sse( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_sse( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_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__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_sse'); + late final _wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_sse = + _wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_ssePtr + .asFunction, int, int)>(); + void wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_struct_with_one_field_twin_rust_async_sse( int port_, @@ -97102,6 +98045,56 @@ class RustLibWire implements BaseWire { _wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_tuple_struct_with_two_field_twin_rust_async_ssePtr .asFunction, int, int)>(); + void + wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_sse( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_sse( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_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__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_sse'); + late final _wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_sse = + _wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_ssePtr + .asFunction, int, int)>(); + + void + wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_twin_sse( + int port_, + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_twin_sse( + port_, + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_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__structure_twin_sse__func_for_struct_with_field_rename_twin_sse'); + late final _wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_twin_sse = + _wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_twin_ssePtr + .asFunction, int, int)>(); + void wire__crate__api__pseudo_manual__structure_twin_sse__func_struct_with_one_field_twin_sse( int port_, @@ -97227,6 +98220,51 @@ class RustLibWire implements BaseWire { _wire__crate__api__pseudo_manual__structure_twin_sse__func_tuple_struct_with_two_field_twin_ssePtr .asFunction, int, int)>(); + WireSyncRust2DartDco + wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync( + ffi.Pointer arg, + ) { + return _wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync( + arg, + ); + } + + late final _wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_syncPtr = + _lookup< + ffi.NativeFunction< + WireSyncRust2DartDco Function( + ffi.Pointer< + wire_cst_struct_with_dart_keyword_field_twin_sync>)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync'); + late final _wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync = + _wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_syncPtr + .asFunction< + WireSyncRust2DartDco Function( + ffi.Pointer< + wire_cst_struct_with_dart_keyword_field_twin_sync>)>(); + + WireSyncRust2DartDco + wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync( + ffi.Pointer arg, + ) { + return _wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync( + arg, + ); + } + + late final _wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_syncPtr = + _lookup< + ffi.NativeFunction< + WireSyncRust2DartDco Function( + ffi.Pointer< + wire_cst_struct_with_field_rename_twin_sync>)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync'); + late final _wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync = + _wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_syncPtr + .asFunction< + WireSyncRust2DartDco Function( + ffi.Pointer)>(); + WireSyncRust2DartDco wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync( ffi.Pointer arg, @@ -97336,6 +98374,56 @@ class RustLibWire implements BaseWire { ffi.Pointer< wire_cst_tuple_struct_with_two_field_twin_sync>)>(); + WireSyncRust2DartSse + wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse( + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse( + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_ssePtr = + _lookup< + ffi.NativeFunction< + WireSyncRust2DartSse Function( + ffi.Pointer, ffi.Int32, ffi.Int32)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse'); + late final _wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse = + _wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_ssePtr + .asFunction< + WireSyncRust2DartSse Function( + ffi.Pointer, int, int)>(); + + WireSyncRust2DartSse + wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse( + ffi.Pointer ptr_, + int rust_vec_len_, + int data_len_, + ) { + return _wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse( + ptr_, + rust_vec_len_, + data_len_, + ); + } + + late final _wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_ssePtr = + _lookup< + ffi.NativeFunction< + WireSyncRust2DartSse Function( + ffi.Pointer, ffi.Int32, ffi.Int32)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse'); + late final _wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse = + _wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_ssePtr + .asFunction< + WireSyncRust2DartSse Function( + ffi.Pointer, int, int)>(); + WireSyncRust2DartSse wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_struct_with_one_field_twin_sync_sse( ffi.Pointer ptr_, @@ -99924,6 +101012,60 @@ class RustLibWire implements BaseWire { .asFunction< void Function(int, ffi.Pointer)>(); + void + wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal( + int port_, + ffi.Pointer arg, + ) { + return _wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal( + port_, + arg, + ); + } + + late final _wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normalPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer< + wire_cst_struct_with_dart_keyword_field_twin_normal>)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal'); + late final _wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal = + _wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normalPtr + .asFunction< + void Function( + int, + ffi.Pointer< + wire_cst_struct_with_dart_keyword_field_twin_normal>)>(); + + void + wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal( + int port_, + ffi.Pointer arg, + ) { + return _wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal( + port_, + arg, + ); + } + + late final _wire__crate__api__structure__func_for_struct_with_field_rename_twin_normalPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer< + wire_cst_struct_with_field_rename_twin_normal>)>>( + 'frbgen_frb_example_pure_dart_wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal'); + late final _wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal = + _wire__crate__api__structure__func_for_struct_with_field_rename_twin_normalPtr + .asFunction< + void Function( + int, + ffi.Pointer< + wire_cst_struct_with_field_rename_twin_normal>)>(); + void wire__crate__api__structure__func_struct_with_one_field_twin_normal( int port_, ffi.Pointer arg, @@ -105436,6 +106578,38 @@ class RustLibWire implements BaseWire { _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoiPtr .asFunction)>(); + void + rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethodPtr = + _lookup)>>( + 'frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod'); + late final _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod = + _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethodPtr + .asFunction)>(); + + void + rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethodPtr = + _lookup)>>( + 'frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod'); + late final _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod = + _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethodPtr + .asFunction)>(); + void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( ffi.Pointer ptr, @@ -109193,6 +110367,60 @@ class RustLibWire implements BaseWire { ffi.Pointer Function()>(); + ffi.Pointer + cst_new_box_autoadd_struct_with_dart_keyword_field_twin_normal() { + return _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_normal(); + } + + late final _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_normalPtr = + _lookup< + ffi.NativeFunction< + ffi.Pointer< + wire_cst_struct_with_dart_keyword_field_twin_normal> + Function()>>( + 'frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_normal'); + late final _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_normal = + _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_normalPtr + .asFunction< + ffi.Pointer + Function()>(); + + ffi.Pointer + cst_new_box_autoadd_struct_with_dart_keyword_field_twin_rust_async() { + return _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_rust_async(); + } + + late final _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_rust_asyncPtr = + _lookup< + ffi.NativeFunction< + ffi.Pointer< + wire_cst_struct_with_dart_keyword_field_twin_rust_async> + Function()>>( + 'frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_rust_async'); + late final _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_rust_async = + _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_rust_asyncPtr + .asFunction< + ffi.Pointer< + wire_cst_struct_with_dart_keyword_field_twin_rust_async> + Function()>(); + + ffi.Pointer + cst_new_box_autoadd_struct_with_dart_keyword_field_twin_sync() { + return _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_sync(); + } + + late final _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_syncPtr = + _lookup< + ffi.NativeFunction< + ffi.Pointer + Function()>>( + 'frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_sync'); + late final _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_sync = + _cst_new_box_autoadd_struct_with_dart_keyword_field_twin_syncPtr + .asFunction< + ffi.Pointer + Function()>(); + ffi.Pointer cst_new_box_autoadd_struct_with_enum_twin_normal() { return _cst_new_box_autoadd_struct_with_enum_twin_normal(); @@ -109348,6 +110576,53 @@ class RustLibWire implements BaseWire { wire_cst_struct_with_explicit_auto_opaque_field_twin_sync_moi> Function()>(); + ffi.Pointer + cst_new_box_autoadd_struct_with_field_rename_twin_normal() { + return _cst_new_box_autoadd_struct_with_field_rename_twin_normal(); + } + + late final _cst_new_box_autoadd_struct_with_field_rename_twin_normalPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer + Function()>>( + 'frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_normal'); + late final _cst_new_box_autoadd_struct_with_field_rename_twin_normal = + _cst_new_box_autoadd_struct_with_field_rename_twin_normalPtr.asFunction< + ffi.Pointer + Function()>(); + + ffi.Pointer + cst_new_box_autoadd_struct_with_field_rename_twin_rust_async() { + return _cst_new_box_autoadd_struct_with_field_rename_twin_rust_async(); + } + + late final _cst_new_box_autoadd_struct_with_field_rename_twin_rust_asyncPtr = + _lookup< + ffi.NativeFunction< + ffi.Pointer + Function()>>( + 'frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_rust_async'); + late final _cst_new_box_autoadd_struct_with_field_rename_twin_rust_async = + _cst_new_box_autoadd_struct_with_field_rename_twin_rust_asyncPtr + .asFunction< + ffi.Pointer + Function()>(); + + ffi.Pointer + cst_new_box_autoadd_struct_with_field_rename_twin_sync() { + return _cst_new_box_autoadd_struct_with_field_rename_twin_sync(); + } + + late final _cst_new_box_autoadd_struct_with_field_rename_twin_syncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer + Function()>>( + 'frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_sync'); + late final _cst_new_box_autoadd_struct_with_field_rename_twin_sync = + _cst_new_box_autoadd_struct_with_field_rename_twin_syncPtr.asFunction< + ffi.Pointer + Function()>(); + ffi.Pointer cst_new_box_autoadd_struct_with_good_and_opaque_field_twin_moi() { return _cst_new_box_autoadd_struct_with_good_and_opaque_field_twin_moi(); @@ -115930,6 +117205,21 @@ final class wire_cst_list_StreamSink_i_32_Dco extends ffi.Struct { external int len; } +final class wire_cst_struct_with_dart_keyword_field_twin_rust_async + extends ffi.Struct { + @ffi.Int32() + external int class_; + + @ffi.Int64() + external int interface1; +} + +final class wire_cst_struct_with_field_rename_twin_rust_async + extends ffi.Struct { + @ffi.Int32() + external int class_; +} + final class wire_cst_struct_with_one_field_twin_rust_async extends ffi.Struct { @ffi.Int32() external int a; @@ -115961,6 +117251,20 @@ final class wire_cst_tuple_struct_with_two_field_twin_rust_async external int field1; } +final class wire_cst_struct_with_dart_keyword_field_twin_sync + extends ffi.Struct { + @ffi.Int32() + external int class_; + + @ffi.Int64() + external int interface1; +} + +final class wire_cst_struct_with_field_rename_twin_sync extends ffi.Struct { + @ffi.Int32() + external int class_; +} + final class wire_cst_struct_with_one_field_twin_sync extends ffi.Struct { @ffi.Int32() external int a; @@ -116134,6 +117438,20 @@ final class wire_cst_my_struct_containing_stream_sink_twin_normal external ffi.Pointer b; } +final class wire_cst_struct_with_dart_keyword_field_twin_normal + extends ffi.Struct { + @ffi.Int32() + external int class_; + + @ffi.Int64() + external int interface1; +} + +final class wire_cst_struct_with_field_rename_twin_normal extends ffi.Struct { + @ffi.Int32() + external int class_; +} + final class wire_cst_struct_with_one_field_twin_normal extends ffi.Struct { @ffi.Int32() external int a; 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 8bb5981b4c..534d597dc3 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 @@ -12,9 +12,11 @@ import 'api/async_misc.dart'; import 'api/async_spawn.dart'; import 'api/attribute.dart'; import 'api/benchmark_misc.dart'; +import 'api/casted_primitive.dart'; import 'api/chrono_type.dart'; import 'api/comment.dart'; import 'api/constructor.dart'; +import 'api/custom_ser_des.dart'; import 'api/customization.dart'; import 'api/dart_code.dart'; import 'api/dart_dynamic.dart'; @@ -949,6 +951,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { get rust_arc_decrement_strong_count_OpaqueTwoTwinSyncSseMoiPtr => wire .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi; + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethodPtr => + wire.rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod; + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_StaticGetterOnlyTwinNormalPtr => wire .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal; @@ -1606,6 +1612,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StaticGetterOnlyTwinNormal dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -2176,6 +2187,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StructInMiscNoTwinExampleA dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -2309,6 +2325,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String dco_decode_Backtrace(dynamic raw); + @protected + int dco_decode_CastedPrimitive_i_64(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_isize(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_u_64(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_usize(dynamic raw); + @protected String dco_decode_Char(dynamic raw); @@ -2324,6 +2352,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected DateTime dco_decode_Chrono_Utc(dynamic raw); + @protected + int dco_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + dynamic raw); + @protected FutureOr Function(Object) dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( @@ -3403,6 +3435,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StaticGetterOnlyTwinNormal dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -5505,6 +5542,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected StructInLowerLevel dco_decode_box_autoadd_struct_in_lower_level(dynamic raw); + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + dynamic raw); + @protected StructWithCommentsTwinNormal dco_decode_box_autoadd_struct_with_comments_twin_normal(dynamic raw); @@ -5535,6 +5577,36 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_box_autoadd_struct_with_custom_name_method_twin_normal( dynamic raw); + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async_sse( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSse + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sse( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSyncSse + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync_sse( + dynamic raw); + @protected StructWithEnumTwinNormal dco_decode_box_autoadd_struct_with_enum_twin_normal( dynamic raw); @@ -5619,6 +5691,33 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync_sse_moi( dynamic raw); + @protected + StructWithFieldRenameTwinNormal + dco_decode_box_autoadd_struct_with_field_rename_twin_normal(dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsyncSse + dco_decode_box_autoadd_struct_with_field_rename_twin_rust_async_sse( + dynamic raw); + + @protected + StructWithFieldRenameTwinSse + dco_decode_box_autoadd_struct_with_field_rename_twin_sse(dynamic raw); + + @protected + StructWithFieldRenameTwinSync + dco_decode_box_autoadd_struct_with_field_rename_twin_sync(dynamic raw); + + @protected + StructWithFieldRenameTwinSyncSse + dco_decode_box_autoadd_struct_with_field_rename_twin_sync_sse( + dynamic raw); + @protected StructWithGoodAndOpaqueFieldTwinMoi dco_decode_box_autoadd_struct_with_good_and_opaque_field_twin_moi( @@ -9074,6 +9173,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected StructInUpperLevel dco_decode_struct_in_upper_level(dynamic raw); + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_struct_with_casted_primitive_twin_normal(dynamic raw); + @protected StructWithCommentsTwinNormal dco_decode_struct_with_comments_twin_normal( dynamic raw); @@ -9102,6 +9205,31 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithCustomNameMethodTwinNormal dco_decode_struct_with_custom_name_method_twin_normal(dynamic raw); + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_struct_with_dart_keyword_field_twin_normal(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_struct_with_dart_keyword_field_twin_rust_async(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + dco_decode_struct_with_dart_keyword_field_twin_rust_async_sse( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSse + dco_decode_struct_with_dart_keyword_field_twin_sse(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_struct_with_dart_keyword_field_twin_sync(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSyncSse + dco_decode_struct_with_dart_keyword_field_twin_sync_sse(dynamic raw); + @protected StructWithEnumTwinNormal dco_decode_struct_with_enum_twin_normal(dynamic raw); @@ -9180,6 +9308,30 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_struct_with_explicit_auto_opaque_field_twin_sync_sse_moi( dynamic raw); + @protected + StructWithFieldRenameTwinNormal + dco_decode_struct_with_field_rename_twin_normal(dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_struct_with_field_rename_twin_rust_async(dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsyncSse + dco_decode_struct_with_field_rename_twin_rust_async_sse(dynamic raw); + + @protected + StructWithFieldRenameTwinSse dco_decode_struct_with_field_rename_twin_sse( + dynamic raw); + + @protected + StructWithFieldRenameTwinSync dco_decode_struct_with_field_rename_twin_sync( + dynamic raw); + + @protected + StructWithFieldRenameTwinSyncSse + dco_decode_struct_with_field_rename_twin_sync_sse(dynamic raw); + @protected StructWithGoodAndOpaqueFieldTwinMoi dco_decode_struct_with_good_and_opaque_field_twin_moi(dynamic raw); @@ -10118,6 +10270,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StaticGetterOnlyTwinNormal sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -10688,6 +10845,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StructInMiscNoTwinExampleA sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -10821,6 +10983,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String sse_decode_Backtrace(SseDeserializer deserializer); + @protected + int sse_decode_CastedPrimitive_i_64(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_isize(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_u_64(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_usize(SseDeserializer deserializer); + @protected String sse_decode_Char(SseDeserializer deserializer); @@ -10836,6 +11010,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected DateTime sse_decode_Chrono_Utc(SseDeserializer deserializer); + @protected + int sse_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + SseDeserializer deserializer); + @protected Object sse_decode_DartOpaque(SseDeserializer deserializer); @@ -11915,6 +12093,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StaticGetterOnlyTwinNormal sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -14209,6 +14392,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructInLowerLevel sse_decode_box_autoadd_struct_in_lower_level( SseDeserializer deserializer); + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer); + @protected StructWithCommentsTwinNormal sse_decode_box_autoadd_struct_with_comments_twin_normal( @@ -14244,6 +14432,36 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_box_autoadd_struct_with_custom_name_method_twin_normal( SseDeserializer deserializer); + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async_sse( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSse + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sse( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSyncSse + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync_sse( + SseDeserializer deserializer); + @protected StructWithEnumTwinNormal sse_decode_box_autoadd_struct_with_enum_twin_normal( SseDeserializer deserializer); @@ -14331,6 +14549,36 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync_sse_moi( SseDeserializer deserializer); + @protected + StructWithFieldRenameTwinNormal + sse_decode_box_autoadd_struct_with_field_rename_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsyncSse + sse_decode_box_autoadd_struct_with_field_rename_twin_rust_async_sse( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSse + sse_decode_box_autoadd_struct_with_field_rename_twin_sse( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSync + sse_decode_box_autoadd_struct_with_field_rename_twin_sync( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSyncSse + sse_decode_box_autoadd_struct_with_field_rename_twin_sync_sse( + SseDeserializer deserializer); + @protected StructWithGoodAndOpaqueFieldTwinMoi sse_decode_box_autoadd_struct_with_good_and_opaque_field_twin_moi( @@ -18271,6 +18519,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructInUpperLevel sse_decode_struct_in_upper_level( SseDeserializer deserializer); + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer); + @protected StructWithCommentsTwinNormal sse_decode_struct_with_comments_twin_normal( SseDeserializer deserializer); @@ -18302,6 +18555,36 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_struct_with_custom_name_method_twin_normal( SseDeserializer deserializer); + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsyncSse + sse_decode_struct_with_dart_keyword_field_twin_rust_async_sse( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSse + sse_decode_struct_with_dart_keyword_field_twin_sse( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSyncSse + sse_decode_struct_with_dart_keyword_field_twin_sync_sse( + SseDeserializer deserializer); + @protected StructWithEnumTwinNormal sse_decode_struct_with_enum_twin_normal( SseDeserializer deserializer); @@ -18387,6 +18670,34 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_struct_with_explicit_auto_opaque_field_twin_sync_sse_moi( SseDeserializer deserializer); + @protected + StructWithFieldRenameTwinNormal + sse_decode_struct_with_field_rename_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsyncSse + sse_decode_struct_with_field_rename_twin_rust_async_sse( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSse sse_decode_struct_with_field_rename_twin_sse( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSync sse_decode_struct_with_field_rename_twin_sync( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSyncSse + sse_decode_struct_with_field_rename_twin_sync_sse( + SseDeserializer deserializer); + @protected StructWithGoodAndOpaqueFieldTwinMoi sse_decode_struct_with_good_and_opaque_field_twin_moi( @@ -21444,6 +21755,29 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { return cst_encode_struct_with_custom_name_method_twin_normal(raw); } + @protected + List + cst_encode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_struct_with_dart_keyword_field_twin_normal(raw); + } + + @protected + List + cst_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_struct_with_dart_keyword_field_twin_rust_async(raw); + } + + @protected + List cst_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_struct_with_dart_keyword_field_twin_sync(raw); + } + @protected List cst_encode_box_autoadd_struct_with_enum_twin_normal( StructWithEnumTwinNormal raw) { @@ -21515,6 +21849,27 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { return cst_encode_struct_with_explicit_auto_opaque_field_twin_sync_moi(raw); } + @protected + List cst_encode_box_autoadd_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_struct_with_field_rename_twin_normal(raw); + } + + @protected + List cst_encode_box_autoadd_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_struct_with_field_rename_twin_rust_async(raw); + } + + @protected + List cst_encode_box_autoadd_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_struct_with_field_rename_twin_sync(raw); + } + @protected List cst_encode_box_autoadd_struct_with_good_and_opaque_field_twin_moi( @@ -24499,7 +24854,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { return [ cst_encode_String(raw.regular), cst_encode_String(raw.type), - cst_encode_bool(raw.async), + cst_encode_bool(raw.async_), cst_encode_String(raw.another) ]; } @@ -24511,7 +24866,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { return [ cst_encode_String(raw.regular), cst_encode_String(raw.type), - cst_encode_bool(raw.async), + cst_encode_bool(raw.async_), cst_encode_String(raw.another) ]; } @@ -24523,7 +24878,7 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { return [ cst_encode_String(raw.regular), cst_encode_String(raw.type), - cst_encode_bool(raw.async), + cst_encode_bool(raw.async_), cst_encode_String(raw.another) ]; } @@ -26202,6 +26557,27 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { return [cst_encode_i_32(raw.field0)]; } + @protected + List cst_encode_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return [cst_encode_i_32(raw.class_), cst_encode_i_64(raw.interface_)]; + } + + @protected + List cst_encode_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return [cst_encode_i_32(raw.class_), cst_encode_i_64(raw.interface_)]; + } + + @protected + List cst_encode_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return [cst_encode_i_32(raw.class_), cst_encode_i_64(raw.interface_)]; + } + @protected List cst_encode_struct_with_enum_twin_normal( StructWithEnumTwinNormal raw) { @@ -26300,6 +26676,27 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { ]; } + @protected + List cst_encode_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return [cst_encode_i_32(raw.renamed_field)]; + } + + @protected + List cst_encode_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return [cst_encode_i_32(raw.renamed_field)]; + } + + @protected + List cst_encode_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return [cst_encode_i_32(raw.renamed_field)]; + } + @protected List cst_encode_struct_with_good_and_opaque_field_twin_moi( StructWithGoodAndOpaqueFieldTwinMoi raw) { @@ -26978,6 +27375,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { int cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncMoi( OpaqueTwoTwinSyncMoi raw); + @protected + int cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod raw); + @protected int cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( StaticGetterOnlyTwinNormal raw); @@ -27318,6 +27719,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { int cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( OpaqueStructWithDartCodeTwinNormal raw); + @protected + int cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod raw); + @protected int cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( StructInMiscNoTwinExampleA raw); @@ -27813,6 +28218,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { int cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncMoi( OpaqueTwoTwinSyncMoi raw); + @protected + int cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod raw); + @protected int cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( StaticGetterOnlyTwinNormal raw); @@ -28560,6 +28969,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( OpaqueTwoTwinSyncSseMoi self, SseSerializer serializer); + @protected + void + sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -29154,6 +29568,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( OpaqueStructWithDartCodeTwinNormal self, SseSerializer serializer); + @protected + void + sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -29299,6 +29718,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_Backtrace(String self, SseSerializer serializer); + @protected + void sse_encode_CastedPrimitive_i_64(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_isize(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_u_64(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_usize(int self, SseSerializer serializer); + @protected void sse_encode_Char(String self, SseSerializer serializer); @@ -29314,6 +29745,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_Chrono_Utc(DateTime self, SseSerializer serializer); + @protected + void + sse_encode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + int self, SseSerializer serializer); + @protected void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer); @@ -30452,6 +30888,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( OpaqueTwoTwinSyncSseMoi self, SseSerializer serializer); + @protected + void + sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -32638,6 +33079,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_box_autoadd_struct_in_lower_level( StructInLowerLevel self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer); @@ -32666,6 +33111,32 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_box_autoadd_struct_with_custom_name_method_twin_normal( StructWithCustomNameMethodTwinNormal self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer); + + @protected + void + sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async_sse( + StructWithDartKeywordFieldTwinRustAsyncSse self, + SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sse( + StructWithDartKeywordFieldTwinSse self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync_sse( + StructWithDartKeywordFieldTwinSyncSse self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer); @@ -32756,6 +33227,30 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithExplicitAutoOpaqueFieldTwinSyncSseMoi self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_rust_async_sse( + StructWithFieldRenameTwinRustAsyncSse self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sse( + StructWithFieldRenameTwinSse self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sync_sse( + StructWithFieldRenameTwinSyncSse self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_moi( StructWithGoodAndOpaqueFieldTwinMoi self, SseSerializer serializer); @@ -36510,6 +37005,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_struct_in_upper_level( StructInUpperLevel self, SseSerializer serializer); + @protected + void sse_encode_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer); + @protected void sse_encode_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer); @@ -36538,6 +37037,31 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_struct_with_custom_name_method_twin_normal( StructWithCustomNameMethodTwinNormal self, SseSerializer serializer); + @protected + void sse_encode_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_rust_async_sse( + StructWithDartKeywordFieldTwinRustAsyncSse self, + SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sse( + StructWithDartKeywordFieldTwinSse self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sync_sse( + StructWithDartKeywordFieldTwinSyncSse self, SseSerializer serializer); + @protected void sse_encode_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer); @@ -36620,6 +37144,30 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithExplicitAutoOpaqueFieldTwinSyncSseMoi self, SseSerializer serializer); + @protected + void sse_encode_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_rust_async_sse( + StructWithFieldRenameTwinRustAsyncSse self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_sse( + StructWithFieldRenameTwinSse self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_sync_sse( + StructWithFieldRenameTwinSyncSse self, SseSerializer serializer); + @protected void sse_encode_struct_with_good_and_opaque_field_twin_moi( StructWithGoodAndOpaqueFieldTwinMoi self, SseSerializer serializer); @@ -37179,6 +37727,60 @@ class RustLibWire implements BaseWire { wasmModule .wire__crate__api__benchmark_misc__benchmark_void_semi_serialize(); + void wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal( + port_, ptr_, rust_vec_len_, data_len_); + + void wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal( + port_, ptr_, rust_vec_len_, data_len_); + + void wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal( + port_, ptr_, rust_vec_len_, data_len_); + + void wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal( + port_, ptr_, rust_vec_len_, data_len_); + + void wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal( + port_, ptr_, rust_vec_len_, data_len_); + + void wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal( + port_, ptr_, rust_vec_len_, data_len_); + void wire__crate__api__chrono_type__datetime_local_twin_normal( NativePortType port_, Object d) => wasmModule.wire__crate__api__chrono_type__datetime_local_twin_normal( @@ -37323,6 +37925,15 @@ class RustLibWire implements BaseWire { wasmModule .wire__crate__api__constructor__constructor_translatable_sync_struct_twin_normal_new(); + void wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer( + port_, ptr_, rust_vec_len_, data_len_); + void wire__crate__api__customization__check_init_done(NativePortType port_) => wasmModule.wire__crate__api__customization__check_init_done(port_); @@ -37888,6 +38499,19 @@ class RustLibWire implements BaseWire { NativePortType port_) => wasmModule.wire__crate__api__exception__throw_anyhow_twin_normal(port_); + dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ + wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new( + String a) => + wasmModule + .wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new( + a); + + void wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method( + NativePortType port_, Object that) => + wasmModule + .wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method( + port_, that); + void wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method( NativePortType port_, List that) => wasmModule @@ -56164,6 +56788,18 @@ class RustLibWire implements BaseWire { .wire__crate__api__pseudo_manual__stream_twin_sse__stream_sink_inside_vec_twin_sse( port_, ptr_, rust_vec_len_, data_len_); + void wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async( + NativePortType port_, List arg) => + wasmModule + .wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async( + port_, arg); + + void wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async( + NativePortType port_, List arg) => + wasmModule + .wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async( + port_, arg); + void wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async( NativePortType port_, List arg) => wasmModule @@ -56194,6 +56830,24 @@ class RustLibWire implements BaseWire { .wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_two_field_twin_rust_async( port_, arg); + void wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_sse( + port_, ptr_, rust_vec_len_, data_len_); + + void wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_sse( + port_, ptr_, rust_vec_len_, data_len_); + void wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_struct_with_one_field_twin_rust_async_sse( NativePortType port_, PlatformGeneralizedUint8ListPtr ptr_, @@ -56239,6 +56893,24 @@ class RustLibWire implements BaseWire { .wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_tuple_struct_with_two_field_twin_rust_async_sse( port_, ptr_, rust_vec_len_, data_len_); + void wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_sse( + port_, ptr_, rust_vec_len_, data_len_); + + void wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_twin_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_twin_sse( + port_, ptr_, rust_vec_len_, data_len_); + void wire__crate__api__pseudo_manual__structure_twin_sse__func_struct_with_one_field_twin_sse( NativePortType port_, PlatformGeneralizedUint8ListPtr ptr_, @@ -56284,6 +56956,20 @@ class RustLibWire implements BaseWire { .wire__crate__api__pseudo_manual__structure_twin_sse__func_tuple_struct_with_two_field_twin_sse( port_, ptr_, rust_vec_len_, data_len_); + dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ + wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync( + List arg) => + wasmModule + .wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync( + arg); + + dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ + wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync( + List arg) => + wasmModule + .wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync( + arg); + dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync( List arg) => @@ -56319,6 +57005,24 @@ class RustLibWire implements BaseWire { .wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync( arg); + dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartSse */ + wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse( + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse( + ptr_, rust_vec_len_, data_len_); + + dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartSse */ + wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse( + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_) => + wasmModule + .wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse( + ptr_, rust_vec_len_, data_len_); + dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartSse */ wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_struct_with_one_field_twin_sync_sse( PlatformGeneralizedUint8ListPtr ptr_, @@ -57141,6 +57845,18 @@ class RustLibWire implements BaseWire { .wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal( port_, sink); + void wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal( + NativePortType port_, List arg) => + wasmModule + .wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal( + port_, arg); + + void wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal( + NativePortType port_, List arg) => + wasmModule + .wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal( + port_, arg); + void wire__crate__api__structure__func_struct_with_one_field_twin_normal( NativePortType port_, List arg) => wasmModule @@ -59204,6 +59920,18 @@ class RustLibWire implements BaseWire { .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( ptr); + void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic ptr) => + wasmModule + .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr); + + void rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic ptr) => + wasmModule + .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr); + void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( dynamic ptr) => wasmModule @@ -59667,6 +60395,48 @@ class RustLibWasmModule { external dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartSse */ wire__crate__api__benchmark_misc__benchmark_void_semi_serialize(); + external void + wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + + external void + wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + + external void + wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + + external void + wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + + external void + wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + + external void + wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + external void wire__crate__api__chrono_type__datetime_local_twin_normal( NativePortType port_, Object d); @@ -59757,6 +60527,13 @@ class RustLibWasmModule { external dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ wire__crate__api__constructor__constructor_translatable_sync_struct_twin_normal_new(); + external void + wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + external void wire__crate__api__customization__check_init_done( NativePortType port_); @@ -60125,6 +60902,14 @@ class RustLibWasmModule { external void wire__crate__api__exception__throw_anyhow_twin_normal( NativePortType port_); + external dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ + wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new( + String a); + + external void + wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method( + NativePortType port_, Object that); + external void wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method( NativePortType port_, List that); @@ -72872,6 +73657,14 @@ class RustLibWasmModule { int rust_vec_len_, int data_len_); + external void + wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async( + NativePortType port_, List arg); + + external void + wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async( + NativePortType port_, List arg); + external void wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async( NativePortType port_, List arg); @@ -72892,6 +73685,20 @@ class RustLibWasmModule { wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_two_field_twin_rust_async( NativePortType port_, List arg); + external void + wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + + external void + wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + external void wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_struct_with_one_field_twin_rust_async_sse( NativePortType port_, @@ -72927,6 +73734,20 @@ class RustLibWasmModule { int rust_vec_len_, int data_len_); + external void + wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + + external void + wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_twin_sse( + NativePortType port_, + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + external void wire__crate__api__pseudo_manual__structure_twin_sse__func_struct_with_one_field_twin_sse( NativePortType port_, @@ -72962,6 +73783,14 @@ class RustLibWasmModule { int rust_vec_len_, int data_len_); + external dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ + wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync( + List arg); + + external dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ + wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync( + List arg); + external dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync( List arg); @@ -72982,6 +73811,18 @@ class RustLibWasmModule { wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync( List arg); + external dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartSse */ + wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse( + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + + external dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartSse */ + wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse( + PlatformGeneralizedUint8ListPtr ptr_, + int rust_vec_len_, + int data_len_); + external dynamic /* flutter_rust_bridge::for_generated::WireSyncRust2DartSse */ wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_struct_with_one_field_twin_sync_sse( PlatformGeneralizedUint8ListPtr ptr_, @@ -73530,6 +74371,14 @@ class RustLibWasmModule { wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal( NativePortType port_, String sink); + external void + wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal( + NativePortType port_, List arg); + + external void + wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal( + NativePortType port_, List arg); + external void wire__crate__api__structure__func_struct_with_one_field_twin_normal( NativePortType port_, List arg); @@ -74896,6 +75745,14 @@ class RustLibWasmModule { rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncSseMoi( dynamic ptr); + external void + rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic ptr); + + external void + rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic ptr); + external void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( dynamic ptr); diff --git a/frb_example/pure_dart/rust/src/api/casted_primitive.rs b/frb_example/pure_dart/rust/src/api/casted_primitive.rs new file mode 100644 index 0000000000..7bed3b530b --- /dev/null +++ b/frb_example/pure_dart/rust/src/api/casted_primitive.rs @@ -0,0 +1,48 @@ +// FRB_INTERNAL_GENERATOR: {"forbiddenDuplicatorModes": ["sync", "rustAsync", "sse", "sync sse", "rustAsync sse"]} + +use flutter_rust_bridge::frb; + +#[frb(serialize)] +#[frb(type_64bit_int)] +pub fn casted_primitive_i64_twin_normal(arg: i64) -> i64 { + arg +} + +#[frb(serialize)] +#[frb(type_64bit_int)] +pub fn casted_primitive_u64_twin_normal(arg: u64) -> u64 { + arg +} + +#[frb(serialize)] +#[frb(type_64bit_int)] +pub fn casted_primitive_isize_twin_normal(arg: isize) -> isize { + arg +} + +#[frb(serialize)] +#[frb(type_64bit_int)] +pub fn casted_primitive_usize_twin_normal(arg: usize) -> usize { + arg +} + +#[frb(serialize)] +#[frb(type_64bit_int)] +pub fn casted_primitive_multi_arg_twin_normal(a: i32, b: i64, c: usize, d: i128) { + let _ = (a, b, c, d); +} + +#[frb(type_64bit_int)] +pub struct StructWithCastedPrimitiveTwinNormal { + pub field_i64: i64, + pub field_u64: u64, + pub field_i32: i32, + pub field_vec_u8: Vec, +} + +#[frb(serialize)] +pub fn function_for_struct_with_casted_primitive_twin_normal( + arg: StructWithCastedPrimitiveTwinNormal, +) -> StructWithCastedPrimitiveTwinNormal { + arg +} diff --git a/frb_example/pure_dart/rust/src/api/custom_ser_des.rs b/frb_example/pure_dart/rust/src/api/custom_ser_des.rs new file mode 100644 index 0000000000..e837310b05 --- /dev/null +++ b/frb_example/pure_dart/rust/src/api/custom_ser_des.rs @@ -0,0 +1,25 @@ +// FRB_INTERNAL_GENERATOR: {"forbiddenDuplicatorModes": ["sync", "rustAsync", "sse", "sync sse", "rustAsync sse"]} + +use flutter_rust_bridge::frb; + +#[frb(opaque)] +pub struct MessageWithCustomSerializerTwinNormal(i32); + +#[frb(rust2dart(dart_type = "int", dart_code = "int.parse({})"))] +#[frb(serialize)] +pub fn serializer_my_type(raw: MessageWithCustomSerializerTwinNormal) -> String { + raw.0.to_string() +} + +#[frb(dart2rust(dart_type = "int", dart_code = "{}.toString()"))] +#[frb(serialize)] +pub fn deserializer_my_type(raw: String) -> MessageWithCustomSerializerTwinNormal { + MessageWithCustomSerializerTwinNormal(raw.parse().unwrap()) +} + +#[frb(serialize)] +pub fn function_using_type_with_custom_serializer( + arg: MessageWithCustomSerializerTwinNormal, +) -> MessageWithCustomSerializerTwinNormal { + arg +} diff --git a/frb_example/pure_dart/rust/src/api/mod.rs b/frb_example/pure_dart/rust/src/api/mod.rs index 860b073e37..a05390f79c 100644 --- a/frb_example/pure_dart/rust/src/api/mod.rs +++ b/frb_example/pure_dart/rust/src/api/mod.rs @@ -4,12 +4,14 @@ pub mod async_misc; pub mod async_spawn; pub mod attribute; pub mod benchmark_misc; +pub mod casted_primitive; pub mod chrono_type; pub mod comment; #[cfg(target_os = "non_existent_os")] pub mod conditionally_compiled_module; pub mod constructor; pub mod custom_handler; +pub mod custom_ser_des; pub mod customization; pub mod dart_code; pub mod dart_dynamic; diff --git a/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_rust_async.rs b/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_rust_async.rs index 05e344088b..64998973ae 100644 --- a/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_rust_async.rs +++ b/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_rust_async.rs @@ -2,6 +2,8 @@ // and is auto-generated from `structure.rs` by frb_internal // Please do not modify manually, but modify the origin and re-run frb_internal generator +use flutter_rust_bridge::frb; + pub struct StructWithZeroFieldTwinRustAsync {} pub async fn func_struct_with_zero_field_twin_rust_async( @@ -46,3 +48,26 @@ pub async fn func_tuple_struct_with_two_field_twin_rust_async( ) -> TupleStructWithTwoFieldTwinRustAsync { arg } + +#[frb] +pub struct StructWithFieldRenameTwinRustAsync { + #[frb(name = "renamed_field")] + pub class: i32, +} + +pub async fn func_for_struct_with_field_rename_twin_rust_async( + arg: StructWithFieldRenameTwinRustAsync, +) -> StructWithFieldRenameTwinRustAsync { + arg +} + +pub struct StructWithDartKeywordFieldTwinRustAsync { + pub class: i32, + pub interface: i64, +} + +pub async fn func_for_struct_with_dart_keyword_field_twin_rust_async( + arg: StructWithDartKeywordFieldTwinRustAsync, +) -> StructWithDartKeywordFieldTwinRustAsync { + arg +} diff --git a/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_rust_async_sse.rs b/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_rust_async_sse.rs index 43f4e574f9..60fc5db02d 100644 --- a/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_rust_async_sse.rs +++ b/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_rust_async_sse.rs @@ -2,6 +2,8 @@ // and is auto-generated from `structure.rs` by frb_internal // Please do not modify manually, but modify the origin and re-run frb_internal generator +use flutter_rust_bridge::frb; + pub struct StructWithZeroFieldTwinRustAsyncSse {} #[flutter_rust_bridge::frb(serialize)] @@ -51,3 +53,28 @@ pub async fn func_tuple_struct_with_two_field_twin_rust_async_sse( ) -> TupleStructWithTwoFieldTwinRustAsyncSse { arg } + +#[frb] +pub struct StructWithFieldRenameTwinRustAsyncSse { + #[frb(name = "renamed_field")] + pub class: i32, +} + +#[flutter_rust_bridge::frb(serialize)] +pub async fn func_for_struct_with_field_rename_twin_rust_async_sse( + arg: StructWithFieldRenameTwinRustAsyncSse, +) -> StructWithFieldRenameTwinRustAsyncSse { + arg +} + +pub struct StructWithDartKeywordFieldTwinRustAsyncSse { + pub class: i32, + pub interface: i64, +} + +#[flutter_rust_bridge::frb(serialize)] +pub async fn func_for_struct_with_dart_keyword_field_twin_rust_async_sse( + arg: StructWithDartKeywordFieldTwinRustAsyncSse, +) -> StructWithDartKeywordFieldTwinRustAsyncSse { + arg +} diff --git a/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sse.rs b/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sse.rs index da5b308543..9f6f0ed96e 100644 --- a/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sse.rs +++ b/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sse.rs @@ -2,6 +2,8 @@ // and is auto-generated from `structure.rs` by frb_internal // Please do not modify manually, but modify the origin and re-run frb_internal generator +use flutter_rust_bridge::frb; + pub struct StructWithZeroFieldTwinSse {} #[flutter_rust_bridge::frb(serialize)] @@ -51,3 +53,28 @@ pub fn func_tuple_struct_with_two_field_twin_sse( ) -> TupleStructWithTwoFieldTwinSse { arg } + +#[frb] +pub struct StructWithFieldRenameTwinSse { + #[frb(name = "renamed_field")] + pub class: i32, +} + +#[flutter_rust_bridge::frb(serialize)] +pub fn func_for_struct_with_field_rename_twin_sse( + arg: StructWithFieldRenameTwinSse, +) -> StructWithFieldRenameTwinSse { + arg +} + +pub struct StructWithDartKeywordFieldTwinSse { + pub class: i32, + pub interface: i64, +} + +#[flutter_rust_bridge::frb(serialize)] +pub fn func_for_struct_with_dart_keyword_field_twin_sse( + arg: StructWithDartKeywordFieldTwinSse, +) -> StructWithDartKeywordFieldTwinSse { + arg +} diff --git a/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sync.rs b/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sync.rs index ec1d3294cf..8b6392b339 100644 --- a/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sync.rs +++ b/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sync.rs @@ -2,6 +2,8 @@ // and is auto-generated from `structure.rs` by frb_internal // Please do not modify manually, but modify the origin and re-run frb_internal generator +use flutter_rust_bridge::frb; + pub struct StructWithZeroFieldTwinSync {} #[flutter_rust_bridge::frb(sync)] @@ -51,3 +53,28 @@ pub fn func_tuple_struct_with_two_field_twin_sync( ) -> TupleStructWithTwoFieldTwinSync { arg } + +#[frb] +pub struct StructWithFieldRenameTwinSync { + #[frb(name = "renamed_field")] + pub class: i32, +} + +#[flutter_rust_bridge::frb(sync)] +pub fn func_for_struct_with_field_rename_twin_sync( + arg: StructWithFieldRenameTwinSync, +) -> StructWithFieldRenameTwinSync { + arg +} + +pub struct StructWithDartKeywordFieldTwinSync { + pub class: i32, + pub interface: i64, +} + +#[flutter_rust_bridge::frb(sync)] +pub fn func_for_struct_with_dart_keyword_field_twin_sync( + arg: StructWithDartKeywordFieldTwinSync, +) -> StructWithDartKeywordFieldTwinSync { + arg +} diff --git a/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sync_sse.rs b/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sync_sse.rs index 95222ee934..378453829b 100644 --- a/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sync_sse.rs +++ b/frb_example/pure_dart/rust/src/api/pseudo_manual/structure_twin_sync_sse.rs @@ -2,6 +2,8 @@ // and is auto-generated from `structure.rs` by frb_internal // Please do not modify manually, but modify the origin and re-run frb_internal generator +use flutter_rust_bridge::frb; + pub struct StructWithZeroFieldTwinSyncSse {} #[flutter_rust_bridge::frb(serialize)] @@ -56,3 +58,30 @@ pub fn func_tuple_struct_with_two_field_twin_sync_sse( ) -> TupleStructWithTwoFieldTwinSyncSse { arg } + +#[frb] +pub struct StructWithFieldRenameTwinSyncSse { + #[frb(name = "renamed_field")] + pub class: i32, +} + +#[flutter_rust_bridge::frb(serialize)] +#[flutter_rust_bridge::frb(sync)] +pub fn func_for_struct_with_field_rename_twin_sync_sse( + arg: StructWithFieldRenameTwinSyncSse, +) -> StructWithFieldRenameTwinSyncSse { + arg +} + +pub struct StructWithDartKeywordFieldTwinSyncSse { + pub class: i32, + pub interface: i64, +} + +#[flutter_rust_bridge::frb(serialize)] +#[flutter_rust_bridge::frb(sync)] +pub fn func_for_struct_with_dart_keyword_field_twin_sync_sse( + arg: StructWithDartKeywordFieldTwinSyncSse, +) -> StructWithDartKeywordFieldTwinSyncSse { + arg +} diff --git a/frb_example/pure_dart/rust/src/api/structure.rs b/frb_example/pure_dart/rust/src/api/structure.rs index b5e9d80d9b..f9146d79b0 100644 --- a/frb_example/pure_dart/rust/src/api/structure.rs +++ b/frb_example/pure_dart/rust/src/api/structure.rs @@ -1,3 +1,5 @@ +use flutter_rust_bridge::frb; + pub struct StructWithZeroFieldTwinNormal {} pub fn func_struct_with_zero_field_twin_normal( @@ -42,3 +44,26 @@ pub fn func_tuple_struct_with_two_field_twin_normal( ) -> TupleStructWithTwoFieldTwinNormal { arg } + +#[frb] +pub struct StructWithFieldRenameTwinNormal { + #[frb(name = "renamed_field")] + pub class: i32, +} + +pub fn func_for_struct_with_field_rename_twin_normal( + arg: StructWithFieldRenameTwinNormal, +) -> StructWithFieldRenameTwinNormal { + arg +} + +pub struct StructWithDartKeywordFieldTwinNormal { + pub class: i32, + pub interface: i64, +} + +pub fn func_for_struct_with_dart_keyword_field_twin_normal( + arg: StructWithDartKeywordFieldTwinNormal, +) -> StructWithDartKeywordFieldTwinNormal { + arg +} 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 392915959f..d1e6b5e14d 100644 --- a/frb_example/pure_dart/rust/src/frb_generated.io.rs +++ b/frb_example/pure_dart/rust/src/frb_generated.io.rs @@ -5,10 +5,12 @@ use super::*; use crate::api::constructor::*; +use crate::api::custom_ser_des::*; use crate::api::dart_code::*; use crate::api::dropping::*; use crate::api::dyn_trait::SimpleTraitForDynTwinNormal; use crate::api::dyn_trait::*; +use crate::api::external_impl::*; use crate::api::impl_trait::SimpleTraitTwinNormal; use crate::api::impl_trait::*; use crate::api::method::*; @@ -751,6 +753,20 @@ impl CstDecode for usize { )) } } +impl CstDecode for usize { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> SimpleOpaqueExternalStructWithMethod { + flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::< + RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >, + >::cst_decode( + self + )) + } +} impl CstDecode for usize { // Codec=Cst (C-struct based), see doc to use other codecs fn cst_decode(self) -> StaticGetterOnlyTwinNormal { @@ -2753,6 +2769,26 @@ impl decode_rust_opaque_moi(self as _) } } +impl + CstDecode< + RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >, + > for usize +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + > { + unsafe { decode_rust_opaque_nom(self as _) } + } +} impl CstDecode< RustOpaqueNom< @@ -6233,6 +6269,37 @@ impl CstDecode::cst_decode(*wrap).into() } } +impl CstDecode + for *mut wire_cst_struct_with_dart_keyword_field_twin_normal +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::structure::StructWithDartKeywordFieldTwinNormal { + let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }; + CstDecode::::cst_decode(*wrap) + .into() + } +} +impl CstDecode for *mut wire_cst_struct_with_dart_keyword_field_twin_rust_async { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }; + CstDecode::::cst_decode(*wrap).into() + } + } +impl CstDecode + for *mut wire_cst_struct_with_dart_keyword_field_twin_sync +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync { + let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }; + CstDecode::< + crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync, + >::cst_decode(*wrap) + .into() + } +} impl CstDecode for *mut wire_cst_struct_with_enum_twin_normal { @@ -6313,6 +6380,41 @@ impl CstDecode::cst_decode(*wrap).into() } } +impl CstDecode + for *mut wire_cst_struct_with_field_rename_twin_normal +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::structure::StructWithFieldRenameTwinNormal { + let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }; + CstDecode::::cst_decode(*wrap) + .into() + } +} +impl + CstDecode< + crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync, + > for *mut wire_cst_struct_with_field_rename_twin_rust_async +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync + { + let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }; + CstDecode::::cst_decode(*wrap).into() + } +} +impl CstDecode + for *mut wire_cst_struct_with_field_rename_twin_sync +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }; + CstDecode::::cst_decode(*wrap).into() + } +} impl CstDecode< crate::api::pseudo_manual::rust_auto_opaque_twin_moi::StructWithGoodAndOpaqueFieldTwinMoi, @@ -11980,6 +12082,36 @@ impl CstDecode + for wire_cst_struct_with_dart_keyword_field_twin_normal +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::structure::StructWithDartKeywordFieldTwinNormal { + crate::api::structure::StructWithDartKeywordFieldTwinNormal { + class: self.class.cst_decode(), + interface: self.interface.cst_decode(), + } + } +} +impl CstDecode for wire_cst_struct_with_dart_keyword_field_twin_rust_async { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync{class: self.class.cst_decode(),interface: self.interface.cst_decode()} + } + } +impl CstDecode + for wire_cst_struct_with_dart_keyword_field_twin_sync +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync { + crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync { + class: self.class.cst_decode(), + interface: self.interface.cst_decode(), + } + } +} impl CstDecode for wire_cst_struct_with_enum_twin_normal { @@ -12060,6 +12192,43 @@ impl CstDecode + for wire_cst_struct_with_field_rename_twin_normal +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::structure::StructWithFieldRenameTwinNormal { + crate::api::structure::StructWithFieldRenameTwinNormal { + class: self.class.cst_decode(), + } + } +} +impl + CstDecode< + crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync, + > for wire_cst_struct_with_field_rename_twin_rust_async +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync + { + crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync { + class: self.class.cst_decode(), + } + } +} +impl CstDecode + for wire_cst_struct_with_field_rename_twin_sync +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + class: self.class.cst_decode(), + } + } +} impl CstDecode< crate::api::pseudo_manual::rust_auto_opaque_twin_moi::StructWithGoodAndOpaqueFieldTwinMoi, @@ -16154,6 +16323,45 @@ impl Default for wire_cst_struct_with_custom_name_method_twin_normal { Self::new_with_null_ptr() } } +impl NewWithNullPtr for wire_cst_struct_with_dart_keyword_field_twin_normal { + fn new_with_null_ptr() -> Self { + Self { + class: Default::default(), + interface: Default::default(), + } + } +} +impl Default for wire_cst_struct_with_dart_keyword_field_twin_normal { + fn default() -> Self { + Self::new_with_null_ptr() + } +} +impl NewWithNullPtr for wire_cst_struct_with_dart_keyword_field_twin_rust_async { + fn new_with_null_ptr() -> Self { + Self { + class: Default::default(), + interface: Default::default(), + } + } +} +impl Default for wire_cst_struct_with_dart_keyword_field_twin_rust_async { + fn default() -> Self { + Self::new_with_null_ptr() + } +} +impl NewWithNullPtr for wire_cst_struct_with_dart_keyword_field_twin_sync { + fn new_with_null_ptr() -> Self { + Self { + class: Default::default(), + interface: Default::default(), + } + } +} +impl Default for wire_cst_struct_with_dart_keyword_field_twin_sync { + fn default() -> Self { + Self::new_with_null_ptr() + } +} impl NewWithNullPtr for wire_cst_struct_with_enum_twin_normal { fn new_with_null_ptr() -> Self { Self { @@ -16271,6 +16479,42 @@ impl Default for wire_cst_struct_with_explicit_auto_opaque_field_twin_sync_moi { Self::new_with_null_ptr() } } +impl NewWithNullPtr for wire_cst_struct_with_field_rename_twin_normal { + fn new_with_null_ptr() -> Self { + Self { + class: Default::default(), + } + } +} +impl Default for wire_cst_struct_with_field_rename_twin_normal { + fn default() -> Self { + Self::new_with_null_ptr() + } +} +impl NewWithNullPtr for wire_cst_struct_with_field_rename_twin_rust_async { + fn new_with_null_ptr() -> Self { + Self { + class: Default::default(), + } + } +} +impl Default for wire_cst_struct_with_field_rename_twin_rust_async { + fn default() -> Self { + Self::new_with_null_ptr() + } +} +impl NewWithNullPtr for wire_cst_struct_with_field_rename_twin_sync { + fn new_with_null_ptr() -> Self { + Self { + class: Default::default(), + } + } +} +impl Default for wire_cst_struct_with_field_rename_twin_sync { + fn default() -> Self { + Self::new_with_null_ptr() + } +} impl NewWithNullPtr for wire_cst_struct_with_good_and_opaque_field_twin_moi { fn new_with_null_ptr() -> Self { Self { @@ -16997,6 +17241,96 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__benchmark_misc_ wire__crate__api__benchmark_misc__benchmark_void_semi_serialize_impl() } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__chrono_type__datetime_local_twin_normal( port_: i64, @@ -17191,6 +17525,21 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__constructor__co wire__crate__api__constructor__constructor_translatable_sync_struct_twin_normal_new_impl() } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__customization__check_init_done( port_: i64, @@ -17974,6 +18323,21 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__exception__thro wire__crate__api__exception__throw_anyhow_twin_normal_impl(port_) } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new( + a: *mut wire_cst_list_prim_u_8_strict, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new_impl(a) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method( + port_: i64, + that: usize, +) { + wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method_impl(port_, that) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method( port_: i64, @@ -40703,6 +41067,22 @@ 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__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async( + port_: i64, + arg: *mut wire_cst_struct_with_dart_keyword_field_twin_rust_async, +) { + wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async_impl(port_, arg) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async( + port_: i64, + arg: *mut wire_cst_struct_with_field_rename_twin_rust_async, +) { + wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async_impl(port_, arg) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async( port_: i64, @@ -40743,6 +41123,26 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__ wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_two_field_twin_rust_async_impl(port_, arg) } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_sse( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_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__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_sse( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_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__structure_twin_rust_async_sse__func_struct_with_one_field_twin_rust_async_sse( port_: i64, @@ -40793,6 +41193,26 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__ wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_tuple_struct_with_two_field_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__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_sse( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_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__structure_twin_sse__func_for_struct_with_field_rename_twin_sse( + port_: i64, + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_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__structure_twin_sse__func_struct_with_one_field_twin_sse( port_: i64, @@ -40858,6 +41278,20 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__ wire__crate__api__pseudo_manual__structure_twin_sse__func_tuple_struct_with_two_field_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__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync( + arg: *mut wire_cst_struct_with_dart_keyword_field_twin_sync, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync_impl(arg) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync( + arg: *mut wire_cst_struct_with_field_rename_twin_sync, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync_impl(arg) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync( arg: *mut wire_cst_struct_with_one_field_twin_sync, @@ -40899,6 +41333,24 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__ wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync_impl(arg) } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse( + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse_impl(ptr_, rust_vec_len_, data_len_) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse( + ptr_: *mut u8, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse_impl(ptr_, rust_vec_len_, data_len_) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_struct_with_one_field_twin_sync_sse( ptr_: *mut u8, @@ -42040,6 +42492,24 @@ pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__stream_misc__st wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal_impl(port_, sink) } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal( + port_: i64, + arg: *mut wire_cst_struct_with_dart_keyword_field_twin_normal, +) { + wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal_impl( + port_, arg, + ) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal( + port_: i64, + arg: *mut wire_cst_struct_with_field_rename_twin_normal, +) { + wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal_impl(port_, arg) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_wire__crate__api__structure__func_struct_with_one_field_twin_normal( port_: i64, @@ -45160,6 +45630,32 @@ pub extern "C" fn frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_R MoiArc::>::decrement_strong_count(ptr as _); } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr: *const std::ffi::c_void, +) { + unsafe { + StdArc::< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >::increment_strong_count(ptr as _); + } +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr: *const std::ffi::c_void, +) { + unsafe { + StdArc::< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >::decrement_strong_count(ptr as _); + } +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( ptr: *const std::ffi::c_void, @@ -47373,6 +47869,30 @@ pub extern "C" fn frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_c ) } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_normal( +) -> *mut wire_cst_struct_with_dart_keyword_field_twin_normal { + flutter_rust_bridge::for_generated::new_leak_box_ptr( + wire_cst_struct_with_dart_keyword_field_twin_normal::new_with_null_ptr(), + ) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( +) -> *mut wire_cst_struct_with_dart_keyword_field_twin_rust_async { + flutter_rust_bridge::for_generated::new_leak_box_ptr( + wire_cst_struct_with_dart_keyword_field_twin_rust_async::new_with_null_ptr(), + ) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_dart_keyword_field_twin_sync( +) -> *mut wire_cst_struct_with_dart_keyword_field_twin_sync { + flutter_rust_bridge::for_generated::new_leak_box_ptr( + wire_cst_struct_with_dart_keyword_field_twin_sync::new_with_null_ptr(), + ) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_enum_twin_normal( ) -> *mut wire_cst_struct_with_enum_twin_normal { @@ -47445,6 +47965,30 @@ pub extern "C" fn frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_e ) } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_normal( +) -> *mut wire_cst_struct_with_field_rename_twin_normal { + flutter_rust_bridge::for_generated::new_leak_box_ptr( + wire_cst_struct_with_field_rename_twin_normal::new_with_null_ptr(), + ) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_rust_async( +) -> *mut wire_cst_struct_with_field_rename_twin_rust_async { + flutter_rust_bridge::for_generated::new_leak_box_ptr( + wire_cst_struct_with_field_rename_twin_rust_async::new_with_null_ptr(), + ) +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_field_rename_twin_sync( +) -> *mut wire_cst_struct_with_field_rename_twin_sync { + flutter_rust_bridge::for_generated::new_leak_box_ptr( + wire_cst_struct_with_field_rename_twin_sync::new_with_null_ptr(), + ) +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_cst_new_box_autoadd_struct_with_good_and_opaque_field_twin_moi( ) -> *mut wire_cst_struct_with_good_and_opaque_field_twin_moi { @@ -53389,6 +53933,24 @@ pub struct wire_cst_struct_with_custom_name_method_twin_normal { } #[repr(C)] #[derive(Clone, Copy)] +pub struct wire_cst_struct_with_dart_keyword_field_twin_normal { + class: i32, + interface: i64, +} +#[repr(C)] +#[derive(Clone, Copy)] +pub struct wire_cst_struct_with_dart_keyword_field_twin_rust_async { + class: i32, + interface: i64, +} +#[repr(C)] +#[derive(Clone, Copy)] +pub struct wire_cst_struct_with_dart_keyword_field_twin_sync { + class: i32, + interface: i64, +} +#[repr(C)] +#[derive(Clone, Copy)] pub struct wire_cst_struct_with_enum_twin_normal { abc1: wire_cst_abc_twin_normal, abc2: wire_cst_abc_twin_normal, @@ -53443,6 +54005,21 @@ pub struct wire_cst_struct_with_explicit_auto_opaque_field_twin_sync_moi { } #[repr(C)] #[derive(Clone, Copy)] +pub struct wire_cst_struct_with_field_rename_twin_normal { + class: i32, +} +#[repr(C)] +#[derive(Clone, Copy)] +pub struct wire_cst_struct_with_field_rename_twin_rust_async { + class: i32, +} +#[repr(C)] +#[derive(Clone, Copy)] +pub struct wire_cst_struct_with_field_rename_twin_sync { + class: i32, +} +#[repr(C)] +#[derive(Clone, Copy)] pub struct wire_cst_struct_with_good_and_opaque_field_twin_moi { good: *mut wire_cst_list_prim_u_8_strict, opaque: usize, diff --git a/frb_example/pure_dart/rust/src/frb_generated.rs b/frb_example/pure_dart/rust/src/frb_generated.rs index a9d94f5572..c742d64844 100644 --- a/frb_example/pure_dart/rust/src/frb_generated.rs +++ b/frb_example/pure_dart/rust/src/frb_generated.rs @@ -22,10 +22,12 @@ // Section: imports use crate::api::constructor::*; +use crate::api::custom_ser_des::*; use crate::api::dart_code::*; use crate::api::dropping::*; use crate::api::dyn_trait::SimpleTraitForDynTwinNormal; use crate::api::dyn_trait::*; +use crate::api::external_impl::*; use crate::api::impl_trait::SimpleTraitTwinNormal; use crate::api::impl_trait::*; use crate::api::method::*; @@ -88,7 +90,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.38"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1702726439; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -2031266698; // Section: executor @@ -526,6 +528,196 @@ fn wire__crate__api__benchmark_misc__benchmark_void_semi_serialize_impl( }, ) } +fn wire__crate__api__casted_primitive__casted_primitive_i64_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: "casted_primitive_i64_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::casted_primitive::casted_primitive_i64_twin_normal(api_arg), + ) + })()) + } + }, + ) +} +fn wire__crate__api__casted_primitive__casted_primitive_isize_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: "casted_primitive_isize_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::casted_primitive::casted_primitive_isize_twin_normal(api_arg), + ) + })()) + } + }, + ) +} +fn wire__crate__api__casted_primitive__casted_primitive_multi_arg_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: "casted_primitive_multi_arg_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_a = ::sse_decode(&mut deserializer); + let api_b = ::sse_decode(&mut deserializer); + let api_c = ::sse_decode(&mut deserializer); + let api_d = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse((move || { + Result::<_, ()>::Ok({ + crate::api::casted_primitive::casted_primitive_multi_arg_twin_normal( + api_a, api_b, api_c, api_d, + ); + }) + })()) + } + }, + ) +} +fn wire__crate__api__casted_primitive__casted_primitive_u64_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: "casted_primitive_u64_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::casted_primitive::casted_primitive_u64_twin_normal(api_arg), + ) + })()) + } + }, + ) +} +fn wire__crate__api__casted_primitive__casted_primitive_usize_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: "casted_primitive_usize_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::casted_primitive::casted_primitive_usize_twin_normal(api_arg), + ) + })()) + } + }, + ) +} +fn wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_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_for_struct_with_casted_primitive_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::casted_primitive::function_for_struct_with_casted_primitive_twin_normal(api_arg)) + })()) + } }) +} fn wire__crate__api__chrono_type__datetime_local_twin_normal_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, d: impl CstDecode>, @@ -1103,6 +1295,42 @@ fn wire__crate__api__constructor__constructor_translatable_sync_struct_twin_norm }, ) } +fn wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer_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_using_type_with_custom_serializer", + 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::custom_ser_des::function_using_type_with_custom_serializer( + api_arg, + ), + ) + })()) + } + }, + ) +} fn wire__crate__api__customization__check_init_done_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, ) { @@ -3114,6 +3342,50 @@ fn wire__crate__api__exception__throw_anyhow_twin_normal_impl( }, ) } +fn wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new_impl( + a: impl CstDecode, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "SimpleOpaqueExternalStructWithMethod_new", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let api_a = a.cst_decode(); + transform_result_dco((move || { + Result::<_, ()>::Ok( + crate::api::external_impl::SimpleOpaqueExternalStructWithMethod::new(api_a), + ) + })()) + }, + ) +} +fn wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + that: impl CstDecode< + RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >, + >, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "SimpleOpaqueExternalStructWithMethod_simple_external_method", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal }, move || { let api_that = that.cst_decode(); move |context| { + transform_result_dco((move || { + let mut api_that_decoded = None; +let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]); + for i in decode_indices_ { + match i { + 0 => api_that_decoded = Some(api_that.lockable_decode_sync_ref()), + _ => unreachable!(), + } + } + let api_that = &*api_that_decoded.unwrap(); + Result::<_,()>::Ok(crate::api::external_impl::SimpleOpaqueExternalStructWithMethod::simple_external_method(api_that)) + })()) + } }) +} fn wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, that: impl CstDecode, @@ -41417,6 +41689,28 @@ fn wire__crate__api__pseudo_manual__stream_twin_sse__stream_sink_inside_vec_twin }, ) } +fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_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: "func_for_struct_with_dart_keyword_field_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::structure_twin_rust_async::func_for_struct_with_dart_keyword_field_twin_rust_async(api_arg).await) + })().await) + } }) +} +fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + arg: impl CstDecode< + crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync, + >, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "func_for_struct_with_field_rename_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::structure_twin_rust_async::func_for_struct_with_field_rename_twin_rust_async(api_arg).await) + })().await) + } }) +} fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, arg: impl CstDecode< @@ -41477,6 +41771,36 @@ fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct })().await) } }) } +fn wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_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: "func_for_struct_with_dart_keyword_field_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::structure_twin_rust_async_sse::func_for_struct_with_dart_keyword_field_twin_rust_async_sse(api_arg).await) + })().await) + } }) +} +fn wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_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: "func_for_struct_with_field_rename_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::structure_twin_rust_async_sse::func_for_struct_with_field_rename_twin_rust_async_sse(api_arg).await) + })().await) + } }) +} fn wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_struct_with_one_field_twin_rust_async_sse_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -41552,6 +41876,36 @@ fn wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_tuple_st })().await) } }) } +fn wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_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: "func_for_struct_with_dart_keyword_field_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::structure_twin_sse::func_for_struct_with_dart_keyword_field_twin_sse(api_arg)) + })()) + } }) +} +fn wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_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: "func_for_struct_with_field_rename_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::structure_twin_sse::func_for_struct_with_field_rename_twin_sse(api_arg)) + })()) + } }) +} fn wire__crate__api__pseudo_manual__structure_twin_sse__func_struct_with_one_field_twin_sse_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -41627,6 +41981,24 @@ fn wire__crate__api__pseudo_manual__structure_twin_sse__func_tuple_struct_with_t })()) } }) } +fn wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync_impl( + arg: impl CstDecode< + crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync, + >, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "func_for_struct_with_dart_keyword_field_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::structure_twin_sync::func_for_struct_with_dart_keyword_field_twin_sync(api_arg)) + })()) }) +} +fn wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_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: "func_for_struct_with_field_rename_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::structure_twin_sync::func_for_struct_with_field_rename_twin_sync(api_arg)) + })()) }) +} fn wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync_impl( arg: impl CstDecode, ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { @@ -41667,6 +42039,32 @@ fn wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_ Result::<_,()>::Ok(crate::api::pseudo_manual::structure_twin_sync::func_tuple_struct_with_two_field_twin_sync(api_arg)) })()) }) } +fn wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_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: "func_for_struct_with_dart_keyword_field_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::structure_twin_sync_sse::func_for_struct_with_dart_keyword_field_twin_sync_sse(api_arg)) + })()) }) +} +fn wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_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: "func_for_struct_with_field_rename_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::structure_twin_sync_sse::func_for_struct_with_field_rename_twin_sync_sse(api_arg)) + })()) }) +} fn wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_struct_with_one_field_twin_sync_sse_impl( ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, @@ -44187,6 +44585,54 @@ fn wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal_impl( }, ) } +fn wire__crate__api__structure__func_for_struct_with_dart_keyword_field_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: "func_for_struct_with_dart_keyword_field_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::structure::func_for_struct_with_dart_keyword_field_twin_normal( + api_arg, + ), + ) + })()) + } + }, + ) +} +fn wire__crate__api__structure__func_for_struct_with_field_rename_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: "func_for_struct_with_field_rename_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::structure::func_for_struct_with_field_rename_twin_normal( + api_arg, + ), + ) + })()) + } + }, + ) +} fn wire__crate__api__structure__func_struct_with_one_field_twin_normal_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, arg: impl CstDecode, @@ -47025,6 +47471,18 @@ impl SseDecode for OpaqueTwoTwinSyncSseMoi { } } +impl SseDecode for SimpleOpaqueExternalStructWithMethod { + // 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 flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner); + } +} + impl SseDecode for StaticGetterOnlyTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -47438,6 +47896,14 @@ impl SseDecode for chrono::DateTime { } } +impl SseDecode for MessageWithCustomSerializerTwinNormal { + // 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 crate::api::custom_ser_des::deserializer_my_type(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 { @@ -49912,6 +50378,20 @@ impl SseDecode } } +impl SseDecode + for RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + > +{ + // 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 { decode_rust_opaque_nom(inner) }; + } +} + impl SseDecode for RustOpaqueNom< flutter_rust_bridge::for_generated::RustAutoOpaqueInner, @@ -59987,12 +60467,12 @@ impl SseDecode for crate::api::raw_string::MoreThanJustOneRawStringStructTwinNor fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { let mut var_regular = ::sse_decode(deserializer); let mut var_type = ::sse_decode(deserializer); - let mut var_async = ::sse_decode(deserializer); + let mut var_async_ = ::sse_decode(deserializer); let mut var_another = ::sse_decode(deserializer); return crate::api::raw_string::MoreThanJustOneRawStringStructTwinNormal { regular: var_regular, r#type: var_type, - r#async: var_async, + r#async: var_async_, another: var_another, }; } @@ -60002,18 +60482,18 @@ impl SseDecode for crate::api::pseudo_manual::raw_string_twin_rust_async::MoreTh // 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_regular = ::sse_decode(deserializer); let mut var_type = ::sse_decode(deserializer); -let mut var_async = ::sse_decode(deserializer); +let mut var_async_ = ::sse_decode(deserializer); let mut var_another = ::sse_decode(deserializer); -return crate::api::pseudo_manual::raw_string_twin_rust_async::MoreThanJustOneRawStringStructTwinRustAsync{regular: var_regular, r#type: var_type, r#async: var_async, another: var_another};} +return crate::api::pseudo_manual::raw_string_twin_rust_async::MoreThanJustOneRawStringStructTwinRustAsync{regular: var_regular, r#type: var_type, r#async: var_async_, another: var_another};} } impl SseDecode for crate::api::pseudo_manual::raw_string_twin_rust_async_sse::MoreThanJustOneRawStringStructTwinRustAsyncSse { // 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_regular = ::sse_decode(deserializer); let mut var_type = ::sse_decode(deserializer); -let mut var_async = ::sse_decode(deserializer); +let mut var_async_ = ::sse_decode(deserializer); let mut var_another = ::sse_decode(deserializer); -return crate::api::pseudo_manual::raw_string_twin_rust_async_sse::MoreThanJustOneRawStringStructTwinRustAsyncSse{regular: var_regular, r#type: var_type, r#async: var_async, another: var_another};} +return crate::api::pseudo_manual::raw_string_twin_rust_async_sse::MoreThanJustOneRawStringStructTwinRustAsyncSse{regular: var_regular, r#type: var_type, r#async: var_async_, another: var_another};} } impl SseDecode @@ -60023,9 +60503,9 @@ impl SseDecode fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { let mut var_regular = ::sse_decode(deserializer); let mut var_type = ::sse_decode(deserializer); - let mut var_async = ::sse_decode(deserializer); + let mut var_async_ = ::sse_decode(deserializer); let mut var_another = ::sse_decode(deserializer); - return crate::api::pseudo_manual::raw_string_twin_sse::MoreThanJustOneRawStringStructTwinSse{regular: var_regular, r#type: var_type, r#async: var_async, another: var_another}; + return crate::api::pseudo_manual::raw_string_twin_sse::MoreThanJustOneRawStringStructTwinSse{regular: var_regular, r#type: var_type, r#async: var_async_, another: var_another}; } } @@ -60036,9 +60516,9 @@ impl SseDecode fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { let mut var_regular = ::sse_decode(deserializer); let mut var_type = ::sse_decode(deserializer); - let mut var_async = ::sse_decode(deserializer); + let mut var_async_ = ::sse_decode(deserializer); let mut var_another = ::sse_decode(deserializer); - return crate::api::pseudo_manual::raw_string_twin_sync::MoreThanJustOneRawStringStructTwinSync{regular: var_regular, r#type: var_type, r#async: var_async, another: var_another}; + return crate::api::pseudo_manual::raw_string_twin_sync::MoreThanJustOneRawStringStructTwinSync{regular: var_regular, r#type: var_type, r#async: var_async_, another: var_another}; } } @@ -60046,9 +60526,9 @@ impl SseDecode for crate::api::pseudo_manual::raw_string_twin_sync_sse::MoreThan // 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_regular = ::sse_decode(deserializer); let mut var_type = ::sse_decode(deserializer); -let mut var_async = ::sse_decode(deserializer); +let mut var_async_ = ::sse_decode(deserializer); let mut var_another = ::sse_decode(deserializer); -return crate::api::pseudo_manual::raw_string_twin_sync_sse::MoreThanJustOneRawStringStructTwinSyncSse{regular: var_regular, r#type: var_type, r#async: var_async, another: var_another};} +return crate::api::pseudo_manual::raw_string_twin_sync_sse::MoreThanJustOneRawStringStructTwinSyncSse{regular: var_regular, r#type: var_type, r#async: var_async_, another: var_another};} } impl SseDecode for crate::api::method::MyCallableTwinNormal { @@ -64317,6 +64797,22 @@ impl SseDecode for crate::deliberate_name_conflict::StructInUpperLevel { } } +impl SseDecode for crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal { + // 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_fieldI64 = ::sse_decode(deserializer); + let mut var_fieldU64 = ::sse_decode(deserializer); + let mut var_fieldI32 = ::sse_decode(deserializer); + let mut var_fieldVecU8 = >::sse_decode(deserializer); + return crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal { + field_i64: var_fieldI64, + field_u64: var_fieldU64, + field_i32: var_fieldI32, + field_vec_u8: var_fieldVecU8, + }; + } +} + impl SseDecode for crate::api::comment::StructWithCommentsTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -64387,6 +64883,68 @@ impl SseDecode for crate::api::misc_no_twin_example_a::StructWithCustomNameMetho } } +impl SseDecode for crate::api::structure::StructWithDartKeywordFieldTwinNormal { + // 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_class_ = ::sse_decode(deserializer); + let mut var_interface_ = ::sse_decode(deserializer); + return crate::api::structure::StructWithDartKeywordFieldTwinNormal { + class: var_class_, + interface: var_interface_, + }; + } +} + +impl SseDecode for crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + // 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_class_ = ::sse_decode(deserializer); +let mut var_interface_ = ::sse_decode(deserializer); +return crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync{class: var_class_, interface: var_interface_};} + } + +impl SseDecode for crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithDartKeywordFieldTwinRustAsyncSse { + // 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_class_ = ::sse_decode(deserializer); +let mut var_interface_ = ::sse_decode(deserializer); +return crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithDartKeywordFieldTwinRustAsyncSse{class: var_class_, interface: var_interface_};} + } + +impl SseDecode + for crate::api::pseudo_manual::structure_twin_sse::StructWithDartKeywordFieldTwinSse +{ + // 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_class_ = ::sse_decode(deserializer); + let mut var_interface_ = ::sse_decode(deserializer); + return crate::api::pseudo_manual::structure_twin_sse::StructWithDartKeywordFieldTwinSse { + class: var_class_, + interface: var_interface_, + }; + } +} + +impl SseDecode + for crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync +{ + // 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_class_ = ::sse_decode(deserializer); + let mut var_interface_ = ::sse_decode(deserializer); + return crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync{class: var_class_, interface: var_interface_}; + } +} + +impl SseDecode + for crate::api::pseudo_manual::structure_twin_sync_sse::StructWithDartKeywordFieldTwinSyncSse +{ + // 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_class_ = ::sse_decode(deserializer); + let mut var_interface_ = ::sse_decode(deserializer); + return crate::api::pseudo_manual::structure_twin_sync_sse::StructWithDartKeywordFieldTwinSyncSse{class: var_class_, interface: var_interface_}; + } +} + 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 { @@ -64573,6 +65131,62 @@ let mut var_normal = ::sse_decode(deserializer); return crate::api::pseudo_manual::rust_auto_opaque_twin_sync_sse_moi::StructWithExplicitAutoOpaqueFieldTwinSyncSseMoi{auto_opaque: var_autoOpaque, normal: var_normal};} } +impl SseDecode for crate::api::structure::StructWithFieldRenameTwinNormal { + // 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_renamed_field = ::sse_decode(deserializer); + return crate::api::structure::StructWithFieldRenameTwinNormal { + class: var_renamed_field, + }; + } +} + +impl SseDecode + for crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync +{ + // 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_renamed_field = ::sse_decode(deserializer); + return crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync{class: var_renamed_field}; + } +} + +impl SseDecode for crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithFieldRenameTwinRustAsyncSse { + // 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_renamed_field = ::sse_decode(deserializer); +return crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithFieldRenameTwinRustAsyncSse{class: var_renamed_field};} + } + +impl SseDecode for crate::api::pseudo_manual::structure_twin_sse::StructWithFieldRenameTwinSse { + // 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_renamed_field = ::sse_decode(deserializer); + return crate::api::pseudo_manual::structure_twin_sse::StructWithFieldRenameTwinSse { + class: var_renamed_field, + }; + } +} + +impl SseDecode for crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + // 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_renamed_field = ::sse_decode(deserializer); + return crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + class: var_renamed_field, + }; + } +} + +impl SseDecode + for crate::api::pseudo_manual::structure_twin_sync_sse::StructWithFieldRenameTwinSyncSse +{ + // 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_renamed_field = ::sse_decode(deserializer); + return crate::api::pseudo_manual::structure_twin_sync_sse::StructWithFieldRenameTwinSyncSse{class: var_renamed_field}; + } +} + impl SseDecode for crate::api::pseudo_manual::rust_auto_opaque_twin_moi::StructWithGoodAndOpaqueFieldTwinMoi { @@ -67572,6 +68186,26 @@ impl flutter_rust_bridge::IntoIntoDart> } } +// 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::<_, StdArc<_>>(self.0) + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for FrbWrapper +{ +} + +impl flutter_rust_bridge::IntoIntoDart> + for SimpleOpaqueExternalStructWithMethod +{ + fn into_into_dart(self) -> FrbWrapper { + self.into() + } +} + // 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 { @@ -79536,6 +80170,33 @@ impl flutter_rust_bridge::IntoIntoDart flutter_rust_bridge::for_generated::DartAbi { + [ + self.field_i64.into_into_dart().into_dart(), + self.field_u64.into_into_dart().into_dart(), + self.field_i32.into_into_dart().into_dart(), + self.field_vec_u8.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal, + > for crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal +{ + fn into_into_dart(self) -> crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs impl flutter_rust_bridge::IntoDart for crate::api::comment::StructWithCommentsTwinNormal { fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { [self.field_with_comments.into_into_dart().into_dart()].into_dart() @@ -79693,6 +80354,140 @@ impl } } // Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::structure::StructWithDartKeywordFieldTwinNormal { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.class.into_into_dart().into_dart(), + self.interface.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::structure::StructWithDartKeywordFieldTwinNormal +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::api::structure::StructWithDartKeywordFieldTwinNormal +{ + fn into_into_dart(self) -> crate::api::structure::StructWithDartKeywordFieldTwinNormal { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.class.into_into_dart().into_dart(), +self.interface.into_into_dart().into_dart() + ].into_dart() + } + } +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync {} +impl flutter_rust_bridge::IntoIntoDart for crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + fn into_into_dart(self) -> crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + self + } + } +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithDartKeywordFieldTwinRustAsyncSse { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.class.into_into_dart().into_dart(), +self.interface.into_into_dart().into_dart() + ].into_dart() + } + } +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithDartKeywordFieldTwinRustAsyncSse {} +impl flutter_rust_bridge::IntoIntoDart for crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithDartKeywordFieldTwinRustAsyncSse { + fn into_into_dart(self) -> crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithDartKeywordFieldTwinRustAsyncSse { + self + } + } +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::pseudo_manual::structure_twin_sse::StructWithDartKeywordFieldTwinSse +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.class.into_into_dart().into_dart(), + self.interface.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::pseudo_manual::structure_twin_sse::StructWithDartKeywordFieldTwinSse +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::pseudo_manual::structure_twin_sse::StructWithDartKeywordFieldTwinSse, + > for crate::api::pseudo_manual::structure_twin_sse::StructWithDartKeywordFieldTwinSse +{ + fn into_into_dart( + self, + ) -> crate::api::pseudo_manual::structure_twin_sse::StructWithDartKeywordFieldTwinSse { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.class.into_into_dart().into_dart(), + self.interface.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync, + > for crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync +{ + fn into_into_dart( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::pseudo_manual::structure_twin_sync_sse::StructWithDartKeywordFieldTwinSyncSse +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.class.into_into_dart().into_dart(), + self.interface.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::pseudo_manual::structure_twin_sync_sse::StructWithDartKeywordFieldTwinSyncSse +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::pseudo_manual::structure_twin_sync_sse::StructWithDartKeywordFieldTwinSyncSse, + > + for crate::api::pseudo_manual::structure_twin_sync_sse::StructWithDartKeywordFieldTwinSyncSse +{ + fn into_into_dart( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync_sse::StructWithDartKeywordFieldTwinSyncSse + { + 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 { [ @@ -80043,6 +80838,130 @@ impl flutter_rust_bridge::IntoIntoDart flutter_rust_bridge::for_generated::DartAbi { + [self.class.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::structure::StructWithFieldRenameTwinNormal +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::api::structure::StructWithFieldRenameTwinNormal +{ + fn into_into_dart(self) -> crate::api::structure::StructWithFieldRenameTwinNormal { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.class.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync, + > for crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync +{ + fn into_into_dart( + self, + ) -> crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync + { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithFieldRenameTwinRustAsyncSse { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.class.into_into_dart().into_dart() + ].into_dart() + } + } +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithFieldRenameTwinRustAsyncSse {} +impl flutter_rust_bridge::IntoIntoDart for crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithFieldRenameTwinRustAsyncSse { + fn into_into_dart(self) -> crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithFieldRenameTwinRustAsyncSse { + self + } + } +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::pseudo_manual::structure_twin_sse::StructWithFieldRenameTwinSse +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.class.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::pseudo_manual::structure_twin_sse::StructWithFieldRenameTwinSse +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::pseudo_manual::structure_twin_sse::StructWithFieldRenameTwinSse, + > for crate::api::pseudo_manual::structure_twin_sse::StructWithFieldRenameTwinSse +{ + fn into_into_dart( + self, + ) -> crate::api::pseudo_manual::structure_twin_sse::StructWithFieldRenameTwinSse { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.class.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync, + > for crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync +{ + fn into_into_dart( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::pseudo_manual::structure_twin_sync_sse::StructWithFieldRenameTwinSyncSse +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.class.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::pseudo_manual::structure_twin_sync_sse::StructWithFieldRenameTwinSyncSse +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::pseudo_manual::structure_twin_sync_sse::StructWithFieldRenameTwinSyncSse, + > for crate::api::pseudo_manual::structure_twin_sync_sse::StructWithFieldRenameTwinSyncSse +{ + fn into_into_dart( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync_sse::StructWithFieldRenameTwinSyncSse { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs impl flutter_rust_bridge::IntoDart for crate::api::pseudo_manual::rust_auto_opaque_twin_moi::StructWithGoodAndOpaqueFieldTwinMoi { @@ -83366,6 +84285,20 @@ impl SseEncode for OpaqueTwoTwinSyncSseMoi { } } +impl SseEncode for SimpleOpaqueExternalStructWithMethod { + // 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::<_, StdArc<_>>(self), + serializer, + ); + } +} + impl SseEncode for StaticGetterOnlyTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -83828,6 +84761,16 @@ impl SseEncode for chrono::DateTime { } } +impl SseEncode for MessageWithCustomSerializerTwinNormal { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode( + crate::api::custom_ser_des::serializer_my_type(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) { @@ -86491,6 +87434,21 @@ impl SseEncode } } +impl SseEncode + for RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + > +{ + // 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 RustOpaqueNom< flutter_rust_bridge::for_generated::RustAutoOpaqueInner, @@ -98406,6 +99364,16 @@ impl SseEncode for crate::deliberate_name_conflict::StructInUpperLevel { } } +impl SseEncode for crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal { + // 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.field_i64, serializer); + ::sse_encode(self.field_u64, serializer); + ::sse_encode(self.field_i32, serializer); + >::sse_encode(self.field_vec_u8, serializer); + } +} + impl SseEncode for crate::api::comment::StructWithCommentsTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -98459,6 +99427,56 @@ impl SseEncode for crate::api::misc_no_twin_example_a::StructWithCustomNameMetho } } +impl SseEncode for crate::api::structure::StructWithDartKeywordFieldTwinNormal { + // 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.class, serializer); + ::sse_encode(self.interface, serializer); + } +} + +impl SseEncode for crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + // 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.class, serializer); +::sse_encode(self.interface, serializer);} + } + +impl SseEncode for crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithDartKeywordFieldTwinRustAsyncSse { + // 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.class, serializer); +::sse_encode(self.interface, serializer);} + } + +impl SseEncode + for crate::api::pseudo_manual::structure_twin_sse::StructWithDartKeywordFieldTwinSse +{ + // 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.class, serializer); + ::sse_encode(self.interface, serializer); + } +} + +impl SseEncode + for crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync +{ + // 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.class, serializer); + ::sse_encode(self.interface, serializer); + } +} + +impl SseEncode + for crate::api::pseudo_manual::structure_twin_sync_sse::StructWithDartKeywordFieldTwinSyncSse +{ + // 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.class, serializer); + ::sse_encode(self.interface, 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) { @@ -98603,6 +99621,50 @@ impl SseEncode for crate::api::pseudo_manual::rust_auto_opaque_twin_sync_sse_moi ::sse_encode(self.normal, serializer);} } +impl SseEncode for crate::api::structure::StructWithFieldRenameTwinNormal { + // 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.class, serializer); + } +} + +impl SseEncode + for crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync +{ + // 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.class, serializer); + } +} + +impl SseEncode for crate::api::pseudo_manual::structure_twin_rust_async_sse::StructWithFieldRenameTwinRustAsyncSse { + // 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.class, serializer);} + } + +impl SseEncode for crate::api::pseudo_manual::structure_twin_sse::StructWithFieldRenameTwinSse { + // 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.class, serializer); + } +} + +impl SseEncode for crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + // 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.class, serializer); + } +} + +impl SseEncode + for crate::api::pseudo_manual::structure_twin_sync_sse::StructWithFieldRenameTwinSyncSse +{ + // 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.class, serializer); + } +} + impl SseEncode for crate::api::pseudo_manual::rust_auto_opaque_twin_moi::StructWithGoodAndOpaqueFieldTwinMoi { 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 4b02b22462..36d580e69c 100644 --- a/frb_example/pure_dart/rust/src/frb_generated.web.rs +++ b/frb_example/pure_dart/rust/src/frb_generated.web.rs @@ -5,10 +5,12 @@ use super::*; use crate::api::constructor::*; +use crate::api::custom_ser_des::*; use crate::api::dart_code::*; use crate::api::dropping::*; use crate::api::dyn_trait::SimpleTraitForDynTwinNormal; use crate::api::dyn_trait::*; +use crate::api::external_impl::*; use crate::api::impl_trait::SimpleTraitTwinNormal; use crate::api::impl_trait::*; use crate::api::method::*; @@ -7489,6 +7491,56 @@ impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::structure::StructWithDartKeywordFieldTwinNormal { + let self_ = self + .dyn_into::() + .unwrap(); + assert_eq!( + self_.length(), + 2, + "Expected 2 elements, got {}", + self_.length() + ); + crate::api::structure::StructWithDartKeywordFieldTwinNormal { + class: self_.get(0).cst_decode(), + interface: self_.get(1).cst_decode(), + } + } +} +impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + let self_ = self.dyn_into::().unwrap(); + assert_eq!(self_.length(), 2, "Expected 2 elements, got {}", self_.length()); + crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync{class: self_.get(0).cst_decode(),interface: self_.get(1).cst_decode()} + } + } +impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync { + let self_ = self + .dyn_into::() + .unwrap(); + assert_eq!( + self_.length(), + 2, + "Expected 2 elements, got {}", + self_.length() + ); + crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync { + class: self_.get(0).cst_decode(), + interface: self_.get(1).cst_decode(), + } + } +} impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { @@ -7615,6 +7667,70 @@ impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::structure::StructWithFieldRenameTwinNormal { + let self_ = self + .dyn_into::() + .unwrap(); + assert_eq!( + self_.length(), + 1, + "Expected 1 elements, got {}", + self_.length() + ); + crate::api::structure::StructWithFieldRenameTwinNormal { + class: self_.get(0).cst_decode(), + } + } +} +impl + CstDecode< + crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync, + > for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync + { + let self_ = self + .dyn_into::() + .unwrap(); + assert_eq!( + self_.length(), + 1, + "Expected 1 elements, got {}", + self_.length() + ); + crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync { + class: self_.get(0).cst_decode(), + } + } +} +impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + let self_ = self + .dyn_into::() + .unwrap(); + assert_eq!( + self_.length(), + 1, + "Expected 1 elements, got {}", + self_.length() + ); + crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + class: self_.get(0).cst_decode(), + } + } +} impl CstDecode< crate::api::pseudo_manual::rust_auto_opaque_twin_moi::StructWithGoodAndOpaqueFieldTwinMoi, @@ -9275,6 +9391,22 @@ impl CstDecode for flutter_rust_bridge::for_generated::was )) } } +impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> SimpleOpaqueExternalStructWithMethod { + flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::< + RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >, + >::cst_decode( + self + )) + } +} impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { @@ -11819,6 +11951,30 @@ impl decode_rust_opaque_moi((self.as_f64().unwrap() as usize) as _) } } +impl + CstDecode< + RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >, + > for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue +{ + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + > { + #[cfg(target_pointer_width = "64")] + { + compile_error!("64-bit pointers are not supported."); + } + unsafe { decode_rust_opaque_nom((self.as_f64().unwrap() as usize) as _) } + } +} impl CstDecode< RustOpaqueNom< @@ -14004,6 +14160,96 @@ pub fn wire__crate__api__benchmark_misc__benchmark_void_semi_serialize( wire__crate__api__benchmark_misc__benchmark_void_semi_serialize_impl() } +#[wasm_bindgen] +pub fn wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + +#[wasm_bindgen] +pub fn wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + +#[wasm_bindgen] +pub fn wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + +#[wasm_bindgen] +pub fn wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + +#[wasm_bindgen] +pub fn wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + +#[wasm_bindgen] +pub fn wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + #[wasm_bindgen] pub fn wire__crate__api__chrono_type__datetime_local_twin_normal( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, @@ -14198,6 +14444,21 @@ pub fn wire__crate__api__constructor__constructor_translatable_sync_struct_twin_ wire__crate__api__constructor__constructor_translatable_sync_struct_twin_normal_new_impl() } +#[wasm_bindgen] +pub fn wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer_impl( + port_, + ptr_, + rust_vec_len_, + data_len_, + ) +} + #[wasm_bindgen] pub fn wire__crate__api__customization__check_init_done( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, @@ -14981,6 +15242,21 @@ pub fn wire__crate__api__exception__throw_anyhow_twin_normal( wire__crate__api__exception__throw_anyhow_twin_normal_impl(port_) } +#[wasm_bindgen] +pub fn wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new( + a: String, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new_impl(a) +} + +#[wasm_bindgen] +pub fn wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method( + port_: flutter_rust_bridge::for_generated::MessagePort, + that: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, +) { + wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method_impl(port_, that) +} + #[wasm_bindgen] pub fn wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, @@ -37710,6 +37986,22 @@ pub fn wire__crate__api__pseudo_manual__stream_twin_sse__stream_sink_inside_vec_ ) } +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async( + port_: flutter_rust_bridge::for_generated::MessagePort, + arg: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, +) { + wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async_impl(port_, arg) +} + +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async( + port_: flutter_rust_bridge::for_generated::MessagePort, + arg: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, +) { + wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async_impl(port_, arg) +} + #[wasm_bindgen] pub fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, @@ -37750,6 +38042,26 @@ pub fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_st wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct_with_two_field_twin_rust_async_impl(port_, arg) } +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_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__structure_twin_rust_async_sse__func_for_struct_with_dart_keyword_field_twin_rust_async_sse_impl(port_, ptr_, rust_vec_len_, data_len_) +} + +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_for_struct_with_field_rename_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__structure_twin_rust_async_sse__func_for_struct_with_field_rename_twin_rust_async_sse_impl(port_, ptr_, rust_vec_len_, data_len_) +} + #[wasm_bindgen] pub fn wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_struct_with_one_field_twin_rust_async_sse( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, @@ -37800,6 +38112,26 @@ pub fn wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_tupl wire__crate__api__pseudo_manual__structure_twin_rust_async_sse__func_tuple_struct_with_two_field_twin_rust_async_sse_impl(port_, ptr_, rust_vec_len_, data_len_) } +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_dart_keyword_field_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__structure_twin_sse__func_for_struct_with_dart_keyword_field_twin_sse_impl(port_, ptr_, rust_vec_len_, data_len_) +} + +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__structure_twin_sse__func_for_struct_with_field_rename_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__structure_twin_sse__func_for_struct_with_field_rename_twin_sse_impl(port_, ptr_, rust_vec_len_, data_len_) +} + #[wasm_bindgen] pub fn wire__crate__api__pseudo_manual__structure_twin_sse__func_struct_with_one_field_twin_sse( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, @@ -37865,6 +38197,20 @@ pub fn wire__crate__api__pseudo_manual__structure_twin_sse__func_tuple_struct_wi wire__crate__api__pseudo_manual__structure_twin_sse__func_tuple_struct_with_two_field_twin_sse_impl(port_, ptr_, rust_vec_len_, data_len_) } +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync( + arg: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync_impl(arg) +} + +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync( + arg: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync_impl(arg) +} + #[wasm_bindgen] pub fn wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync( arg: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, @@ -37906,6 +38252,24 @@ pub fn wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_w wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync_impl(arg) } +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_dart_keyword_field_twin_sync_sse_impl(ptr_, rust_vec_len_, data_len_) +} + +#[wasm_bindgen] +pub fn wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_for_struct_with_field_rename_twin_sync_sse_impl(ptr_, rust_vec_len_, data_len_) +} + #[wasm_bindgen] pub fn wire__crate__api__pseudo_manual__structure_twin_sync_sse__func_struct_with_one_field_twin_sync_sse( ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -39047,6 +39411,24 @@ pub fn wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal( wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal_impl(port_, sink) } +#[wasm_bindgen] +pub fn wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal( + port_: flutter_rust_bridge::for_generated::MessagePort, + arg: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, +) { + wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal_impl( + port_, arg, + ) +} + +#[wasm_bindgen] +pub fn wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal( + port_: flutter_rust_bridge::for_generated::MessagePort, + arg: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, +) { + wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal_impl(port_, arg) +} + #[wasm_bindgen] pub fn wire__crate__api__structure__func_struct_with_one_field_twin_normal( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, @@ -42147,6 +42529,32 @@ pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generat MoiArc::>::decrement_strong_count(ptr as _); } +#[wasm_bindgen] +pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr: *const std::ffi::c_void, +) { + unsafe { + StdArc::< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >::increment_strong_count(ptr as _); + } +} + +#[wasm_bindgen] +pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr: *const std::ffi::c_void, +) { + unsafe { + StdArc::< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >::decrement_strong_count(ptr as _); + } +} + #[wasm_bindgen] pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( ptr: *const std::ffi::c_void, diff --git a/frb_example/pure_dart/test/api/casted_primitive_test.dart b/frb_example/pure_dart/test/api/casted_primitive_test.dart new file mode 100644 index 0000000000..be906d3ae7 --- /dev/null +++ b/frb_example/pure_dart/test/api/casted_primitive_test.dart @@ -0,0 +1,33 @@ +// FRB_INTERNAL_GENERATOR: {"forbiddenDuplicatorModes": ["sync", "rustAsync", "sse", "sync sse", "rustAsync sse"]} + +import 'dart:typed_data'; + +import 'package:frb_example_pure_dart/src/rust/api/casted_primitive.dart'; +import 'package:frb_example_pure_dart/src/rust/frb_generated.dart'; +import 'package:test/test.dart'; + +import '../test_utils.dart'; + +Future main({bool skipRustLibInit = false}) async { + if (!skipRustLibInit) await RustLib.init(); + + addTestsIdentityFunctionCall( + castedPrimitiveI64TwinNormal, [0, -1000000000, 1000000000]); + addTestsIdentityFunctionCall( + castedPrimitiveU64TwinNormal, [0, 1000000000]); + addTestsIdentityFunctionCall( + castedPrimitiveIsizeTwinNormal, [0, -1000000000, 1000000000]); + addTestsIdentityFunctionCall( + castedPrimitiveUsizeTwinNormal, [0, 1000000000]); + + test('StructWithCastedPrimitiveTwinNormal', () async { + await functionForStructWithCastedPrimitiveTwinNormal( + arg: StructWithCastedPrimitiveTwinNormal( + fieldI64: 1000000000, + fieldU64: 2000000000, + fieldI32: 123456789, + fieldVecU8: Uint8List.fromList([10, 20, 100]), + ), + ); + }); +} diff --git a/frb_example/pure_dart/test/api/custom_ser_des_test.dart b/frb_example/pure_dart/test/api/custom_ser_des_test.dart new file mode 100644 index 0000000000..7acd797534 --- /dev/null +++ b/frb_example/pure_dart/test/api/custom_ser_des_test.dart @@ -0,0 +1,14 @@ +// FRB_INTERNAL_GENERATOR: {"forbiddenDuplicatorModes": ["sync", "rustAsync", "sse", "sync sse", "rustAsync sse"]} + +import 'package:frb_example_pure_dart/src/rust/api/custom_ser_des.dart'; +import 'package:frb_example_pure_dart/src/rust/frb_generated.dart'; +import 'package:test/test.dart'; + +Future main({bool skipRustLibInit = false}) async { + if (!skipRustLibInit) await RustLib.init(); + + test('custom serializer', () async { + expect( + await functionUsingTypeWithCustomSerializer(arg: 123456789), 123456789); + }); +} diff --git a/frb_example/pure_dart/test/dart_valgrind_test_entrypoint.dart b/frb_example/pure_dart/test/dart_valgrind_test_entrypoint.dart index 6a1ca57536..ce04c322a1 100644 --- a/frb_example/pure_dart/test/dart_valgrind_test_entrypoint.dart +++ b/frb_example/pure_dart/test/dart_valgrind_test_entrypoint.dart @@ -11,9 +11,11 @@ import 'api/array_test.dart' as array_test; import 'api/async_misc_test.dart' as async_misc_test; import 'api/async_spawn_test.dart' as async_spawn_test; import 'api/attribute_test.dart' as attribute_test; +import 'api/casted_primitive_test.dart' as casted_primitive_test; import 'api/chrono_type_test.dart' as chrono_type_test; import 'api/comment_test.dart' as comment_test; import 'api/constructor_test.dart' as constructor_test; +import 'api/custom_ser_des_test.dart' as custom_ser_des_test; import 'api/customization_test.dart' as customization_test; import 'api/dart_code_test.dart' as dart_code_test; import 'api/dart_dynamic_test.dart' as dart_dynamic_test; @@ -439,9 +441,11 @@ Future callFileEntrypoints() async { await async_misc_test.main(skipRustLibInit: true); await async_spawn_test.main(skipRustLibInit: true); await attribute_test.main(skipRustLibInit: true); + await casted_primitive_test.main(skipRustLibInit: true); await chrono_type_test.main(skipRustLibInit: true); await comment_test.main(skipRustLibInit: true); await constructor_test.main(skipRustLibInit: true); + await custom_ser_des_test.main(skipRustLibInit: true); await customization_test.main(skipRustLibInit: true); await dart_code_test.main(skipRustLibInit: true); await dart_dynamic_test.main(skipRustLibInit: true); diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/attribute.dart b/frb_example/pure_dart_pde/lib/src/rust/api/attribute.dart index ec4c6bb1ec..e20ea28f85 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/attribute.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/attribute.dart @@ -10,7 +10,8 @@ import 'package:meta/meta.dart' as meta; part 'attribute.freezed.dart'; // These types are ignored because they are not used by any `pub` functions: `IgnoredStructTwinNormal`, `StructWithOnlyIgnoredMethodTwinNormal` -// These functions are ignored: `func_should_not_exist_in_dart_twin_normal`, `method_should_not_exist_in_dart_twin_normal`, `method_should_not_exist_in_dart_twin_normal` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `func_should_not_exist_in_dart_twin_normal`, `method_should_not_exist_in_dart_twin_normal` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `method_should_not_exist_in_dart_twin_normal` Future handleCustomizedStructTwinNormal( {required CustomizedTwinNormal val}) => diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/casted_primitive.dart b/frb_example/pure_dart_pde/lib/src/rust/api/casted_primitive.dart new file mode 100644 index 0000000000..49f6249ef8 --- /dev/null +++ b/frb_example/pure_dart_pde/lib/src/rust/api/casted_primitive.dart @@ -0,0 +1,67 @@ +// This file is automatically generated, so please do not edit it. +// Generated by `flutter_rust_bridge`@ 2.0.0-dev.38. + +// ignore_for_file: invalid_use_of_internal_member, unused_import, unnecessary_import + +import '../frb_generated.dart'; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; + +Future castedPrimitiveI64TwinNormal({required int arg}) => + RustLib.instance.api + .crateApiCastedPrimitiveCastedPrimitiveI64TwinNormal(arg: arg); + +Future castedPrimitiveU64TwinNormal({required int arg}) => + RustLib.instance.api + .crateApiCastedPrimitiveCastedPrimitiveU64TwinNormal(arg: arg); + +Future castedPrimitiveIsizeTwinNormal({required int arg}) => + RustLib.instance.api + .crateApiCastedPrimitiveCastedPrimitiveIsizeTwinNormal(arg: arg); + +Future castedPrimitiveUsizeTwinNormal({required int arg}) => + RustLib.instance.api + .crateApiCastedPrimitiveCastedPrimitiveUsizeTwinNormal(arg: arg); + +Future castedPrimitiveMultiArgTwinNormal( + {required int a, required int b, required int c, required BigInt d}) => + RustLib.instance.api + .crateApiCastedPrimitiveCastedPrimitiveMultiArgTwinNormal( + a: a, b: b, c: c, d: d); + +Future + functionForStructWithCastedPrimitiveTwinNormal( + {required StructWithCastedPrimitiveTwinNormal arg}) => + RustLib.instance.api + .crateApiCastedPrimitiveFunctionForStructWithCastedPrimitiveTwinNormal( + arg: arg); + +class StructWithCastedPrimitiveTwinNormal { + final int fieldI64; + final int fieldU64; + final int fieldI32; + final Uint8List fieldVecU8; + + const StructWithCastedPrimitiveTwinNormal({ + required this.fieldI64, + required this.fieldU64, + required this.fieldI32, + required this.fieldVecU8, + }); + + @override + int get hashCode => + fieldI64.hashCode ^ + fieldU64.hashCode ^ + fieldI32.hashCode ^ + fieldVecU8.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithCastedPrimitiveTwinNormal && + runtimeType == other.runtimeType && + fieldI64 == other.fieldI64 && + fieldU64 == other.fieldU64 && + fieldI32 == other.fieldI32 && + fieldVecU8 == other.fieldVecU8; +} diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/custom_ser_des.dart b/frb_example/pure_dart_pde/lib/src/rust/api/custom_ser_des.dart new file mode 100644 index 0000000000..9c9e0b3d69 --- /dev/null +++ b/frb_example/pure_dart_pde/lib/src/rust/api/custom_ser_des.dart @@ -0,0 +1,13 @@ +// This file is automatically generated, so please do not edit it. +// Generated by `flutter_rust_bridge`@ 2.0.0-dev.38. + +// ignore_for_file: invalid_use_of_internal_member, unused_import, unnecessary_import + +import '../frb_generated.dart'; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; + +// These types are ignored because they are not used by any `pub` functions: `MessageWithCustomSerializerTwinNormal` + +Future functionUsingTypeWithCustomSerializer({required int arg}) => + RustLib.instance.api + .crateApiCustomSerDesFunctionUsingTypeWithCustomSerializer(arg: arg); diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/external_impl.dart b/frb_example/pure_dart_pde/lib/src/rust/api/external_impl.dart index 88d4c53891..0e6f6be444 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/external_impl.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/external_impl.dart @@ -6,7 +6,15 @@ import '../frb_generated.dart'; import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; -// These functions are ignored: `new`, `simple_external_method` +// Rust type: RustOpaqueMoi> +abstract class SimpleOpaqueExternalStructWithMethod + implements RustOpaqueInterface { + factory SimpleOpaqueExternalStructWithMethod({required String a}) => + RustLib.instance.api + .crateApiExternalImplSimpleOpaqueExternalStructWithMethodNew(a: a); + + Future simpleExternalMethod(); +} class SimpleTranslatableExternalStructWithMethod { final String a; diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async.dart b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async.dart index bfb60ca396..9ee6415fe3 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/attribute_twin_rust_async.dart @@ -10,7 +10,8 @@ import 'package:meta/meta.dart' as meta; part 'attribute_twin_rust_async.freezed.dart'; // These types are ignored because they are not used by any `pub` functions: `IgnoredStructTwinRustAsync`, `StructWithOnlyIgnoredMethodTwinRustAsync` -// These functions are ignored: `func_should_not_exist_in_dart_twin_rust_async`, `method_should_not_exist_in_dart_twin_rust_async`, `method_should_not_exist_in_dart_twin_rust_async` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `func_should_not_exist_in_dart_twin_rust_async`, `method_should_not_exist_in_dart_twin_rust_async` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `method_should_not_exist_in_dart_twin_rust_async` Future handleCustomizedStructTwinRustAsync( {required CustomizedTwinRustAsync val}) => diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/attribute_twin_sync.dart b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/attribute_twin_sync.dart index 76b145c22b..aa54d94265 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/attribute_twin_sync.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/attribute_twin_sync.dart @@ -10,7 +10,8 @@ import 'package:meta/meta.dart' as meta; part 'attribute_twin_sync.freezed.dart'; // These types are ignored because they are not used by any `pub` functions: `IgnoredStructTwinSync`, `StructWithOnlyIgnoredMethodTwinSync` -// These functions are ignored: `func_should_not_exist_in_dart_twin_sync`, `method_should_not_exist_in_dart_twin_sync`, `method_should_not_exist_in_dart_twin_sync` +// These functions are ignored (category: IgnoreBecauseExplicitAttribute): `func_should_not_exist_in_dart_twin_sync`, `method_should_not_exist_in_dart_twin_sync` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `method_should_not_exist_in_dart_twin_sync` void handleCustomizedStructTwinSync({required CustomizedTwinSync val}) => RustLib.instance.api diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async.dart b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async.dart index dc10bfb660..c12bed0826 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/raw_string_twin_rust_async.dart @@ -17,19 +17,19 @@ Future class MoreThanJustOneRawStringStructTwinRustAsync { final String regular; final String type; - final bool async; + final bool async_; final String another; const MoreThanJustOneRawStringStructTwinRustAsync({ required this.regular, required this.type, - required this.async, + required this.async_, required this.another, }); @override int get hashCode => - regular.hashCode ^ type.hashCode ^ async.hashCode ^ another.hashCode; + regular.hashCode ^ type.hashCode ^ async_.hashCode ^ another.hashCode; @override bool operator ==(Object other) => @@ -38,7 +38,7 @@ class MoreThanJustOneRawStringStructTwinRustAsync { runtimeType == other.runtimeType && regular == other.regular && type == other.type && - async == other.async && + async_ == other.async_ && another == other.another; } diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/raw_string_twin_sync.dart b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/raw_string_twin_sync.dart index bbc0a804f6..cf424756b3 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/raw_string_twin_sync.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/raw_string_twin_sync.dart @@ -17,19 +17,19 @@ MoreThanJustOneRawStringStructTwinSync class MoreThanJustOneRawStringStructTwinSync { final String regular; final String type; - final bool async; + final bool async_; final String another; const MoreThanJustOneRawStringStructTwinSync({ required this.regular, required this.type, - required this.async, + required this.async_, required this.another, }); @override int get hashCode => - regular.hashCode ^ type.hashCode ^ async.hashCode ^ another.hashCode; + regular.hashCode ^ type.hashCode ^ async_.hashCode ^ another.hashCode; @override bool operator ==(Object other) => @@ -38,7 +38,7 @@ class MoreThanJustOneRawStringStructTwinSync { runtimeType == other.runtimeType && regular == other.regular && type == other.type && - async == other.async && + async_ == other.async_ && another == other.another; } diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/rust_auto_opaque_twin_rust_async.dart b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/rust_auto_opaque_twin_rust_async.dart index c3c81da002..18e57e494b 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/rust_auto_opaque_twin_rust_async.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/rust_auto_opaque_twin_rust_async.dart @@ -8,7 +8,7 @@ import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; import 'package:freezed_annotation/freezed_annotation.dart' hide protected; part 'rust_auto_opaque_twin_rust_async.freezed.dart'; -// These functions are ignored: `f` +// These functions are ignored (category: IgnoreBecauseNotAllowedOwner): `f` Future rustAutoOpaqueArgOwnTwinRustAsync( {required NonCloneSimpleTwinRustAsync arg, required int expect}) => diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/structure_twin_rust_async.dart b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/structure_twin_rust_async.dart index acf711226b..3e61eb324d 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/structure_twin_rust_async.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/structure_twin_rust_async.dart @@ -38,6 +38,59 @@ Future< .crateApiPseudoManualStructureTwinRustAsyncFuncTupleStructWithTwoFieldTwinRustAsync( arg: arg); +Future< + StructWithFieldRenameTwinRustAsync> funcForStructWithFieldRenameTwinRustAsync( + {required StructWithFieldRenameTwinRustAsync arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithFieldRenameTwinRustAsync( + arg: arg); + +Future + funcForStructWithDartKeywordFieldTwinRustAsync( + {required StructWithDartKeywordFieldTwinRustAsync arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithDartKeywordFieldTwinRustAsync( + arg: arg); + +class StructWithDartKeywordFieldTwinRustAsync { + final int class_; + final PlatformInt64 interface_; + + const StructWithDartKeywordFieldTwinRustAsync({ + required this.class_, + required this.interface_, + }); + + @override + int get hashCode => class_.hashCode ^ interface_.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithDartKeywordFieldTwinRustAsync && + runtimeType == other.runtimeType && + class_ == other.class_ && + interface_ == other.interface_; +} + +class StructWithFieldRenameTwinRustAsync { + final int renamed_field; + + const StructWithFieldRenameTwinRustAsync({ + required this.renamed_field, + }); + + @override + int get hashCode => renamed_field.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithFieldRenameTwinRustAsync && + runtimeType == other.runtimeType && + renamed_field == other.renamed_field; +} + class StructWithOneFieldTwinRustAsync { final int a; diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/structure_twin_sync.dart b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/structure_twin_sync.dart index 15b4c73266..ab90a6c7fc 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/structure_twin_sync.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/pseudo_manual/structure_twin_sync.dart @@ -36,6 +36,57 @@ TupleStructWithTwoFieldTwinSync funcTupleStructWithTwoFieldTwinSync( .crateApiPseudoManualStructureTwinSyncFuncTupleStructWithTwoFieldTwinSync( arg: arg); +StructWithFieldRenameTwinSync funcForStructWithFieldRenameTwinSync( + {required StructWithFieldRenameTwinSync arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinSyncFuncForStructWithFieldRenameTwinSync( + arg: arg); + +StructWithDartKeywordFieldTwinSync funcForStructWithDartKeywordFieldTwinSync( + {required StructWithDartKeywordFieldTwinSync arg}) => + RustLib.instance.api + .crateApiPseudoManualStructureTwinSyncFuncForStructWithDartKeywordFieldTwinSync( + arg: arg); + +class StructWithDartKeywordFieldTwinSync { + final int class_; + final PlatformInt64 interface_; + + const StructWithDartKeywordFieldTwinSync({ + required this.class_, + required this.interface_, + }); + + @override + int get hashCode => class_.hashCode ^ interface_.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithDartKeywordFieldTwinSync && + runtimeType == other.runtimeType && + class_ == other.class_ && + interface_ == other.interface_; +} + +class StructWithFieldRenameTwinSync { + final int renamed_field; + + const StructWithFieldRenameTwinSync({ + required this.renamed_field, + }); + + @override + int get hashCode => renamed_field.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithFieldRenameTwinSync && + runtimeType == other.runtimeType && + renamed_field == other.renamed_field; +} + class StructWithOneFieldTwinSync { final int a; diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/raw_string.dart b/frb_example/pure_dart_pde/lib/src/rust/api/raw_string.dart index 35fe807e52..efafd4bfb6 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/raw_string.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/raw_string.dart @@ -16,19 +16,19 @@ Future class MoreThanJustOneRawStringStructTwinNormal { final String regular; final String type; - final bool async; + final bool async_; final String another; const MoreThanJustOneRawStringStructTwinNormal({ required this.regular, required this.type, - required this.async, + required this.async_, required this.another, }); @override int get hashCode => - regular.hashCode ^ type.hashCode ^ async.hashCode ^ another.hashCode; + regular.hashCode ^ type.hashCode ^ async_.hashCode ^ another.hashCode; @override bool operator ==(Object other) => @@ -37,7 +37,7 @@ class MoreThanJustOneRawStringStructTwinNormal { runtimeType == other.runtimeType && regular == other.regular && type == other.type && - async == other.async && + async_ == other.async_ && another == other.another; } diff --git a/frb_example/pure_dart_pde/lib/src/rust/api/structure.dart b/frb_example/pure_dart_pde/lib/src/rust/api/structure.dart index 0803ab4251..b025b9a653 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/api/structure.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/api/structure.dart @@ -31,6 +31,57 @@ Future funcTupleStructWithTwoFieldTwinNormal( RustLib.instance.api .crateApiStructureFuncTupleStructWithTwoFieldTwinNormal(arg: arg); +Future funcForStructWithFieldRenameTwinNormal( + {required StructWithFieldRenameTwinNormal arg}) => + RustLib.instance.api + .crateApiStructureFuncForStructWithFieldRenameTwinNormal(arg: arg); + +Future + funcForStructWithDartKeywordFieldTwinNormal( + {required StructWithDartKeywordFieldTwinNormal arg}) => + RustLib.instance.api + .crateApiStructureFuncForStructWithDartKeywordFieldTwinNormal( + arg: arg); + +class StructWithDartKeywordFieldTwinNormal { + final int class_; + final PlatformInt64 interface_; + + const StructWithDartKeywordFieldTwinNormal({ + required this.class_, + required this.interface_, + }); + + @override + int get hashCode => class_.hashCode ^ interface_.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithDartKeywordFieldTwinNormal && + runtimeType == other.runtimeType && + class_ == other.class_ && + interface_ == other.interface_; +} + +class StructWithFieldRenameTwinNormal { + final int renamed_field; + + const StructWithFieldRenameTwinNormal({ + required this.renamed_field, + }); + + @override + int get hashCode => renamed_field.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is StructWithFieldRenameTwinNormal && + runtimeType == other.runtimeType && + renamed_field == other.renamed_field; +} + class StructWithOneFieldTwinNormal { final int a; diff --git a/frb_example/pure_dart_pde/lib/src/rust/auxiliary/sample_types.dart b/frb_example/pure_dart_pde/lib/src/rust/auxiliary/sample_types.dart index aaa36f603a..2610dda2fd 100644 --- a/frb_example/pure_dart_pde/lib/src/rust/auxiliary/sample_types.dart +++ b/frb_example/pure_dart_pde/lib/src/rust/auxiliary/sample_types.dart @@ -7,8 +7,8 @@ import '../frb_generated.dart'; import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; enum MyEnum { - False, - True, + false_, + true_, ; } 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 53fb0b448d..e6dab104f6 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 @@ -13,9 +13,11 @@ import 'api/async_misc.dart'; import 'api/async_spawn.dart'; import 'api/attribute.dart'; import 'api/benchmark_misc.dart'; +import 'api/casted_primitive.dart'; import 'api/chrono_type.dart'; import 'api/comment.dart'; import 'api/constructor.dart'; +import 'api/custom_ser_des.dart'; import 'api/customization.dart'; import 'api/dart_code.dart'; import 'api/dart_fn.dart'; @@ -194,7 +196,7 @@ class RustLib extends BaseEntrypoint { String get codegenVersion => '2.0.0-dev.38'; @override - int get rustContentHash => 2063949598; + int get rustContentHash => -263748021; static const kDefaultExternalLibraryLoaderConfig = ExternalLibraryLoaderConfig( @@ -258,6 +260,25 @@ abstract class RustLibApi extends BaseApi { void crateApiBenchmarkMiscBenchmarkVoidSemiSerialize(); + Future crateApiCastedPrimitiveCastedPrimitiveI64TwinNormal( + {required int arg}); + + Future crateApiCastedPrimitiveCastedPrimitiveIsizeTwinNormal( + {required int arg}); + + Future crateApiCastedPrimitiveCastedPrimitiveMultiArgTwinNormal( + {required int a, required int b, required int c, required BigInt d}); + + Future crateApiCastedPrimitiveCastedPrimitiveU64TwinNormal( + {required int arg}); + + Future crateApiCastedPrimitiveCastedPrimitiveUsizeTwinNormal( + {required int arg}); + + Future + crateApiCastedPrimitiveFunctionForStructWithCastedPrimitiveTwinNormal( + {required StructWithCastedPrimitiveTwinNormal arg}); + Future crateApiChronoTypeDatetimeLocalTwinNormal( {required DateTime d}); @@ -331,6 +352,9 @@ abstract class RustLibApi extends BaseApi { ConstructorTranslatableSyncStructTwinNormal crateApiConstructorConstructorTranslatableSyncStructTwinNormalNew(); + Future crateApiCustomSerDesFunctionUsingTypeWithCustomSerializer( + {required int arg}); + Future crateApiCustomizationCheckInitDone(); Future crateApiCustomizationInitApp(); @@ -612,6 +636,14 @@ abstract class RustLibApi extends BaseApi { Future crateApiExceptionThrowAnyhowTwinNormal(); + SimpleOpaqueExternalStructWithMethod + crateApiExternalImplSimpleOpaqueExternalStructWithMethodNew( + {required String a}); + + Future + crateApiExternalImplSimpleOpaqueExternalStructWithMethodSimpleExternalMethod( + {required SimpleOpaqueExternalStructWithMethod that}); + Future crateApiExternalImplSimpleTranslatableExternalStructWithMethodSimpleExternalMethod( {required SimpleTranslatableExternalStructWithMethod that}); @@ -3947,6 +3979,14 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualStreamTwinRustAsyncStreamSinkInsideVecTwinRustAsync( {required List> arg}); + Future + crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithDartKeywordFieldTwinRustAsync( + {required StructWithDartKeywordFieldTwinRustAsync arg}); + + Future + crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithFieldRenameTwinRustAsync( + {required StructWithFieldRenameTwinRustAsync arg}); + Future crateApiPseudoManualStructureTwinRustAsyncFuncStructWithOneFieldTwinRustAsync( {required StructWithOneFieldTwinRustAsync arg}); @@ -3967,6 +4007,14 @@ abstract class RustLibApi extends BaseApi { crateApiPseudoManualStructureTwinRustAsyncFuncTupleStructWithTwoFieldTwinRustAsync( {required TupleStructWithTwoFieldTwinRustAsync arg}); + StructWithDartKeywordFieldTwinSync + crateApiPseudoManualStructureTwinSyncFuncForStructWithDartKeywordFieldTwinSync( + {required StructWithDartKeywordFieldTwinSync arg}); + + StructWithFieldRenameTwinSync + crateApiPseudoManualStructureTwinSyncFuncForStructWithFieldRenameTwinSync( + {required StructWithFieldRenameTwinSync arg}); + StructWithOneFieldTwinSync crateApiPseudoManualStructureTwinSyncFuncStructWithOneFieldTwinSync( {required StructWithOneFieldTwinSync arg}); @@ -4297,6 +4345,14 @@ abstract class RustLibApi extends BaseApi { Future> crateApiStreamMiscStreamSinkDartAsyncTwinNormal(); + Future + crateApiStructureFuncForStructWithDartKeywordFieldTwinNormal( + {required StructWithDartKeywordFieldTwinNormal arg}); + + Future + crateApiStructureFuncForStructWithFieldRenameTwinNormal( + {required StructWithFieldRenameTwinNormal arg}); + Future crateApiStructureFuncStructWithOneFieldTwinNormal( {required StructWithOneFieldTwinNormal arg}); @@ -4800,6 +4856,15 @@ abstract class RustLibApi extends BaseApi { CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_OpaqueTwoTwinSyncPtr; + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_SimpleOpaqueExternalStructWithMethod; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethod; + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethodPtr; + RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_StaticGetterOnlyTwinNormal; @@ -5471,6 +5536,177 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + Future crateApiCastedPrimitiveCastedPrimitiveI64TwinNormal( + {required int arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_CastedPrimitive_i_64(arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 21, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_CastedPrimitive_i_64, + decodeErrorData: null, + ), + constMeta: kCrateApiCastedPrimitiveCastedPrimitiveI64TwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveCastedPrimitiveI64TwinNormalConstMeta => + const TaskConstMeta( + debugName: "casted_primitive_i64_twin_normal", + argNames: ["arg"], + ); + + @override + Future crateApiCastedPrimitiveCastedPrimitiveIsizeTwinNormal( + {required int arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_CastedPrimitive_isize(arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 22, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_CastedPrimitive_isize, + decodeErrorData: null, + ), + constMeta: + kCrateApiCastedPrimitiveCastedPrimitiveIsizeTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveCastedPrimitiveIsizeTwinNormalConstMeta => + const TaskConstMeta( + debugName: "casted_primitive_isize_twin_normal", + argNames: ["arg"], + ); + + @override + Future crateApiCastedPrimitiveCastedPrimitiveMultiArgTwinNormal( + {required int a, required int b, required int c, required BigInt d}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_i_32(a, serializer); + sse_encode_CastedPrimitive_i_64(b, serializer); + sse_encode_CastedPrimitive_usize(c, serializer); + sse_encode_I128(d, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 23, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: + kCrateApiCastedPrimitiveCastedPrimitiveMultiArgTwinNormalConstMeta, + argValues: [a, b, c, d], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveCastedPrimitiveMultiArgTwinNormalConstMeta => + const TaskConstMeta( + debugName: "casted_primitive_multi_arg_twin_normal", + argNames: ["a", "b", "c", "d"], + ); + + @override + Future crateApiCastedPrimitiveCastedPrimitiveU64TwinNormal( + {required int arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_CastedPrimitive_u_64(arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 24, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_CastedPrimitive_u_64, + decodeErrorData: null, + ), + constMeta: kCrateApiCastedPrimitiveCastedPrimitiveU64TwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveCastedPrimitiveU64TwinNormalConstMeta => + const TaskConstMeta( + debugName: "casted_primitive_u64_twin_normal", + argNames: ["arg"], + ); + + @override + Future crateApiCastedPrimitiveCastedPrimitiveUsizeTwinNormal( + {required int arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_CastedPrimitive_usize(arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 25, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_CastedPrimitive_usize, + decodeErrorData: null, + ), + constMeta: + kCrateApiCastedPrimitiveCastedPrimitiveUsizeTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveCastedPrimitiveUsizeTwinNormalConstMeta => + const TaskConstMeta( + debugName: "casted_primitive_usize_twin_normal", + argNames: ["arg"], + ); + + @override + Future + crateApiCastedPrimitiveFunctionForStructWithCastedPrimitiveTwinNormal( + {required StructWithCastedPrimitiveTwinNormal arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_casted_primitive_twin_normal( + arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 26, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_struct_with_casted_primitive_twin_normal, + decodeErrorData: null, + ), + constMeta: + kCrateApiCastedPrimitiveFunctionForStructWithCastedPrimitiveTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCastedPrimitiveFunctionForStructWithCastedPrimitiveTwinNormalConstMeta => + const TaskConstMeta( + debugName: "function_for_struct_with_casted_primitive_twin_normal", + argNames: ["arg"], + ); + @override Future crateApiChronoTypeDatetimeLocalTwinNormal( {required DateTime d}) { @@ -5479,7 +5715,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Local(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 21, port: port_); + funcId: 27, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Local, @@ -5505,7 +5741,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Utc(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 22, port: port_); + funcId: 28, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Utc, @@ -5530,7 +5766,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Duration(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 23, port: port_); + funcId: 29, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -5557,7 +5793,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_Chrono_Duration(durations, serializer); sse_encode_Chrono_Local(since, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 24, port: port_); + funcId: 30, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Local, @@ -5584,7 +5820,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_Chrono_Naive(timestamps, serializer); sse_encode_Chrono_Naive(epoch, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 25, port: port_); + funcId: 31, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Duration, @@ -5610,7 +5846,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_feature_chrono_twin_normal(mine, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 26, port: port_); + funcId: 32, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -5636,7 +5872,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Naive(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 27, port: port_); + funcId: 33, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Naive, @@ -5662,7 +5898,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_Chrono_Utc(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 28, port: port_); + funcId: 34, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_Chrono_Utc, @@ -5687,7 +5923,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 29, port: port_); + funcId: 35, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_normal, @@ -5711,7 +5947,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 30, port: port_); + funcId: 36, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_normal, @@ -5735,7 +5971,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 31, port: port_); + funcId: 37, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -5762,7 +5998,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 32, port: port_); + funcId: 38, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -5790,7 +6026,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 33, port: port_); + funcId: 39, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -5821,7 +6057,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_comments_twin_normal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 34, port: port_); + funcId: 40, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -5849,7 +6085,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 35, port: port_); + funcId: 41, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -5878,7 +6114,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerConstructorOpaqueStructTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 36)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 42)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -5906,7 +6142,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerConstructorOpaqueStructTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 37)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 43)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -5933,7 +6169,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 38, port: port_); + funcId: 44, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -5963,7 +6199,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerConstructorOpaqueStructTwinNormal( that, serializer); sse_encode_String(one, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 39)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 45)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -5991,7 +6227,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerConstructorOpaqueSyncStructTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 40)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 46)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6019,7 +6255,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerConstructorOpaqueSyncStructTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 41)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 47)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -6045,7 +6281,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 42)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 48)!; }, codec: SseCodec( decodeSuccessData: @@ -6076,7 +6312,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerConstructorOpaqueSyncStructTwinNormal( that, serializer); sse_encode_String(one, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 43)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 49)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6103,7 +6339,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 44, port: port_); + funcId: 50, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -6130,7 +6366,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 45)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 51)!; }, codec: SseCodec( decodeSuccessData: @@ -6151,13 +6387,43 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + Future crateApiCustomSerDesFunctionUsingTypeWithCustomSerializer( + {required int arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 52, port: port_); + }, + codec: SseCodec( + decodeSuccessData: + sse_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal, + decodeErrorData: null, + ), + constMeta: + kCrateApiCustomSerDesFunctionUsingTypeWithCustomSerializerConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiCustomSerDesFunctionUsingTypeWithCustomSerializerConstMeta => + const TaskConstMeta( + debugName: "function_using_type_with_custom_serializer", + argNames: ["arg"], + ); + @override Future crateApiCustomizationCheckInitDone() { return handler.executeNormal(NormalTask( callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 46, port: port_); + funcId: 53, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -6181,7 +6447,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 47, port: port_); + funcId: 54, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6205,7 +6471,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 48, port: port_); + funcId: 55, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6229,7 +6495,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 49, port: port_); + funcId: 56, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6257,7 +6523,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 50, port: port_); + funcId: 57, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -6288,7 +6554,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_translatable_struct_with_dart_code_twin_normal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 51, port: port_); + funcId: 58, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -6320,7 +6586,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { 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: 52, port: port_); + funcId: 59, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6348,7 +6614,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callback, serializer); sse_encode_i_32(numTimes, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 53, port: port_); + funcId: 60, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6375,7 +6641,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 54, port: port_); + funcId: 61, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6404,7 +6670,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callback, serializer); sse_encode_opt_String(expectOutput, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 55, port: port_); + funcId: 62, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6432,7 +6698,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs__Output_String_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 56, port: port_); + funcId: 63, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6459,7 +6725,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs__Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 57, port: port_); + funcId: 64, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6488,7 +6754,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs_String_demo_struct_for_rust_call_dart_twin_normal_Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 58, port: port_); + funcId: 65, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6517,7 +6783,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 59, port: port_); + funcId: 66, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6546,7 +6812,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 60, port: port_); + funcId: 67, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -6574,7 +6840,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 61, port: port_); + funcId: 68, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -6601,7 +6867,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 62, port: port_); + funcId: 69, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -6628,7 +6894,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 63, port: port_); + funcId: 70, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_dart_opaque_twin_normal, @@ -6657,7 +6923,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartOpaque(opaque1, serializer); sse_encode_DartOpaque(opaque2, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 64, port: port_); + funcId: 71, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_dart_opaque_nested_twin_normal, @@ -6684,7 +6950,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 65, port: port_); + funcId: 72, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6711,7 +6977,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: 66, port: port_); + funcId: 73, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6738,7 +7004,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_dart_opaque_nested_twin_normal( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 67, port: port_); + funcId: 74, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6764,7 +7030,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque_array_1(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 68, port: port_); + funcId: 75, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6790,7 +7056,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 69, port: port_); + funcId: 76, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque_array_1, @@ -6815,7 +7081,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 70, port: port_); + funcId: 77, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6841,7 +7107,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 71, port: port_); + funcId: 78, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -6867,7 +7133,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 72, port: port_); + funcId: 79, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -6893,7 +7159,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 73, port: port_); + funcId: 80, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6919,7 +7185,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 74, port: port_); + funcId: 81, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -6945,7 +7211,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 75, port: port_); + funcId: 82, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6973,7 +7239,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(id, serializer); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 76, port: port_); + funcId: 83, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -6998,7 +7264,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: 84)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -7024,7 +7290,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: 85)!; }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -7049,7 +7315,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 79)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 86)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -7074,7 +7340,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: 80)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 87)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -7100,7 +7366,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 81)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 88)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -7128,7 +7394,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: 82, port: port_); + funcId: 89, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_in_upper_level, @@ -7159,7 +7425,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_StreamSink_i_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 83, port: port_); + funcId: 90, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7184,7 +7450,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 84, port: port_); + funcId: 91, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -7211,7 +7477,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 85, port: port_); + funcId: 92, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -7240,7 +7506,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDroppableTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 86, port: port_); + funcId: 93, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7269,7 +7535,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(one, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 87, port: port_); + funcId: 94, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -7298,7 +7564,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructOneWithTraitForDynTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 88)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 95)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -7327,7 +7593,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructOneWithTraitForDynTwinNormal( that, serializer); sse_encode_i_32(one, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 89)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 96)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7357,7 +7623,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructOneWithTraitForDynTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 90, port: port_); + funcId: 97, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -7387,7 +7653,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(two, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 91, port: port_); + funcId: 98, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -7416,7 +7682,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructTwoWithTraitForDynTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 92)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 99)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -7445,7 +7711,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructTwoWithTraitForDynTwinNormal( that, serializer); sse_encode_i_32(two, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 93)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 100)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7475,7 +7741,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructTwoWithTraitForDynTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 94, port: port_); + funcId: 101, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -7504,7 +7770,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DynTrait_SimpleTraitForDynTwinNormal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 96, port: port_); + funcId: 103, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -7530,7 +7796,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_simple_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 97, port: port_); + funcId: 104, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_simple_twin_normal, @@ -7557,7 +7823,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_with_discriminant_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 98, port: port_); + funcId: 105, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_discriminant_twin_normal, @@ -7587,7 +7853,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_mixed_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 99, port: port_); + funcId: 106, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_mixed_twin_normal, @@ -7616,7 +7882,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_struct_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 100, port: port_); + funcId: 107, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_struct_twin_normal, @@ -7645,7 +7911,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_tuple_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 101, port: port_); + funcId: 108, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_tuple_twin_normal, @@ -7672,7 +7938,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_weekdays_twin_normal(weekday, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 102, port: port_); + funcId: 109, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_weekdays_twin_normal, @@ -7699,7 +7965,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: 103, port: port_); + funcId: 110, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_kitchen_sink_twin_normal, @@ -7725,7 +7991,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 104, port: port_); + funcId: 111, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_weekdays_twin_normal, @@ -7751,7 +8017,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_measure_twin_normal(measure, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 105, port: port_); + funcId: 112, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_measure_twin_normal, @@ -7777,7 +8043,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_note_twin_normal(note, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 106, port: port_); + funcId: 113, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -7801,7 +8067,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 107, port: port_); + funcId: 114, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7828,7 +8094,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: 108)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 115)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7855,7 +8121,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(address, serializer); sse_encode_String(payload, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 109, port: port_); + funcId: 116, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7881,7 +8147,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_event_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 110, port: port_); + funcId: 117, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -7910,7 +8176,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_event_twin_normal_Sse(listener, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 111, port: port_); + funcId: 118, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7936,7 +8202,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 112, port: port_); + funcId: 119, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -7960,7 +8226,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 113, port: port_); + funcId: 120, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -7988,7 +8254,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 114, port: port_); + funcId: 121, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8016,7 +8282,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_custom_nested_error_outer_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 115, port: port_); + funcId: 122, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8044,7 +8310,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: 116, port: port_); + funcId: 123, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8073,7 +8339,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(message, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 117, port: port_); + funcId: 124, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_custom_struct_twin_normal, @@ -8101,7 +8367,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: 118, port: port_); + funcId: 125, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8131,7 +8397,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: 119, port: port_); + funcId: 126, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8159,7 +8425,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 120, port: port_); + funcId: 127, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8187,7 +8453,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 121, port: port_); + funcId: 128, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8214,7 +8480,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 122, port: port_); + funcId: 129, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -8238,7 +8504,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 123, port: port_); + funcId: 130, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -8263,7 +8529,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 124, port: port_); + funcId: 131, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -8288,7 +8554,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 125, port: port_); + funcId: 132, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8313,7 +8579,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 126, port: port_); + funcId: 133, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8338,7 +8604,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 127, port: port_); + funcId: 134, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8364,7 +8630,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 128, port: port_); + funcId: 135, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8389,7 +8655,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 129, port: port_); + funcId: 136, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8414,7 +8680,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 130, port: port_); + funcId: 137, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8438,7 +8704,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 131, port: port_); + funcId: 138, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8464,7 +8730,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(variant, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 132, port: port_); + funcId: 139, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8488,7 +8754,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 133, port: port_); + funcId: 140, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8514,7 +8780,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 134, port: port_); + funcId: 141, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_some_struct_twin_normal, @@ -8542,7 +8808,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: 135, port: port_); + funcId: 142, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8572,7 +8838,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: 136, port: port_); + funcId: 143, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8600,7 +8866,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 137, port: port_); + funcId: 144, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8628,7 +8894,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 138, port: port_); + funcId: 145, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -8658,7 +8924,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 139, port: port_); + funcId: 146, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8684,7 +8950,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 140, port: port_); + funcId: 147, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8702,6 +8968,66 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: [], ); + @override + SimpleOpaqueExternalStructWithMethod + crateApiExternalImplSimpleOpaqueExternalStructWithMethodNew( + {required String a}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_String(a, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 148)!; + }, + codec: SseCodec( + decodeSuccessData: + sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod, + decodeErrorData: null, + ), + constMeta: + kCrateApiExternalImplSimpleOpaqueExternalStructWithMethodNewConstMeta, + argValues: [a], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiExternalImplSimpleOpaqueExternalStructWithMethodNewConstMeta => + const TaskConstMeta( + debugName: "SimpleOpaqueExternalStructWithMethod_new", + argNames: ["a"], + ); + + @override + Future + crateApiExternalImplSimpleOpaqueExternalStructWithMethodSimpleExternalMethod( + {required SimpleOpaqueExternalStructWithMethod that}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + that, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 149, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_String, + decodeErrorData: null, + ), + constMeta: + kCrateApiExternalImplSimpleOpaqueExternalStructWithMethodSimpleExternalMethodConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiExternalImplSimpleOpaqueExternalStructWithMethodSimpleExternalMethodConstMeta => + const TaskConstMeta( + debugName: + "SimpleOpaqueExternalStructWithMethod_simple_external_method", + argNames: ["that"], + ); + @override Future crateApiExternalImplSimpleTranslatableExternalStructWithMethodSimpleExternalMethod( @@ -8712,7 +9038,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_simple_translatable_external_struct_with_method( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 141, port: port_); + funcId: 150, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -8740,7 +9066,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 142, port: port_); + funcId: 151, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_new_simple_struct, @@ -8767,7 +9093,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 143, port: port_); + funcId: 152, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_old_simple_struct, @@ -8795,7 +9121,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_my_enum(myEnum, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 144, port: port_); + funcId: 153, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -8822,7 +9148,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_struct(myStruct, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 145, port: port_); + funcId: 154, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -8850,7 +9176,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructOneWithTraitTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 146)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 155)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -8878,7 +9204,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructOneWithTraitTwinNormal( that, serializer); sse_encode_i_32(one, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 147)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 156)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -8907,7 +9233,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructOneWithTraitTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 148, port: port_); + funcId: 157, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -8937,7 +9263,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 149, port: port_); + funcId: 158, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -8966,7 +9292,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 150, port: port_); + funcId: 159, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -8995,7 +9321,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructTwoWithTraitTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 151)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 160)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -9023,7 +9349,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructTwoWithTraitTwinNormal( that, serializer); sse_encode_i_32(two, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 152)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 161)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9052,7 +9378,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructTwoWithTraitTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 153, port: port_); + funcId: 162, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -9082,7 +9408,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 154, port: port_); + funcId: 163, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -9111,7 +9437,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 155, port: port_); + funcId: 164, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -9139,7 +9465,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 159, port: port_); + funcId: 168, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_another_macro_struct_twin_normal, @@ -9165,7 +9491,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_macro_struct(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 160, port: port_); + funcId: 169, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_macro_struct, @@ -9191,7 +9517,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 161, port: port_); + funcId: 170, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -9218,7 +9544,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: 162, port: port_); + funcId: 171, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_list_prim_u_8_strict, @@ -9246,7 +9572,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: 163, port: port_); + funcId: 172, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_kitchen_sink_twin_normal, @@ -9275,7 +9601,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: 164, port: port_); + funcId: 173, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_enum_simple_twin_normal, @@ -9304,7 +9630,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 165, port: port_); + funcId: 174, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_String, @@ -9332,7 +9658,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_my_size(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 166, port: port_); + funcId: 175, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_my_size, @@ -9359,7 +9685,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 167, port: port_); + funcId: 176, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Set_i_32, @@ -9385,7 +9711,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 168, port: port_); + funcId: 177, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Set_String, @@ -9409,7 +9735,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 169, port: port_); + funcId: 178, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -9439,7 +9765,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(a, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 170, port: port_); + funcId: 179, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9469,7 +9795,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: 171, port: port_); + funcId: 180, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9498,7 +9824,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_u_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 172, port: port_); + funcId: 181, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9532,7 +9858,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: 173, port: port_); + funcId: 182, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9565,7 +9891,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: 174, port: port_); + funcId: 183, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9602,7 +9928,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: 175, port: port_); + funcId: 184, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -9633,7 +9959,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(a, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 176, port: port_); + funcId: 185, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_concatenate_with_twin_normal, @@ -9660,7 +9986,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: 177, port: port_); + funcId: 186, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9690,7 +10016,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(b, serializer); sse_encode_u_32(c, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 178, port: port_); + funcId: 187, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_normal_array_3, @@ -9714,7 +10040,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 179, port: port_); + funcId: 188, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_normal, @@ -9741,7 +10067,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: 180, port: port_); + funcId: 189, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9768,7 +10094,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 181, port: port_); + funcId: 190, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_enum_twin_normal, @@ -9796,7 +10122,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: 182, port: port_); + funcId: 191, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9824,7 +10150,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_simple_primitive_enum_twin_normal(that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 183, port: port_); + funcId: 192, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -9854,7 +10180,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: 184, port: port_); + funcId: 193, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9882,7 +10208,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: 185, port: port_); + funcId: 194, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9910,7 +10236,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: 186, port: port_); + funcId: 195, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -9939,7 +10265,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 187, port: port_); + funcId: 196, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_twin_normal, @@ -9967,7 +10293,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_simple_struct_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 188, port: port_); + funcId: 197, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -9995,7 +10321,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(a, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 189, port: port_); + funcId: 198, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -10025,7 +10351,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(y, serializer); sse_encode_u_32(z, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 190, port: port_); + funcId: 199, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -10051,7 +10377,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_settings_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 191, port: port_); + funcId: 200, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10079,7 +10405,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_settings_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 192, port: port_); + funcId: 201, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10105,7 +10431,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_numbers(nums, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 193, port: port_); + funcId: 202, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -10131,7 +10457,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_sequences(seqs, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 194, port: port_); + funcId: 203, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -10155,7 +10481,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 195, port: port_); + funcId: 204, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -10179,7 +10505,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 196, port: port_); + funcId: 205, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -10203,7 +10529,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 197, port: port_); + funcId: 206, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_message, @@ -10229,7 +10555,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_application_settings(appSettings, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 198, port: port_); + funcId: 207, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -10256,7 +10582,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: 199, port: port_); + funcId: 208, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10283,7 +10609,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 200, port: port_); + funcId: 209, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10311,7 +10637,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: 201, port: port_); + funcId: 210, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10339,7 +10665,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_opt_box_autoadd_application_mode_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 202, port: port_); + funcId: 211, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10366,7 +10692,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Set_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 203, port: port_); + funcId: 212, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10393,7 +10719,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: 204, port: port_); + funcId: 213, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10422,7 +10748,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_record_application_settings_raw_string_enum_mirrored_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 205, port: port_); + funcId: 214, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10449,7 +10775,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 206, port: port_); + funcId: 215, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -10477,7 +10803,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(num, serializer); sse_encode_usize(times, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 207, port: port_); + funcId: 216, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_numbers, @@ -10504,7 +10830,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(seq, serializer); sse_encode_usize(times, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 208, port: port_); + funcId: 217, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sequences, @@ -10529,7 +10855,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 209, port: port_); + funcId: 218, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_contains_mirrored_sub_struct_twin_normal, @@ -10556,7 +10882,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 210, port: port_); + funcId: 219, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_mirrored, @@ -10583,7 +10909,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 211, port: port_); + funcId: 220, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_hash_map, @@ -10609,7 +10935,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 212, port: port_); + funcId: 221, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_enum_mirrored, @@ -10636,7 +10962,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 213, port: port_); + funcId: 222, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_of_nested_raw_string_mirrored, @@ -10663,7 +10989,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 214, port: port_); + funcId: 223, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_nested_raw_string_mirrored, @@ -10691,7 +11017,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(nested, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 215, port: port_); + funcId: 224, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_enum_mirrored, @@ -10716,7 +11042,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 216, port: port_); + funcId: 225, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_mirrored, @@ -10740,7 +11066,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 217, port: port_); + funcId: 226, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_big_buffers_twin_normal, @@ -10766,7 +11092,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Char(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 218, port: port_); + funcId: 227, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Char, @@ -10792,7 +11118,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: 219, port: port_); + funcId: 228, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_tree_node_twin_normal, @@ -10820,7 +11146,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: 220, port: port_); + funcId: 229, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_nested_struct_twin_normal, @@ -10846,7 +11172,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 221, port: port_); + funcId: 230, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -10873,7 +11199,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: 222, port: port_); + funcId: 231, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_size, @@ -10899,7 +11225,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(v, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 223, port: port_); + funcId: 232, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -10926,7 +11252,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_weekdays_twin_normal(weekdays, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 224, port: port_); + funcId: 233, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_weekdays_twin_normal, @@ -10954,7 +11280,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(a, serializer); sse_encode_i_32(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 225, port: port_); + funcId: 234, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -10981,7 +11307,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_abc_twin_normal(abc, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 226, port: port_); + funcId: 235, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_abc_twin_normal, @@ -11008,7 +11334,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: 227, port: port_); + funcId: 236, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_enum_twin_normal, @@ -11033,7 +11359,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 228, port: port_); + funcId: 237, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11063,7 +11389,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDeliberateFailSanityCheckTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 229)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 238)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -11093,7 +11419,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDeliberateFailSanityCheckTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 230)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 239)!; }, codec: SseCodec( decodeSuccessData: @@ -11124,7 +11450,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDeliberateFailSanityCheckTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 231)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 240)!; }, codec: SseCodec( decodeSuccessData: @@ -11155,7 +11481,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDeliberateFailSanityCheckTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 232)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 241)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -11183,7 +11509,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDeliberateFailSanityCheckTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 233)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 242)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -11212,7 +11538,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDeliberateFailSanityCheckTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 234)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 243)!; }, codec: SseCodec( decodeSuccessData: @@ -11244,7 +11570,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDeliberateFailSanityCheckTwinNormal( that, serializer); sse_encode_list_prim_u_8_strict(deliberateBadFieldA, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 235)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 244)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11277,7 +11603,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueItemTwinNormal( deliberateBadFieldB, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 236)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 245)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11310,7 +11636,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_list_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueItemTwinNormal( deliberateBadFieldC, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 237)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 246)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11342,7 +11668,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDeliberateFailSanityCheckTwinNormal( that, serializer); sse_encode_String(goodFieldA, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 238)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 247)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11373,7 +11699,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDeliberateFailSanityCheckTwinNormal( that, serializer); sse_encode_i_32(goodFieldB, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 239)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 248)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11405,7 +11731,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_AutoExplicit_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueItemTwinNormal( goodFieldC, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 240)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 249)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11432,7 +11758,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 241, port: port_); + funcId: 250, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -11463,7 +11789,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerItemContainerSolutionOneTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 242, port: port_); + funcId: 251, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_32_strict, @@ -11492,7 +11818,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerItemContainerSolutionOneTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 243)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 252)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -11522,7 +11848,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerItemContainerSolutionOneTwinNormal( that, serializer); sse_encode_String(name, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 244)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 253)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11552,7 +11878,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 245, port: port_); + funcId: 254, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11582,7 +11908,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithImplBlockInMultiFile( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 246, port: port_); + funcId: 255, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11612,7 +11938,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithImplBlockInMultiFile( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 247, port: port_); + funcId: 256, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11640,7 +11966,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithSimpleSetterTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 248)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 257)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -11666,7 +11992,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 249)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 258)!; }, codec: SseCodec( decodeSuccessData: @@ -11696,7 +12022,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithSimpleSetterTwinNormal( that, serializer); sse_encode_i_32(value, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 250)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 259)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11724,7 +12050,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithSimpleSetterTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 251)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 260)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -11753,7 +12079,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithSimpleSetterTwinNormal( that, serializer); sse_encode_i_32(value, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 252)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 261)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11782,7 +12108,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynAnySendSyncstatic( a, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 253, port: port_); + funcId: 262, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11808,7 +12134,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 254, port: port_); + funcId: 263, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11835,7 +12161,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 255, port: port_); + funcId: 264, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_item_container_solution_two_twin_normal, @@ -11866,7 +12192,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_item_container_solution_two_twin_normal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 256, port: port_); + funcId: 265, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_32_strict, @@ -11893,7 +12219,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 257, port: port_); + funcId: 266, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11922,7 +12248,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_struct_with_custom_name_method_twin_normal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 258)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 267)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11952,7 +12278,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: 259, port: port_); + funcId: 268, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -11982,7 +12308,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleB( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 260, port: port_); + funcId: 269, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -12014,7 +12340,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleB( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 261, port: port_); + funcId: 270, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -12040,7 +12366,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 262, port: port_); + funcId: 271, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -12068,7 +12394,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_empty_twin_normal(empty, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 263, port: port_); + funcId: 272, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_empty_twin_normal, @@ -12092,7 +12418,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 264, port: port_); + funcId: 273, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -12118,7 +12444,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_my_size(l, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 265, port: port_); + funcId: 274, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_my_size, @@ -12144,7 +12470,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(names, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 266, port: port_); + funcId: 275, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -12170,7 +12496,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: 267, port: port_); + funcId: 276, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_new_type_int_twin_normal, @@ -12196,7 +12522,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_f_64(opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 268, port: port_); + funcId: 277, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -12236,7 +12562,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: 269, port: port_); + funcId: 278, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -12273,7 +12599,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_exotic_optionals_twin_normal( opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 270, port: port_); + funcId: 279, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -12302,7 +12628,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(left, serializer); sse_encode_f_64(right, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 271, port: port_); + funcId: 280, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -12328,7 +12654,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(document, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 272, port: port_); + funcId: 281, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_element_twin_normal, @@ -12354,7 +12680,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: 273, port: port_); + funcId: 282, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_vecs_twin_normal, @@ -12383,7 +12709,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: 274, port: port_); + funcId: 283, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -12410,7 +12736,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 275, port: port_); + funcId: 284, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -12436,7 +12762,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 276, port: port_); + funcId: 285, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -12462,7 +12788,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 277, port: port_); + funcId: 286, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -12487,7 +12813,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 278, port: port_); + funcId: 287, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -12513,7 +12839,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 279, port: port_); + funcId: 288, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -12541,7 +12867,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_simple_struct_for_borrow_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 280, port: port_); + funcId: 289, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_for_borrow_twin_normal, @@ -12568,7 +12894,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(n, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 281, port: port_); + funcId: 290, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_vec_of_primitive_pack_twin_normal, @@ -12602,7 +12928,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(myF64, serializer); sse_encode_bool(myBool, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 282, port: port_); + funcId: 291, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -12628,7 +12954,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(myU32, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 283, port: port_); + funcId: 292, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -12655,7 +12981,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 284, port: port_); + funcId: 293, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -12684,7 +13010,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_ProxyEnum_auto_ref_rust_opaque_flutter_rust_bridgefor_generated_rust_auto_opaque_inner_my_audio_param_twin_normal_proxy_enum( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 285, port: port_); + funcId: 294, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -12710,7 +13036,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 286, port: port_); + funcId: 295, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -12738,7 +13064,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_u_8_array_1600(blob, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 289, port: port_); + funcId: 298, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_blob_twin_rust_async, @@ -12767,7 +13093,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: 290, port: port_); + funcId: 299, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_rust_async, @@ -12794,7 +13120,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 291, port: port_); + funcId: 300, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_5, @@ -12821,7 +13147,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 292, port: port_); + funcId: 301, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_point_twin_rust_async_array_2, @@ -12849,7 +13175,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64_array_16(array, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 293, port: port_); + funcId: 302, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -12878,7 +13204,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: 294, port: port_); + funcId: 303, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_rust_async_array_2, @@ -12907,7 +13233,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8_array_32(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 295, port: port_); + funcId: 304, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_message_id_twin_rust_async, @@ -12936,7 +13262,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8_array_8(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 296, port: port_); + funcId: 305, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_box_feed_id_twin_rust_async, @@ -12965,7 +13291,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: 297, port: port_); + funcId: 306, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_box_u_8_array_8, @@ -12994,7 +13320,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_blob_twin_rust_async(blob, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 298, port: port_); + funcId: 307, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_1600, @@ -13022,7 +13348,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: 299, port: port_); + funcId: 308, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_32, @@ -13049,7 +13375,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: 300)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 309)!; }, codec: SseCodec( decodeSuccessData: sse_decode_blob_twin_sync, @@ -13075,7 +13401,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: 301)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 310)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_sync, @@ -13099,7 +13425,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 302)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 311)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_5, @@ -13124,7 +13450,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 303)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 312)!; }, codec: SseCodec( decodeSuccessData: sse_decode_point_twin_sync_array_2, @@ -13151,7 +13477,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: 304)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 313)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -13177,7 +13503,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: 305)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 314)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_id_twin_sync_array_2, @@ -13203,7 +13529,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: 306)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 315)!; }, codec: SseCodec( decodeSuccessData: sse_decode_message_id_twin_sync, @@ -13229,7 +13555,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: 307)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 316)!; }, codec: SseCodec( decodeSuccessData: sse_decode_box_feed_id_twin_sync, @@ -13256,7 +13582,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: 308)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 317)!; }, codec: SseCodec( decodeSuccessData: sse_decode_box_u_8_array_8, @@ -13283,7 +13609,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: 309)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 318)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_1600, @@ -13310,7 +13636,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: 310)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 319)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8_array_32, @@ -13338,7 +13664,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: 311, port: port_); + funcId: 320, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -13367,7 +13693,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: 312, port: port_); + funcId: 321, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_user_id_twin_rust_async, @@ -13394,7 +13720,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: 313)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 322)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -13421,7 +13747,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: 314)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 323)!; }, codec: SseCodec( decodeSuccessData: sse_decode_user_id_twin_sync, @@ -13450,7 +13776,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: 315, port: port_); + funcId: 324, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_general_enum_twin_normal, @@ -13480,7 +13806,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_basic_primitive_enum_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 316, port: port_); + funcId: 325, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_primitive_enum_twin_normal, @@ -13510,7 +13836,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: 317, port: port_); + funcId: 326, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_struct_twin_normal, @@ -13539,7 +13865,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 318, port: port_); + funcId: 327, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -13567,7 +13893,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 319, port: port_); + funcId: 328, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -13595,7 +13921,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 320, port: port_); + funcId: 329, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_32, @@ -13623,7 +13949,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 321, port: port_); + funcId: 330, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -13652,7 +13978,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_I128(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 322, port: port_); + funcId: 331, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_I128, @@ -13681,7 +14007,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_16(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 323, port: port_); + funcId: 332, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_16, @@ -13710,7 +14036,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 324, port: port_); + funcId: 333, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -13739,7 +14065,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_64(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 325, port: port_); + funcId: 334, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_64, @@ -13768,7 +14094,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_8(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 326, port: port_); + funcId: 335, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_8, @@ -13798,7 +14124,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_isize(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 327, port: port_); + funcId: 336, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_isize, @@ -13826,7 +14152,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 328, port: port_); + funcId: 337, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -13855,7 +14181,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_U128(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 329, port: port_); + funcId: 338, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_U128, @@ -13884,7 +14210,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_16(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 330, port: port_); + funcId: 339, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_16, @@ -13913,7 +14239,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 331, port: port_); + funcId: 340, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -13942,7 +14268,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_64(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 332, port: port_); + funcId: 341, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -13971,7 +14297,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_8(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 333, port: port_); + funcId: 342, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8, @@ -14000,7 +14326,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_usize(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 334, port: port_); + funcId: 343, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_usize, @@ -14029,7 +14355,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: 335, port: port_); + funcId: 344, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_general_enum_twin_normal, @@ -14059,7 +14385,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: 336, port: port_); + funcId: 345, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_primitive_enum_twin_normal, @@ -14089,7 +14415,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_basic_struct_twin_normal(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 337, port: port_); + funcId: 346, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_struct_twin_normal, @@ -14119,7 +14445,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 338, port: port_); + funcId: 347, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_bool, @@ -14148,7 +14474,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: 339, port: port_); + funcId: 348, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_list_prim_u_8_strict, @@ -14177,7 +14503,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 340, port: port_); + funcId: 349, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_32_strict, @@ -14206,7 +14532,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_64_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 341, port: port_); + funcId: 350, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_64_strict, @@ -14235,7 +14561,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 342, port: port_); + funcId: 351, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_16_strict, @@ -14264,7 +14590,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 343, port: port_); + funcId: 352, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_32_strict, @@ -14293,7 +14619,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 344, port: port_); + funcId: 353, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_64_strict, @@ -14322,7 +14648,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 345, port: port_); + funcId: 354, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_8_strict, @@ -14351,7 +14677,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 346, port: port_); + funcId: 355, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -14380,7 +14706,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 347, port: port_); + funcId: 356, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_16_strict, @@ -14409,7 +14735,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 348, port: port_); + funcId: 357, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_32_strict, @@ -14438,7 +14764,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 349, port: port_); + funcId: 358, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_64_strict, @@ -14467,7 +14793,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 350, port: port_); + funcId: 359, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -14496,7 +14822,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: 351, port: port_); + funcId: 360, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_general_enum_twin_rust_async, @@ -14526,7 +14852,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: 352, port: port_); + funcId: 361, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_primitive_enum_twin_rust_async, @@ -14556,7 +14882,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: 353, port: port_); + funcId: 362, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_struct_twin_rust_async, @@ -14586,7 +14912,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 354, port: port_); + funcId: 363, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_bool, @@ -14615,7 +14941,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: 355, port: port_); + funcId: 364, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_list_prim_u_8_strict, @@ -14644,7 +14970,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 356, port: port_); + funcId: 365, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_32_strict, @@ -14673,7 +14999,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_f_64_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 357, port: port_); + funcId: 366, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_64_strict, @@ -14702,7 +15028,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 358, port: port_); + funcId: 367, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_16_strict, @@ -14731,7 +15057,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 359, port: port_); + funcId: 368, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_32_strict, @@ -14760,7 +15086,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 360, port: port_); + funcId: 369, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_64_strict, @@ -14789,7 +15115,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_i_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 361, port: port_); + funcId: 370, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_8_strict, @@ -14818,7 +15144,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 362, port: port_); + funcId: 371, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -14847,7 +15173,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_16_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 363, port: port_); + funcId: 372, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_16_strict, @@ -14876,7 +15202,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_32_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 364, port: port_); + funcId: 373, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_32_strict, @@ -14905,7 +15231,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_64_strict(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 365, port: port_); + funcId: 374, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_64_strict, @@ -14934,7 +15260,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 366, port: port_); + funcId: 375, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -14962,7 +15288,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: 367)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 376)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_general_enum_twin_sync, @@ -14991,7 +15317,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: 368)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 377)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_primitive_enum_twin_sync, @@ -15020,7 +15346,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: 369)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 378)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_basic_struct_twin_sync, @@ -15049,7 +15375,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_bool(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 370)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 379)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_bool, @@ -15077,7 +15403,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: 371)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 380)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_list_prim_u_8_strict, @@ -15105,7 +15431,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: 372)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 381)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_32_strict, @@ -15133,7 +15459,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: 373)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 382)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_f_64_strict, @@ -15161,7 +15487,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: 374)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 383)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_16_strict, @@ -15189,7 +15515,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: 375)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 384)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_32_strict, @@ -15217,7 +15543,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: 376)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 385)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_64_strict, @@ -15244,7 +15570,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: 377)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 386)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_i_8_strict, @@ -15272,7 +15598,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 378)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 387)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -15300,7 +15626,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: 379)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 388)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_16_strict, @@ -15328,7 +15654,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: 380)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 389)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_32_strict, @@ -15356,7 +15682,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: 381)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 390)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_64_strict, @@ -15383,7 +15709,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: 382)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 391)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -15412,7 +15738,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: 383, port: port_); + funcId: 392, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_general_enum_twin_normal, @@ -15442,7 +15768,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: 384, port: port_); + funcId: 393, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_primitive_enum_twin_normal, @@ -15472,7 +15798,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: 385, port: port_); + funcId: 394, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_struct_twin_normal, @@ -15502,7 +15828,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 386, port: port_); + funcId: 395, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_bool, @@ -15531,7 +15857,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: 387, port: port_); + funcId: 396, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_list_prim_u_8_strict, @@ -15560,7 +15886,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 388, port: port_); + funcId: 397, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_32, @@ -15589,7 +15915,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 389, port: port_); + funcId: 398, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_64, @@ -15618,7 +15944,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_I128(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 390, port: port_); + funcId: 399, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_I128, @@ -15647,7 +15973,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 391, port: port_); + funcId: 400, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_16, @@ -15676,7 +16002,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 392, port: port_); + funcId: 401, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -15705,7 +16031,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 393, port: port_); + funcId: 402, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_64, @@ -15734,7 +16060,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 394, port: port_); + funcId: 403, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_8, @@ -15763,7 +16089,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 395, port: port_); + funcId: 404, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_isize, @@ -15792,7 +16118,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 396, port: port_); + funcId: 405, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_String, @@ -15821,7 +16147,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_U128(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 397, port: port_); + funcId: 406, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_U128, @@ -15850,7 +16176,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 398, port: port_); + funcId: 407, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_16, @@ -15879,7 +16205,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 399, port: port_); + funcId: 408, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_32, @@ -15908,7 +16234,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 400, port: port_); + funcId: 409, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_64, @@ -15937,7 +16263,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 401, port: port_); + funcId: 410, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_8, @@ -15966,7 +16292,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 402, port: port_); + funcId: 411, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_usize, @@ -15995,7 +16321,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: 403, port: port_); + funcId: 412, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -16027,7 +16353,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Map_i_32_basic_primitive_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 404, port: port_); + funcId: 413, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -16058,7 +16384,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: 405, port: port_); + funcId: 414, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_struct_twin_rust_async, @@ -16088,7 +16414,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 406, port: port_); + funcId: 415, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_bool, @@ -16117,7 +16443,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: 407, port: port_); + funcId: 416, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_list_prim_u_8_strict, @@ -16146,7 +16472,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 408, port: port_); + funcId: 417, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_32, @@ -16175,7 +16501,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 409, port: port_); + funcId: 418, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_64, @@ -16204,7 +16530,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_I128(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 410, port: port_); + funcId: 419, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_I128, @@ -16233,7 +16559,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 411, port: port_); + funcId: 420, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_16, @@ -16262,7 +16588,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 412, port: port_); + funcId: 421, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -16291,7 +16617,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 413, port: port_); + funcId: 422, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_64, @@ -16320,7 +16646,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 414, port: port_); + funcId: 423, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_8, @@ -16349,7 +16675,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 415, port: port_); + funcId: 424, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_isize, @@ -16378,7 +16704,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 416, port: port_); + funcId: 425, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_String, @@ -16407,7 +16733,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_U128(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 417, port: port_); + funcId: 426, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_U128, @@ -16436,7 +16762,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 418, port: port_); + funcId: 427, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_16, @@ -16465,7 +16791,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 419, port: port_); + funcId: 428, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_32, @@ -16494,7 +16820,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 420, port: port_); + funcId: 429, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_64, @@ -16523,7 +16849,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 421, port: port_); + funcId: 430, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_8, @@ -16552,7 +16878,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 422, port: port_); + funcId: 431, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_usize, @@ -16580,7 +16906,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: 423)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 432)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_general_enum_twin_sync, @@ -16609,7 +16935,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: 424)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 433)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_primitive_enum_twin_sync, @@ -16638,7 +16964,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: 425)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 434)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_basic_struct_twin_sync, @@ -16667,7 +16993,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: 426)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 435)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_bool, @@ -16695,7 +17021,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: 427)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 436)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_list_prim_u_8_strict, @@ -16723,7 +17049,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: 428)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 437)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_32, @@ -16751,7 +17077,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: 429)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 438)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_f_64, @@ -16779,7 +17105,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_I128(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 430)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 439)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_I128, @@ -16807,7 +17133,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: 431)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 440)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_16, @@ -16835,7 +17161,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: 432)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 441)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -16863,7 +17189,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: 433)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 442)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_64, @@ -16891,7 +17217,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: 434)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 443)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_8, @@ -16919,7 +17245,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: 435)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 444)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_isize, @@ -16947,7 +17273,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: 436)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 445)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_String, @@ -16975,7 +17301,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_U128(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 437)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 446)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_U128, @@ -17003,7 +17329,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: 438)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 447)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_16, @@ -17031,7 +17357,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: 439)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 448)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_32, @@ -17059,7 +17385,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: 440)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 449)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_64, @@ -17087,7 +17413,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: 441)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 450)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_u_8, @@ -17115,7 +17441,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: 442)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 451)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_usize, @@ -17145,7 +17471,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_general_enum_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 443, port: port_); + funcId: 452, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -17177,7 +17503,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_primitive_enum_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 444, port: port_); + funcId: 453, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -17208,7 +17534,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: 445, port: port_); + funcId: 454, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_basic_struct_twin_normal, @@ -17238,7 +17564,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 446, port: port_); + funcId: 455, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_bool, @@ -17267,7 +17593,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: 447, port: port_); + funcId: 456, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_list_prim_u_8_strict, @@ -17296,7 +17622,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 448, port: port_); + funcId: 457, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_32, @@ -17325,7 +17651,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 449, port: port_); + funcId: 458, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -17354,7 +17680,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_I128(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 450, port: port_); + funcId: 459, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_I128, @@ -17383,7 +17709,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 451, port: port_); + funcId: 460, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_16, @@ -17412,7 +17738,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 452, port: port_); + funcId: 461, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -17441,7 +17767,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 453, port: port_); + funcId: 462, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_64, @@ -17470,7 +17796,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 454, port: port_); + funcId: 463, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_8, @@ -17499,7 +17825,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 455, port: port_); + funcId: 464, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_isize, @@ -17528,7 +17854,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 456, port: port_); + funcId: 465, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_String, @@ -17557,7 +17883,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_U128(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 457, port: port_); + funcId: 466, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_U128, @@ -17586,7 +17912,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 458, port: port_); + funcId: 467, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_16, @@ -17615,7 +17941,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 459, port: port_); + funcId: 468, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_32, @@ -17644,7 +17970,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 460, port: port_); + funcId: 469, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_64, @@ -17673,7 +17999,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 461, port: port_); + funcId: 470, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_8, @@ -17702,7 +18028,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 462, port: port_); + funcId: 471, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_usize, @@ -17732,7 +18058,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_general_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 463, port: port_); + funcId: 472, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -17764,7 +18090,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_primitive_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 464, port: port_); + funcId: 473, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -17796,7 +18122,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_basic_struct_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 465, port: port_); + funcId: 474, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -17827,7 +18153,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 466, port: port_); + funcId: 475, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_bool, @@ -17856,7 +18182,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: 467, port: port_); + funcId: 476, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_list_prim_u_8_strict, @@ -17885,7 +18211,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 468, port: port_); + funcId: 477, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_32, @@ -17914,7 +18240,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 469, port: port_); + funcId: 478, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -17943,7 +18269,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_I128(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 470, port: port_); + funcId: 479, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_I128, @@ -17972,7 +18298,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 471, port: port_); + funcId: 480, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_16, @@ -18001,7 +18327,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 472, port: port_); + funcId: 481, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -18030,7 +18356,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 473, port: port_); + funcId: 482, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_64, @@ -18059,7 +18385,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_i_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 474, port: port_); + funcId: 483, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_8, @@ -18088,7 +18414,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_isize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 475, port: port_); + funcId: 484, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_isize, @@ -18117,7 +18443,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 476, port: port_); + funcId: 485, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_String, @@ -18146,7 +18472,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_U128(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 477, port: port_); + funcId: 486, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_U128, @@ -18175,7 +18501,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_16(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 478, port: port_); + funcId: 487, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_16, @@ -18204,7 +18530,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 479, port: port_); + funcId: 488, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_32, @@ -18233,7 +18559,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 480, port: port_); + funcId: 489, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_64, @@ -18262,7 +18588,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_u_8(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 481, port: port_); + funcId: 490, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_8, @@ -18291,7 +18617,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_usize(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 482, port: port_); + funcId: 491, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_usize, @@ -18320,7 +18646,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: 483)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 492)!; }, codec: SseCodec( decodeSuccessData: @@ -18351,7 +18677,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: 484)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 493)!; }, codec: SseCodec( decodeSuccessData: @@ -18381,7 +18707,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: 485)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 494)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_basic_struct_twin_sync, @@ -18410,7 +18736,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: 486)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 495)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_bool, @@ -18438,7 +18764,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: 487)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 496)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_list_prim_u_8_strict, @@ -18466,7 +18792,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: 488)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 497)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_32, @@ -18494,7 +18820,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: 489)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 498)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -18522,7 +18848,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_I128(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 490)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 499)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_I128, @@ -18550,7 +18876,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: 491)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 500)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_16, @@ -18578,7 +18904,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: 492)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 501)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -18606,7 +18932,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: 493)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 502)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_64, @@ -18634,7 +18960,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: 494)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 503)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_8, @@ -18662,7 +18988,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: 495)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 504)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_isize, @@ -18690,7 +19016,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 496)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 505)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_String, @@ -18718,7 +19044,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_U128(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 497)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 506)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_U128, @@ -18746,7 +19072,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: 498)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 507)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_16, @@ -18774,7 +19100,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: 499)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 508)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_32, @@ -18802,7 +19128,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: 500)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 509)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_64, @@ -18830,7 +19156,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: 501)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 510)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_u_8, @@ -18858,7 +19184,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: 502)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 511)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_usize, @@ -18888,7 +19214,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_basic_general_enum_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 503, port: port_); + funcId: 512, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_general_enum_twin_rust_async, @@ -18918,7 +19244,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: 504, port: port_); + funcId: 513, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_primitive_enum_twin_rust_async, @@ -18948,7 +19274,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: 505, port: port_); + funcId: 514, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_basic_struct_twin_rust_async, @@ -18978,7 +19304,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 506, port: port_); + funcId: 515, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -19007,7 +19333,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 507, port: port_); + funcId: 516, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19036,7 +19362,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 508, port: port_); + funcId: 517, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_32, @@ -19065,7 +19391,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 509, port: port_); + funcId: 518, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -19095,7 +19421,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_I128(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 510, port: port_); + funcId: 519, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_I128, @@ -19125,7 +19451,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_16(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 511, port: port_); + funcId: 520, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_16, @@ -19155,7 +19481,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 512, port: port_); + funcId: 521, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -19185,7 +19511,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_64(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 513, port: port_); + funcId: 522, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_64, @@ -19215,7 +19541,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_8(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 514, port: port_); + funcId: 523, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_8, @@ -19245,7 +19571,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_isize(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 515, port: port_); + funcId: 524, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_isize, @@ -19274,7 +19600,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 516, port: port_); + funcId: 525, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -19304,7 +19630,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_U128(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 517, port: port_); + funcId: 526, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_U128, @@ -19334,7 +19660,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_16(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 518, port: port_); + funcId: 527, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_16, @@ -19364,7 +19690,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 519, port: port_); + funcId: 528, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -19394,7 +19720,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_64(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 520, port: port_); + funcId: 529, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -19424,7 +19750,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_8(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 521, port: port_); + funcId: 530, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_8, @@ -19454,7 +19780,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_usize(arg, serializer); sse_encode_String(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 522, port: port_); + funcId: 531, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_usize, @@ -19482,7 +19808,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: 523)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 532)!; }, codec: SseCodec( decodeSuccessData: sse_decode_basic_general_enum_twin_sync, @@ -19511,7 +19837,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: 524)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 533)!; }, codec: SseCodec( decodeSuccessData: sse_decode_basic_primitive_enum_twin_sync, @@ -19540,7 +19866,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: 525)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 534)!; }, codec: SseCodec( decodeSuccessData: sse_decode_basic_struct_twin_sync, @@ -19567,7 +19893,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 526)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 535)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -19594,7 +19920,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: 527)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 536)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -19621,7 +19947,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 528)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 537)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_32, @@ -19648,7 +19974,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_f_64(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 529)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 538)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -19676,7 +20002,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_I128(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 530)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 539)!; }, codec: SseCodec( decodeSuccessData: sse_decode_I128, @@ -19704,7 +20030,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_16(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 531)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 540)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_16, @@ -19732,7 +20058,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 532)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 541)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -19760,7 +20086,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_64(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 533)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 542)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_64, @@ -19788,7 +20114,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_8(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 534)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 543)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_8, @@ -19816,7 +20142,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_isize(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 535)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 544)!; }, codec: SseCodec( decodeSuccessData: sse_decode_isize, @@ -19843,7 +20169,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 536)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 545)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -19871,7 +20197,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_U128(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 537)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 546)!; }, codec: SseCodec( decodeSuccessData: sse_decode_U128, @@ -19899,7 +20225,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_16(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 538)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 547)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_16, @@ -19927,7 +20253,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 539)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 548)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -19955,7 +20281,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 540)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 549)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -19983,7 +20309,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_8(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 541)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 550)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_8, @@ -20011,7 +20337,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_usize(arg, serializer); sse_encode_String(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 542)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 551)!; }, codec: SseCodec( decodeSuccessData: sse_decode_usize, @@ -20040,7 +20366,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 543, port: port_); + funcId: 552, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20069,7 +20395,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 544, port: port_); + funcId: 553, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20099,7 +20425,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_benchmark_binary_tree_twin_normal( tree, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 545, port: port_); + funcId: 554, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20128,7 +20454,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 546, port: port_); + funcId: 555, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -20157,7 +20483,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 547, port: port_); + funcId: 556, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -20186,7 +20512,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 548, port: port_); + funcId: 557, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_binary_tree_twin_normal, @@ -20214,7 +20540,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 549, port: port_); + funcId: 558, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20243,7 +20569,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 550, port: port_); + funcId: 559, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20271,7 +20597,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: 551, port: port_); + funcId: 560, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20300,7 +20626,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 552, port: port_); + funcId: 561, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -20329,7 +20655,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 553, port: port_); + funcId: 562, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -20358,7 +20684,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 554, port: port_); + funcId: 563, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_blob_twin_normal, @@ -20386,7 +20712,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(bytes, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 555, port: port_); + funcId: 564, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -20415,7 +20741,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 556, port: port_); + funcId: 565, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -20441,7 +20767,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 557, port: port_); + funcId: 566, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20470,7 +20796,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 558, port: port_); + funcId: 567, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20499,7 +20825,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 559, port: port_); + funcId: 568, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20529,7 +20855,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_benchmark_binary_tree_twin_rust_async( tree, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 560, port: port_); + funcId: 569, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20558,7 +20884,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 561, port: port_); + funcId: 570, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -20587,7 +20913,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 562, port: port_); + funcId: 571, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -20616,7 +20942,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 563, port: port_); + funcId: 572, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_binary_tree_twin_rust_async, @@ -20645,7 +20971,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 564, port: port_); + funcId: 573, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20674,7 +21000,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(raw, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 565, port: port_); + funcId: 574, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20703,7 +21029,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: 566, port: port_); + funcId: 575, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20732,7 +21058,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 567, port: port_); + funcId: 576, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -20761,7 +21087,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 568, port: port_); + funcId: 577, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -20790,7 +21116,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 569, port: port_); + funcId: 578, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_blob_twin_rust_async, @@ -20819,7 +21145,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(bytes, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 570, port: port_); + funcId: 579, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -20848,7 +21174,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 571, port: port_); + funcId: 580, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -20875,7 +21201,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 572, port: port_); + funcId: 581, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20903,7 +21229,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 573)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 582)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20931,7 +21257,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: 574)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 583)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20959,7 +21285,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: 575)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 584)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -20987,7 +21313,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 576)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 585)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -21015,7 +21341,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 577)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 586)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -21043,7 +21369,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(depth, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 578)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 587)!; }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_binary_tree_twin_sync, @@ -21070,7 +21396,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(raw, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 579)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 588)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21098,7 +21424,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: 580)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 589)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21125,7 +21451,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: 581)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 590)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21153,7 +21479,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 582)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 591)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -21181,7 +21507,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 583)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 592)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -21209,7 +21535,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 584)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 593)!; }, codec: SseCodec( decodeSuccessData: sse_decode_benchmark_blob_twin_sync, @@ -21236,7 +21562,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: 585)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 594)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -21264,7 +21590,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(size, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 586)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 595)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -21289,7 +21615,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 587)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 596)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21318,7 +21644,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Local(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 588, port: port_); + funcId: 597, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Local, @@ -21347,7 +21673,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Utc(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 589, port: port_); + funcId: 598, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Utc, @@ -21376,7 +21702,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Duration(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 590, port: port_); + funcId: 599, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -21406,7 +21732,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_Chrono_Duration(durations, serializer); sse_encode_Chrono_Local(since, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 591, port: port_); + funcId: 600, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Local, @@ -21436,7 +21762,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_list_Chrono_Naive(timestamps, serializer); sse_encode_Chrono_Naive(epoch, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 592, port: port_); + funcId: 601, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Duration, @@ -21465,7 +21791,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: 593, port: port_); + funcId: 602, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -21494,7 +21820,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Naive(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 594, port: port_); + funcId: 603, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Naive, @@ -21523,7 +21849,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_Chrono_Utc(d, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 595, port: port_); + funcId: 604, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_Chrono_Utc, @@ -21550,7 +21876,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 596, port: port_); + funcId: 605, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_rust_async, @@ -21577,7 +21903,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 597, port: port_); + funcId: 606, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_rust_async, @@ -21604,7 +21930,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Local(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 598)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 607)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Local, @@ -21631,7 +21957,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Utc(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 599)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 608)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Utc, @@ -21658,7 +21984,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Duration(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 600)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 609)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -21686,7 +22012,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: 601)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 610)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Local, @@ -21714,7 +22040,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: 602)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 611)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_Chrono_Duration, @@ -21741,7 +22067,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: 603)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 612)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Duration, @@ -21768,7 +22094,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Chrono_Naive(d, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 604)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 613)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Chrono_Naive, @@ -21796,7 +22122,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: 605)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 614)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_Chrono_Utc, @@ -21822,7 +22148,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 606)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 615)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_sync, @@ -21848,7 +22174,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 607)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 616)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_chrono_twin_sync, @@ -21875,7 +22201,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 608, port: port_); + funcId: 617, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21902,7 +22228,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 609, port: port_); + funcId: 618, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21930,7 +22256,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 610, port: port_); + funcId: 619, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21961,7 +22287,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_comments_twin_rust_async( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 611, port: port_); + funcId: 620, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -21989,7 +22315,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 612, port: port_); + funcId: 621, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22016,7 +22342,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 613)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 622)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22042,7 +22368,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 614)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 623)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22069,7 +22395,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 615)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 624)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22098,7 +22424,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: 616)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 625)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22125,7 +22451,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 617)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 626)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22157,7 +22483,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: 618, port: port_); + funcId: 627, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22189,7 +22515,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callback, serializer); sse_encode_i_32(numTimes, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 619, port: port_); + funcId: 628, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22219,7 +22545,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs_String_Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 620, port: port_); + funcId: 629, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22251,7 +22577,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callback, serializer); sse_encode_opt_String(expectOutput, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 621, port: port_); + funcId: 630, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22281,7 +22607,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs__Output_String_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 622, port: port_); + funcId: 631, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22311,7 +22637,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs__Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 623, port: port_); + funcId: 632, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22343,7 +22669,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: 624, port: port_); + funcId: 633, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22375,7 +22701,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 625, port: port_); + funcId: 634, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22405,7 +22731,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartFn_Inputs__Output_DartOpaque_AnyhowException( callback, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 626, port: port_); + funcId: 635, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -22434,7 +22760,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 627, port: port_); + funcId: 636, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -22463,7 +22789,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 628, port: port_); + funcId: 637, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -22492,7 +22818,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 629, port: port_); + funcId: 638, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_dart_opaque_twin_rust_async, @@ -22522,7 +22848,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_DartOpaque(opaque1, serializer); sse_encode_DartOpaque(opaque2, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 630, port: port_); + funcId: 639, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_dart_opaque_nested_twin_rust_async, @@ -22551,7 +22877,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 631, port: port_); + funcId: 640, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22581,7 +22907,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_dart_opaque_twin_rust_async( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 632, port: port_); + funcId: 641, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22611,7 +22937,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_dart_opaque_nested_twin_rust_async( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 633, port: port_); + funcId: 642, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22640,7 +22966,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque_array_1(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 634, port: port_); + funcId: 643, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22669,7 +22995,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 635, port: port_); + funcId: 644, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque_array_1, @@ -22698,7 +23024,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_autoadd_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 636, port: port_); + funcId: 645, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22727,7 +23053,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 637, port: port_); + funcId: 646, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -22756,7 +23082,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 638, port: port_); + funcId: 647, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -22785,7 +23111,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 639, port: port_); + funcId: 648, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22814,7 +23140,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 640, port: port_); + funcId: 649, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -22843,7 +23169,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 641, port: port_); + funcId: 650, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22873,7 +23199,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(id, serializer); sse_encode_DartOpaque(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 642, port: port_); + funcId: 651, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -22900,7 +23226,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 643)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 652)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -22927,7 +23253,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 644)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 653)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -22955,7 +23281,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 645)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 654)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_dart_opaque_twin_sync, @@ -22984,7 +23310,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: 646)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 655)!; }, codec: SseCodec( decodeSuccessData: sse_decode_dart_opaque_nested_twin_sync, @@ -23011,7 +23337,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 647)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 656)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23038,7 +23364,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: 648)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 657)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23065,7 +23391,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: 649)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 658)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23092,7 +23418,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque_array_1(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 650)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 659)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23119,7 +23445,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 651)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 660)!; }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque_array_1, @@ -23146,7 +23472,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: 652)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 661)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23173,7 +23499,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 653)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 662)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_DartOpaque, @@ -23200,7 +23526,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 654)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 663)!; }, codec: SseCodec( decodeSuccessData: sse_decode_DartOpaque, @@ -23227,7 +23553,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 655)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 664)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23254,7 +23580,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 656)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 665)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_DartOpaque, @@ -23281,7 +23607,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_DartOpaque(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 657)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 666)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23309,7 +23635,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: 658)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 667)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23341,7 +23667,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_StreamSink_i_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 659, port: port_); + funcId: 668, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23369,7 +23695,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 660, port: port_); + funcId: 669, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23396,7 +23722,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 661, port: port_); + funcId: 670, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -23427,7 +23753,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerDroppableTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 662, port: port_); + funcId: 671, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23458,7 +23784,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: 663)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 672)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23484,7 +23810,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: 673)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -23510,7 +23836,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: 674)!; }, codec: SseCodec( decodeSuccessData: @@ -23540,7 +23866,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: 666)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 675)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -23569,7 +23895,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_enum_simple_twin_rust_async(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 667, port: port_); + funcId: 676, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_simple_twin_rust_async, @@ -23598,7 +23924,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: 668, port: port_); + funcId: 677, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_discriminant_twin_rust_async, @@ -23628,7 +23954,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_mixed_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 669, port: port_); + funcId: 678, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_mixed_twin_rust_async, @@ -23658,7 +23984,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_struct_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 670, port: port_); + funcId: 679, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_struct_twin_rust_async, @@ -23688,7 +24014,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_item_tuple_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 671, port: port_); + funcId: 680, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_tuple_twin_rust_async, @@ -23717,7 +24043,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_weekdays_twin_rust_async(weekday, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 672, port: port_); + funcId: 681, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_weekdays_twin_rust_async, @@ -23746,7 +24072,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: 673, port: port_); + funcId: 682, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_kitchen_sink_twin_rust_async, @@ -23775,7 +24101,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 674, port: port_); + funcId: 683, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_weekdays_twin_rust_async, @@ -23804,7 +24130,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: 675, port: port_); + funcId: 684, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_measure_twin_rust_async, @@ -23833,7 +24159,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: 676, port: port_); + funcId: 685, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -23861,7 +24187,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: 677)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 686)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_simple_twin_sync, @@ -23889,7 +24215,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: 678)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 687)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_discriminant_twin_sync, @@ -23917,7 +24243,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: 679)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 688)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_mixed_twin_sync, @@ -23945,7 +24271,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: 680)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 689)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_struct_twin_sync, @@ -23973,7 +24299,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: 681)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 690)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_item_tuple_twin_sync, @@ -24001,7 +24327,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_weekdays_twin_sync(weekday, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 682)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 691)!; }, codec: SseCodec( decodeSuccessData: sse_decode_weekdays_twin_sync, @@ -24029,7 +24355,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: 683)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 692)!; }, codec: SseCodec( decodeSuccessData: sse_decode_kitchen_sink_twin_sync, @@ -24057,7 +24383,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 684)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 693)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_weekdays_twin_sync, @@ -24084,7 +24410,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: 685)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 694)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_measure_twin_sync, @@ -24111,7 +24437,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: 686)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 695)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -24138,7 +24464,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 687, port: port_); + funcId: 696, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24168,7 +24494,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(address, serializer); sse_encode_String(payload, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 688, port: port_); + funcId: 697, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24197,7 +24523,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: 689, port: port_); + funcId: 698, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -24226,7 +24552,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: 690, port: port_); + funcId: 699, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24254,7 +24580,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 691, port: port_); + funcId: 700, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24281,7 +24607,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 692, port: port_); + funcId: 701, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24310,7 +24636,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 693, port: port_); + funcId: 702, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24340,7 +24666,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_custom_nested_error_outer_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 694, port: port_); + funcId: 703, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24370,7 +24696,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_custom_struct_error_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 695, port: port_); + funcId: 704, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24399,7 +24725,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(message, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 696, port: port_); + funcId: 705, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_custom_struct_twin_rust_async, @@ -24428,7 +24754,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: 697, port: port_); + funcId: 706, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24458,7 +24784,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: 698, port: port_); + funcId: 707, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24486,7 +24812,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 699, port: port_); + funcId: 708, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24514,7 +24840,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 700, port: port_); + funcId: 709, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24542,7 +24868,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 701, port: port_); + funcId: 710, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -24569,7 +24895,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 702, port: port_); + funcId: 711, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -24596,7 +24922,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 703, port: port_); + funcId: 712, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -24623,7 +24949,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 704, port: port_); + funcId: 713, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24650,7 +24976,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 705, port: port_); + funcId: 714, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24677,7 +25003,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 706, port: port_); + funcId: 715, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24704,7 +25030,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 707, port: port_); + funcId: 716, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24731,7 +25057,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 708, port: port_); + funcId: 717, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -24758,7 +25084,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 709, port: port_); + funcId: 718, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24785,7 +25111,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 710, port: port_); + funcId: 719, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24814,7 +25140,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(variant, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 711, port: port_); + funcId: 720, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24841,7 +25167,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 712, port: port_); + funcId: 721, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24870,7 +25196,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 713, port: port_); + funcId: 722, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_some_struct_twin_rust_async, @@ -24899,7 +25225,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: 714, port: port_); + funcId: 723, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24929,7 +25255,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: 715, port: port_); + funcId: 724, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24957,7 +25283,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 716, port: port_); + funcId: 725, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -24985,7 +25311,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 717, port: port_); + funcId: 726, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25015,7 +25341,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 718, port: port_); + funcId: 727, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25043,7 +25369,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 719, port: port_); + funcId: 728, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25068,7 +25394,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 720)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 729)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25093,7 +25419,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 721)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 730)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25120,7 +25446,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 722)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 731)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25149,7 +25475,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: 723)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 732)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25177,7 +25503,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: 724)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 733)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25205,7 +25531,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(message, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 725)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 734)!; }, codec: SseCodec( decodeSuccessData: sse_decode_custom_struct_twin_sync, @@ -25233,7 +25559,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: 726)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 735)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25261,7 +25587,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: 727)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 736)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25288,7 +25614,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 728)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 737)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25314,7 +25640,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 729)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 738)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25340,7 +25666,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 730)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 739)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -25365,7 +25691,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 731)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 740)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -25390,7 +25716,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 732)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 741)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -25415,7 +25741,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 733)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 742)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25440,7 +25766,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 734)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 743)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25466,7 +25792,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 735)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 744)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25491,7 +25817,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 736)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 745)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25516,7 +25842,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 737)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 746)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25541,7 +25867,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 738)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 747)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25566,7 +25892,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 739)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 748)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25593,7 +25919,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(variant, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 740)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 749)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25618,7 +25944,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 741)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 750)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25646,7 +25972,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(value, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 742)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 751)!; }, codec: SseCodec( decodeSuccessData: sse_decode_some_struct_twin_sync, @@ -25673,7 +25999,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: 743)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 752)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25701,7 +26027,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: 744)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 753)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25727,7 +26053,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: 754)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25753,7 +26079,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 746)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 755)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -25782,7 +26108,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 747)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 756)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25808,7 +26134,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 748)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 757)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -25835,7 +26161,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 749, port: port_); + funcId: 758, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_new_simple_struct, @@ -25862,7 +26188,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 750, port: port_); + funcId: 759, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_old_simple_struct, @@ -25891,7 +26217,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_my_enum(myEnum, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 751, port: port_); + funcId: 760, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -25920,7 +26246,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_my_struct(myStruct, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 752, port: port_); + funcId: 761, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -25946,7 +26272,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 753)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 762)!; }, codec: SseCodec( decodeSuccessData: sse_decode_new_simple_struct, @@ -25972,7 +26298,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 754)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 763)!; }, codec: SseCodec( decodeSuccessData: sse_decode_old_simple_struct, @@ -25999,7 +26325,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_my_enum(myEnum, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 755)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 764)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -26026,7 +26352,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: 756)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 765)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -26054,7 +26380,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructOneWithTraitTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 757)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 766)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -26083,7 +26409,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructOneWithTraitTwinSync( that, serializer); sse_encode_i_32(one, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 758)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 767)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26113,7 +26439,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructOneWithTraitTwinSync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 759, port: port_); + funcId: 768, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -26143,7 +26469,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 760, port: port_); + funcId: 769, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -26171,7 +26497,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 761, port: port_); + funcId: 770, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -26200,7 +26526,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructTwoWithTraitTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 762)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 771)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -26229,7 +26555,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructTwoWithTraitTwinSync( that, serializer); sse_encode_i_32(two, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 763)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 772)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26259,7 +26585,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructTwoWithTraitTwinSync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 764, port: port_); + funcId: 773, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -26289,7 +26615,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 765, port: port_); + funcId: 774, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -26317,7 +26643,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 766, port: port_); + funcId: 775, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -26347,7 +26673,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_i_32_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 770, port: port_); + funcId: 779, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -26376,7 +26702,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: 771, port: port_); + funcId: 780, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_list_prim_u_8_strict, @@ -26405,7 +26731,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: 772, port: port_); + funcId: 781, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_kitchen_sink_twin_rust_async, @@ -26434,7 +26760,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: 773, port: port_); + funcId: 782, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_enum_simple_twin_rust_async, @@ -26463,7 +26789,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 774, port: port_); + funcId: 783, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_String, @@ -26492,7 +26818,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_my_size(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 775, port: port_); + funcId: 784, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_my_size, @@ -26521,7 +26847,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 776, port: port_); + funcId: 785, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Set_i_32, @@ -26550,7 +26876,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 777, port: port_); + funcId: 786, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Set_String, @@ -26577,7 +26903,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: 778)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 787)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_i_32_i_32, @@ -26605,7 +26931,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: 779)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 788)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_list_prim_u_8_strict, @@ -26633,7 +26959,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: 780)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 789)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_kitchen_sink_twin_sync, @@ -26661,7 +26987,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: 781)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 790)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_enum_simple_twin_sync, @@ -26689,7 +27015,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Map_String_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 782)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 791)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_String, @@ -26717,7 +27043,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: 783)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 792)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Map_String_my_size, @@ -26744,7 +27070,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 784)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 793)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Set_i_32, @@ -26771,7 +27097,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Set_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 785)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 794)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Set_String, @@ -26798,7 +27124,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 786, port: port_); + funcId: 795, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -26829,7 +27155,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_String(a, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 787, port: port_); + funcId: 796, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26861,7 +27187,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 788, port: port_); + funcId: 797, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -26891,7 +27217,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_u_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 789, port: port_); + funcId: 798, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26925,7 +27251,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: 790, port: port_); + funcId: 799, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26959,7 +27285,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { that, serializer); sse_encode_StreamSink_u_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 791, port: port_); + funcId: 800, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -26997,7 +27323,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: 792, port: port_); + funcId: 801, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27028,7 +27354,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(a, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 793, port: port_); + funcId: 802, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_concatenate_with_twin_rust_async, @@ -27058,7 +27384,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_concatenate_with_twin_rust_async( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 794, port: port_); + funcId: 803, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27090,7 +27416,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(b, serializer); sse_encode_u_32(c, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 795, port: port_); + funcId: 804, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_rust_async_array_3, @@ -27117,7 +27443,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 796, port: port_); + funcId: 805, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_rust_async, @@ -27147,7 +27473,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: 797, port: port_); + funcId: 806, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27176,7 +27502,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 798, port: port_); + funcId: 807, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_enum_twin_rust_async, @@ -27206,7 +27532,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: 799, port: port_); + funcId: 808, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27236,7 +27562,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: 800, port: port_); + funcId: 809, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -27268,7 +27594,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: 801, port: port_); + funcId: 810, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27297,7 +27623,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: 802, port: port_); + funcId: 811, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27327,7 +27653,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: 803, port: port_); + funcId: 812, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27357,7 +27683,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 804, port: port_); + funcId: 813, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_twin_rust_async, @@ -27387,7 +27713,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: 805, port: port_); + funcId: 814, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -27416,7 +27742,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(a, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 806, port: port_); + funcId: 815, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -27450,7 +27776,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(y, serializer); sse_encode_u_32(z, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 807, port: port_); + funcId: 816, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -27475,7 +27801,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: 817)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -27504,7 +27830,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: 809)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 818)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27534,7 +27860,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: 810)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 819)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27562,7 +27888,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: 811)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 820)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27595,7 +27921,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: 812)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 821)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27627,7 +27953,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: 813)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 822)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27663,7 +27989,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: 814)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 823)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -27693,7 +28019,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(a, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 815)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 824)!; }, codec: SseCodec( decodeSuccessData: sse_decode_concatenate_with_twin_sync, @@ -27721,7 +28047,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: 816)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 825)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27750,7 +28076,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: 817)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 826)!; }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_sync_array_3, @@ -27775,7 +28101,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: 827)!; }, codec: SseCodec( decodeSuccessData: sse_decode_sum_with_twin_sync, @@ -27803,7 +28129,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: 819)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 828)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27831,7 +28157,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 820)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 829)!; }, codec: SseCodec( decodeSuccessData: sse_decode_simple_enum_twin_sync, @@ -27859,7 +28185,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: 821)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 830)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27886,7 +28212,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: 822)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 831)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -27915,7 +28241,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: 823)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 832)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27943,7 +28269,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: 824)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 833)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27971,7 +28297,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: 825)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 834)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -27999,7 +28325,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(one, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 826)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 835)!; }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_twin_sync, @@ -28027,7 +28353,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: 827)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 836)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -28054,7 +28380,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(a, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 828)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 837)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -28083,7 +28409,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: 829)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 838)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -28112,7 +28438,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_settings_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 830, port: port_); + funcId: 839, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28142,7 +28468,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_settings_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 831, port: port_); + funcId: 840, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28171,7 +28497,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_numbers(nums, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 832, port: port_); + funcId: 841, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -28200,7 +28526,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_sequences(seqs, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 833, port: port_); + funcId: 842, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -28227,7 +28553,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 834, port: port_); + funcId: 843, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -28254,7 +28580,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 835, port: port_); + funcId: 844, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -28281,7 +28607,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 836, port: port_); + funcId: 845, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_application_message, @@ -28310,7 +28636,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_application_settings(appSettings, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 837, port: port_); + funcId: 846, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -28339,7 +28665,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: 838, port: port_); + funcId: 847, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28369,7 +28695,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 839, port: port_); + funcId: 848, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28399,7 +28725,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: 840, port: port_); + funcId: 849, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28430,7 +28756,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_opt_box_autoadd_application_mode_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 841, port: port_); + funcId: 850, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28460,7 +28786,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_Set_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 842, port: port_); + funcId: 851, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28491,7 +28817,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_mirror_struct_twin_rust_async_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 843, port: port_); + funcId: 852, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28522,7 +28848,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_record_application_settings_raw_string_enum_mirrored_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 844, port: port_); + funcId: 853, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28552,7 +28878,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_list_application_mode_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 845, port: port_); + funcId: 854, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28583,7 +28909,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(num, serializer); sse_encode_usize(times, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 846, port: port_); + funcId: 855, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_numbers, @@ -28613,7 +28939,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(seq, serializer); sse_encode_usize(times, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 847, port: port_); + funcId: 856, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_sequences, @@ -28640,7 +28966,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 848, port: port_); + funcId: 857, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -28668,7 +28994,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 849, port: port_); + funcId: 858, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_mirrored, @@ -28695,7 +29021,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 850, port: port_); + funcId: 859, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_hash_map, @@ -28722,7 +29048,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 851, port: port_); + funcId: 860, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_enum_mirrored, @@ -28749,7 +29075,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 852, port: port_); + funcId: 861, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_of_nested_raw_string_mirrored, @@ -28777,7 +29103,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 853, port: port_); + funcId: 862, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_nested_raw_string_mirrored, @@ -28806,7 +29132,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(nested, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 854, port: port_); + funcId: 863, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_enum_mirrored, @@ -28833,7 +29159,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 855, port: port_); + funcId: 864, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_mirrored, @@ -28861,7 +29187,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: 856)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 865)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28890,7 +29216,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: 857)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 866)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -28918,7 +29244,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_numbers(nums, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 858)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 867)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -28945,7 +29271,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_box_autoadd_sequences(seqs, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 859)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 868)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -28971,7 +29297,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 860)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 869)!; }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -28997,7 +29323,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 861)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 870)!; }, codec: SseCodec( decodeSuccessData: sse_decode_application_settings, @@ -29022,7 +29348,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 862)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 871)!; }, codec: SseCodec( decodeSuccessData: sse_decode_application_message, @@ -29048,7 +29374,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: 863)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 872)!; }, codec: SseCodec( decodeSuccessData: sse_decode_bool, @@ -29076,7 +29402,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: 864)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 873)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29105,7 +29431,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: 865)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 874)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29134,7 +29460,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: 866)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 875)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29164,7 +29490,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: 867)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 876)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29193,7 +29519,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: 868)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 877)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29222,7 +29548,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: 869)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 878)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29252,7 +29578,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: 870)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 879)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29281,7 +29607,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: 871)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 880)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -29310,7 +29636,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: 872)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 881)!; }, codec: SseCodec( decodeSuccessData: sse_decode_numbers, @@ -29338,7 +29664,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: 873)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 882)!; }, codec: SseCodec( decodeSuccessData: sse_decode_sequences, @@ -29364,7 +29690,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 874)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 883)!; }, codec: SseCodec( decodeSuccessData: sse_decode_contains_mirrored_sub_struct_twin_sync, @@ -29390,7 +29716,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 875)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 884)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_mirrored, @@ -29416,7 +29742,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 876)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 885)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_hash_map, @@ -29442,7 +29768,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 877)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 886)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_raw_string_enum_mirrored, @@ -29468,7 +29794,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 878)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 887)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_of_nested_raw_string_mirrored, @@ -29494,7 +29820,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 879)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 888)!; }, codec: SseCodec( decodeSuccessData: sse_decode_nested_raw_string_mirrored, @@ -29522,7 +29848,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_bool(nested, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 880)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 889)!; }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_enum_mirrored, @@ -29548,7 +29874,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 881)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 890)!; }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_mirrored, @@ -29575,7 +29901,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 882, port: port_); + funcId: 891, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_big_buffers_twin_rust_async, @@ -29604,7 +29930,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Char(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 883, port: port_); + funcId: 892, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Char, @@ -29633,7 +29959,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: 884, port: port_); + funcId: 893, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_tree_node_twin_rust_async, @@ -29662,7 +29988,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: 885, port: port_); + funcId: 894, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_nested_struct_twin_rust_async, @@ -29691,7 +30017,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(s, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 886, port: port_); + funcId: 895, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -29721,7 +30047,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: 887, port: port_); + funcId: 896, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_my_size, @@ -29750,7 +30076,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(v, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 888, port: port_); + funcId: 897, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -29779,7 +30105,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_weekdays_twin_rust_async(weekdays, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 889, port: port_); + funcId: 898, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_weekdays_twin_rust_async, @@ -29809,7 +30135,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(a, serializer); sse_encode_i_32(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 890, port: port_); + funcId: 899, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -29838,7 +30164,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: 891, port: port_); + funcId: 900, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_abc_twin_rust_async, @@ -29867,7 +30193,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: 892, port: port_); + funcId: 901, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_enum_twin_rust_async, @@ -29893,7 +30219,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 893)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 902)!; }, codec: SseCodec( decodeSuccessData: sse_decode_big_buffers_twin_sync, @@ -29920,7 +30246,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Char(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 894)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 903)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Char, @@ -29948,7 +30274,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: 895)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 904)!; }, codec: SseCodec( decodeSuccessData: sse_decode_my_tree_node_twin_sync, @@ -29976,7 +30302,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: 896)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 905)!; }, codec: SseCodec( decodeSuccessData: sse_decode_my_nested_struct_twin_sync, @@ -30003,7 +30329,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(s, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 897)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 906)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -30031,7 +30357,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: 898)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 907)!; }, codec: SseCodec( decodeSuccessData: sse_decode_my_size, @@ -30058,7 +30384,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: 899)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 908)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -30086,7 +30412,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: 900)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 909)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_weekdays_twin_sync, @@ -30114,7 +30440,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: 901)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 910)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -30141,7 +30467,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: 902)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 911)!; }, codec: SseCodec( decodeSuccessData: sse_decode_abc_twin_sync, @@ -30169,7 +30495,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: 903)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 912)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_enum_twin_sync, @@ -30198,7 +30524,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: 904, port: port_); + funcId: 913, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_empty_twin_rust_async, @@ -30225,7 +30551,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 905, port: port_); + funcId: 914, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30254,7 +30580,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_my_size(l, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 906, port: port_); + funcId: 915, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_my_size, @@ -30283,7 +30609,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(names, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 907, port: port_); + funcId: 916, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -30310,7 +30636,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: 908)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 917)!; }, codec: SseCodec( decodeSuccessData: sse_decode_empty_twin_sync, @@ -30335,7 +30661,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 909)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 918)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -30362,7 +30688,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_my_size(l, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 910)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 919)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_my_size, @@ -30389,7 +30715,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(names, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 911)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 920)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -30418,7 +30744,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: 912, port: port_); + funcId: 921, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_new_type_int_twin_rust_async, @@ -30446,7 +30772,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: 913)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 922)!; }, codec: SseCodec( decodeSuccessData: sse_decode_new_type_int_twin_sync, @@ -30478,7 +30804,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: 914, port: port_); + funcId: 923, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -30509,7 +30835,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: 915)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 924)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_i_32, @@ -30538,7 +30864,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_box_f_64(opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 916, port: port_); + funcId: 925, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -30580,7 +30906,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_exotic_optionals_twin_rust_async( structbox, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 917, port: port_); + funcId: 926, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -30618,7 +30944,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_exotic_optionals_twin_rust_async( opt, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 918, port: port_); + funcId: 927, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -30649,7 +30975,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(left, serializer); sse_encode_f_64(right, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 919, port: port_); + funcId: 928, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -30678,7 +31004,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(document, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 920, port: port_); + funcId: 929, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_element_twin_rust_async, @@ -30707,7 +31033,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: 921, port: port_); + funcId: 930, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opt_vecs_twin_rust_async, @@ -30735,7 +31061,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: 922)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 931)!; }, codec: SseCodec( decodeSuccessData: sse_decode_f_64, @@ -30774,7 +31100,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: 923)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 932)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -30810,7 +31136,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: 924)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 933)!; }, codec: SseCodec( decodeSuccessData: @@ -30839,7 +31165,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: 925)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 934)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_f_64, @@ -30867,7 +31193,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_opt_String(document, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 926)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 935)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_box_autoadd_element_twin_sync, @@ -30894,7 +31220,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: 927)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 936)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opt_vecs_twin_sync, @@ -30922,7 +31248,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 928, port: port_); + funcId: 937, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -30951,7 +31277,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 929, port: port_); + funcId: 938, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -30980,7 +31306,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_prim_u_8_loose(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 930, port: port_); + funcId: 939, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -31009,7 +31335,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 931, port: port_); + funcId: 940, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -31038,7 +31364,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 932, port: port_); + funcId: 941, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -31068,7 +31394,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_simple_struct_for_borrow_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 933, port: port_); + funcId: 942, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_for_borrow_twin_rust_async, @@ -31095,7 +31421,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 934)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 943)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -31122,7 +31448,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 935)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 944)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_String, @@ -31149,7 +31475,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: 936)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 945)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_prim_u_8_strict, @@ -31176,7 +31502,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 937)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 946)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -31203,7 +31529,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_String(arg, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 938)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 947)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -31232,7 +31558,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: 939)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 948)!; }, codec: SseCodec( decodeSuccessData: sse_decode_simple_struct_for_borrow_twin_sync, @@ -31261,7 +31587,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(n, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 940, port: port_); + funcId: 949, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_vec_of_primitive_pack_twin_rust_async, @@ -31289,7 +31615,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(n, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 941)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 950)!; }, codec: SseCodec( decodeSuccessData: sse_decode_vec_of_primitive_pack_twin_sync, @@ -31324,7 +31650,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_f_64(myF64, serializer); sse_encode_bool(myBool, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 942, port: port_); + funcId: 951, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -31353,7 +31679,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(myU32, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 943, port: port_); + funcId: 952, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -31386,7 +31712,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: 944)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 953)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -31413,7 +31739,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_32(myU32, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 945)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 954)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_32, @@ -31440,7 +31766,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 946, port: port_); + funcId: 955, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31469,7 +31795,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 947, port: port_); + funcId: 956, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_item_struct_twin_rust_async, @@ -31495,7 +31821,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 948)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 957)!; }, codec: SseCodec( decodeSuccessData: @@ -31522,7 +31848,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 949)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 958)!; }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_item_struct_twin_sync, @@ -31552,7 +31878,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 950, port: port_); + funcId: 959, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31583,7 +31909,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 951, port: port_); + funcId: 960, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31614,7 +31940,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 952, port: port_); + funcId: 961, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31645,7 +31971,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 953, port: port_); + funcId: 962, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -31676,7 +32002,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 954, port: port_); + funcId: 963, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31705,7 +32031,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 955, port: port_); + funcId: 964, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31734,7 +32060,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 956, port: port_); + funcId: 965, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31762,7 +32088,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 957, port: port_); + funcId: 966, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31794,7 +32120,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 958, port: port_); + funcId: 967, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31825,7 +32151,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 959, port: port_); + funcId: 968, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31856,7 +32182,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 960, port: port_); + funcId: 969, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31884,7 +32210,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 961, port: port_); + funcId: 970, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -31916,7 +32242,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithGoodAndOpaqueFieldWithoutOptionTwinRustAsync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 962)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 971)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -31948,7 +32274,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithGoodAndOpaqueFieldWithoutOptionTwinRustAsync( that, serializer); sse_encode_String(good, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 963)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 972)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -31980,7 +32306,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 965, port: port_); + funcId: 974, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32014,7 +32340,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(expect, serializer); sse_encode_i_32(adder, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 966, port: port_); + funcId: 975, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32044,7 +32370,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 967, port: port_); + funcId: 976, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32077,7 +32403,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 968, port: port_); + funcId: 977, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32109,7 +32435,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_list_prim_i_32_loose(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 969, port: port_); + funcId: 978, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32142,7 +32468,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 970, port: port_); + funcId: 979, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -32175,7 +32501,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( mutBorrow, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 971, port: port_); + funcId: 980, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -32205,7 +32531,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynFnStringStringSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 972, port: port_); + funcId: 981, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32232,7 +32558,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 973, port: port_); + funcId: 982, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32266,7 +32592,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerEnumWithGoodAndOpaqueWithoutOptionTwinRustAsync( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 974, port: port_); + funcId: 983, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32296,7 +32622,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleEnumTwinRustAsync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 975, port: port_); + funcId: 984, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32323,7 +32649,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 976, port: port_); + funcId: 985, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32354,7 +32680,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: 977, port: port_); + funcId: 986, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32382,7 +32708,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 978, port: port_); + funcId: 987, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_rust_async, @@ -32410,7 +32736,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 979, port: port_); + funcId: 988, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_rust_async, @@ -32442,7 +32768,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 980, port: port_); + funcId: 989, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32469,7 +32795,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 981, port: port_); + funcId: 990, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32500,7 +32826,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 982, port: port_); + funcId: 991, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32531,7 +32857,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: 983, port: port_); + funcId: 992, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32562,7 +32888,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 984, port: port_); + funcId: 993, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32592,7 +32918,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynMyTraitTwinRustAsyncSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 985, port: port_); + funcId: 994, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32619,7 +32945,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 986, port: port_); + funcId: 995, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32647,7 +32973,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 987, port: port_); + funcId: 996, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32676,7 +33002,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 988, port: port_); + funcId: 997, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32706,7 +33032,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 989, port: port_); + funcId: 998, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32734,7 +33060,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 990, port: port_); + funcId: 999, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32768,7 +33094,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( orange, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 991, port: port_); + funcId: 1000, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -32798,7 +33124,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 992, port: port_); + funcId: 1001, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32829,7 +33155,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: 993, port: port_); + funcId: 1002, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32857,7 +33183,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 994, port: port_); + funcId: 1003, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -32892,7 +33218,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinRustAsync( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 995, port: port_); + funcId: 1004, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32921,7 +33247,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: 996)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1005)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32951,7 +33277,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: 997)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1006)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -32981,7 +33307,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: 998)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1007)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33010,7 +33336,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: 999)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1008)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -33040,7 +33366,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: 1000)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1009)!; }, codec: SseCodec( decodeSuccessData: @@ -33068,7 +33394,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1001)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1010)!; }, codec: SseCodec( decodeSuccessData: @@ -33095,7 +33421,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1002)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1011)!; }, codec: SseCodec( decodeSuccessData: @@ -33122,7 +33448,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1003)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1012)!; }, codec: SseCodec( decodeSuccessData: @@ -33152,7 +33478,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: 1004)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1013)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33182,7 +33508,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: 1005)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1014)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33212,7 +33538,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: 1006)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1015)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33238,7 +33564,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1007)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1016)!; }, codec: SseCodec( decodeSuccessData: @@ -33269,7 +33595,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithGoodAndOpaqueFieldWithoutOptionTwinSync( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1008)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1017)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -33301,7 +33627,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithGoodAndOpaqueFieldWithoutOptionTwinSync( that, serializer); sse_encode_String(good, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1009)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1018)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33332,7 +33658,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: 1011)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1020)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33365,7 +33691,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: 1012)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1021)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33394,7 +33720,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: 1013)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1022)!; }, codec: SseCodec( decodeSuccessData: @@ -33424,7 +33750,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: 1014)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1023)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33455,7 +33781,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: 1015)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1024)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33485,7 +33811,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: 1016)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1025)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -33516,7 +33842,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: 1017)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1026)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -33545,7 +33871,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: 1018)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1027)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33571,7 +33897,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1019)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1028)!; }, codec: SseCodec( decodeSuccessData: @@ -33603,7 +33929,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: 1020)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1029)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33632,7 +33958,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: 1021)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1030)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33658,7 +33984,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1022)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1031)!; }, codec: SseCodec( decodeSuccessData: @@ -33688,7 +34014,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: 1023)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1032)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33715,7 +34041,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1024)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1033)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_sync, @@ -33742,7 +34068,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1025)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1034)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_sync, @@ -33773,7 +34099,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_AutoExplicit_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinSync( arg, serializer); sse_encode_i_32(expect, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1026)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1035)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33799,7 +34125,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1027)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1036)!; }, codec: SseCodec( decodeSuccessData: @@ -33828,7 +34154,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1028)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1037)!; }, codec: SseCodec( decodeSuccessData: @@ -33858,7 +34184,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: 1029)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1038)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33888,7 +34214,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: 1030)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1039)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33917,7 +34243,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: 1031)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1040)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -33943,7 +34269,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1032)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1041)!; }, codec: SseCodec( decodeSuccessData: @@ -33972,7 +34298,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1033)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1042)!; }, codec: SseCodec( decodeSuccessData: @@ -33999,7 +34325,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1034)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1043)!; }, codec: SseCodec( decodeSuccessData: @@ -34028,7 +34354,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1035)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1044)!; }, codec: SseCodec( decodeSuccessData: @@ -34055,7 +34381,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1036)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1045)!; }, codec: SseCodec( decodeSuccessData: @@ -34087,7 +34413,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: 1037)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1046)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -34116,7 +34442,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: 1038)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1047)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34146,7 +34472,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: 1039)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1048)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34173,7 +34499,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1040)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1049)!; }, codec: SseCodec( decodeSuccessData: @@ -34205,7 +34531,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: 1041)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1050)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34232,7 +34558,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1042, port: port_); + funcId: 1051, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_opaque_twin_rust_async_array_5, @@ -34259,7 +34585,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1043, port: port_); + funcId: 1052, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opaque_nested_twin_rust_async, @@ -34286,7 +34612,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1044, port: port_); + funcId: 1053, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinRustAsync, @@ -34316,7 +34642,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_RustOpaque_HideDataTwinRustAsync( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1045, port: port_); + funcId: 1054, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -34344,7 +34670,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1046, port: port_); + funcId: 1055, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueReturnTwinRustAsync, @@ -34373,7 +34699,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync_array_2(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1047, port: port_); + funcId: 1056, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34400,7 +34726,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1048, port: port_); + funcId: 1057, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinRustAsync_array_2, @@ -34429,7 +34755,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_RustOpaque_HideDataTwinRustAsync(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1049, port: port_); + funcId: 1058, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34456,7 +34782,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1050, port: port_); + funcId: 1059, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_RustOpaque_HideDataTwinRustAsync, @@ -34485,7 +34811,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: 1051, port: port_); + funcId: 1060, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -34515,7 +34841,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_opaque_nested_twin_rust_async( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1052, port: port_); + funcId: 1061, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34544,7 +34870,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_NonCloneDataTwinRustAsync(clone, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1053, port: port_); + funcId: 1062, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -34573,7 +34899,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1054, port: port_); + funcId: 1063, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -34602,7 +34928,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1055, port: port_); + funcId: 1064, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -34631,7 +34957,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinRustAsync(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1056, port: port_); + funcId: 1065, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -34657,7 +34983,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1057)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1066)!; }, codec: SseCodec( decodeSuccessData: sse_decode_enum_opaque_twin_sync_array_5, @@ -34683,7 +35009,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1058)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1067)!; }, codec: SseCodec( decodeSuccessData: sse_decode_opaque_nested_twin_sync, @@ -34709,7 +35035,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1059)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1068)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinSync, @@ -34738,7 +35064,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: 1060)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1069)!; }, codec: SseCodec( decodeSuccessData: @@ -34765,7 +35091,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1061)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1070)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueReturnTwinSync, @@ -34792,7 +35118,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: 1062)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1071)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34818,7 +35144,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1063)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1072)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinSync_array_2, @@ -34845,7 +35171,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_RustOpaque_HideDataTwinSync(data, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1064)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1073)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34871,7 +35197,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1065)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1074)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_RustOpaque_HideDataTwinSync, @@ -34898,7 +35224,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: 1066)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1075)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -34925,7 +35251,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: 1067)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1076)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -34952,7 +35278,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_NonCloneDataTwinSync(clone, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1068)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1077)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -34979,7 +35305,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinSync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1069)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1078)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -35006,7 +35332,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinSync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1070)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1079)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -35033,7 +35359,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinSync(opaque, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1071)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1080)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -35062,7 +35388,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(a, serializer); sse_encode_i_32(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1072, port: port_); + funcId: 1081, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -35090,7 +35416,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: 1073)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1082)!; }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -35119,7 +35445,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_i_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1074, port: port_); + funcId: 1083, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35149,7 +35475,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1075, port: port_); + funcId: 1084, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35179,7 +35505,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1076, port: port_); + funcId: 1085, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35212,7 +35538,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: 1077, port: port_); + funcId: 1086, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35243,7 +35569,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_my_stream_entry_twin_rust_async_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1078, port: port_); + funcId: 1087, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35276,7 +35602,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: 1079, port: port_); + funcId: 1088, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35309,7 +35635,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: 1080, port: port_); + funcId: 1089, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35342,7 +35668,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(key, serializer); sse_encode_u_32(max, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1081, port: port_); + funcId: 1090, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35372,7 +35698,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: 1082, port: port_); + funcId: 1091, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35404,7 +35730,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: 1083, port: port_); + funcId: 1092, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35433,7 +35759,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_StreamSink_i_32_Sse(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1084, port: port_); + funcId: 1093, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35453,6 +35779,68 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["arg"], ); + @override + Future + crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithDartKeywordFieldTwinRustAsync( + {required StructWithDartKeywordFieldTwinRustAsync arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 1094, port: port_); + }, + codec: SseCodec( + decodeSuccessData: + sse_decode_struct_with_dart_keyword_field_twin_rust_async, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinRustAsyncFuncForStructWithDartKeywordFieldTwinRustAsyncConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinRustAsyncFuncForStructWithDartKeywordFieldTwinRustAsyncConstMeta => + const TaskConstMeta( + debugName: + "func_for_struct_with_dart_keyword_field_twin_rust_async", + argNames: ["arg"], + ); + + @override + Future + crateApiPseudoManualStructureTwinRustAsyncFuncForStructWithFieldRenameTwinRustAsync( + {required StructWithFieldRenameTwinRustAsync arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_field_rename_twin_rust_async( + arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 1095, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_struct_with_field_rename_twin_rust_async, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinRustAsyncFuncForStructWithFieldRenameTwinRustAsyncConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinRustAsyncFuncForStructWithFieldRenameTwinRustAsyncConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_field_rename_twin_rust_async", + argNames: ["arg"], + ); + @override Future crateApiPseudoManualStructureTwinRustAsyncFuncStructWithOneFieldTwinRustAsync( @@ -35463,7 +35851,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_one_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1085, port: port_); + funcId: 1096, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_one_field_twin_rust_async, @@ -35493,7 +35881,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_two_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1086, port: port_); + funcId: 1097, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_two_field_twin_rust_async, @@ -35523,7 +35911,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_zero_field_twin_rust_async( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1087, port: port_); + funcId: 1098, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_zero_field_twin_rust_async, @@ -35553,7 +35941,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: 1088, port: port_); + funcId: 1099, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35584,7 +35972,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: 1089, port: port_); + funcId: 1100, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -35605,6 +35993,64 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["arg"], ); + @override + StructWithDartKeywordFieldTwinSync + crateApiPseudoManualStructureTwinSyncFuncForStructWithDartKeywordFieldTwinSync( + {required StructWithDartKeywordFieldTwinSync arg}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + arg, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1101)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_struct_with_dart_keyword_field_twin_sync, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinSyncFuncForStructWithDartKeywordFieldTwinSyncConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinSyncFuncForStructWithDartKeywordFieldTwinSyncConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_dart_keyword_field_twin_sync", + argNames: ["arg"], + ); + + @override + StructWithFieldRenameTwinSync + crateApiPseudoManualStructureTwinSyncFuncForStructWithFieldRenameTwinSync( + {required StructWithFieldRenameTwinSync arg}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_field_rename_twin_sync( + arg, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1102)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_struct_with_field_rename_twin_sync, + decodeErrorData: null, + ), + constMeta: + kCrateApiPseudoManualStructureTwinSyncFuncForStructWithFieldRenameTwinSyncConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiPseudoManualStructureTwinSyncFuncForStructWithFieldRenameTwinSyncConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_field_rename_twin_sync", + argNames: ["arg"], + ); + @override StructWithOneFieldTwinSync crateApiPseudoManualStructureTwinSyncFuncStructWithOneFieldTwinSync( @@ -35613,7 +36059,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: 1090)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1103)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_one_field_twin_sync, @@ -35641,7 +36087,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: 1091)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1104)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_two_field_twin_sync, @@ -35670,7 +36116,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: 1092)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1105)!; }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_zero_field_twin_sync, @@ -35699,7 +36145,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: 1093)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1106)!; }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_one_field_twin_sync, @@ -35728,7 +36174,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: 1094)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1107)!; }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_two_field_twin_sync, @@ -35756,7 +36202,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_record_string_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1095, port: port_); + funcId: 1108, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35785,7 +36231,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: 1096, port: port_); + funcId: 1109, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_record_string_i_32, @@ -35812,7 +36258,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: 1097)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1110)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -35838,7 +36284,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: 1098)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1111)!; }, codec: SseCodec( decodeSuccessData: sse_decode_record_string_i_32, @@ -35866,7 +36312,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1099, port: port_); + funcId: 1112, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -35895,7 +36341,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1100, port: port_); + funcId: 1113, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_model_twin_rust_async, @@ -35924,7 +36370,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1101, port: port_); + funcId: 1114, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -35951,7 +36397,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1102)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1115)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -35979,7 +36425,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1103)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1116)!; }, codec: SseCodec( decodeSuccessData: sse_decode_test_model_twin_sync, @@ -36006,7 +36452,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1104)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1117)!; }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -36035,7 +36481,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: 1105, port: port_); + funcId: 1118, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_feature_uuid_twin_rust_async, @@ -36064,7 +36510,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Uuid(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1106, port: port_); + funcId: 1119, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Uuid, @@ -36093,7 +36539,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Uuid(ids, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1107, port: port_); + funcId: 1120, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Uuid, @@ -36121,7 +36567,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: 1108)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1121)!; }, codec: SseCodec( decodeSuccessData: sse_decode_feature_uuid_twin_sync, @@ -36148,7 +36594,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Uuid(id, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1109)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1122)!; }, codec: SseCodec( decodeSuccessData: sse_decode_Uuid, @@ -36175,7 +36621,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Uuid(ids, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1110)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1123)!; }, codec: SseCodec( decodeSuccessData: sse_decode_list_Uuid, @@ -36202,7 +36648,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1111, port: port_); + funcId: 1124, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36230,7 +36676,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1112, port: port_); + funcId: 1125, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_raw_string_item_struct_twin_normal, @@ -36259,7 +36705,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1113, port: port_); + funcId: 1126, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36290,7 +36736,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1114, port: port_); + funcId: 1127, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36321,7 +36767,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1115, port: port_); + funcId: 1128, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36352,7 +36798,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1116, port: port_); + funcId: 1129, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -36383,7 +36829,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( that, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1117, port: port_); + funcId: 1130, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36412,7 +36858,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1118, port: port_); + funcId: 1131, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36440,7 +36886,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1119, port: port_); + funcId: 1132, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36468,7 +36914,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1120, port: port_); + funcId: 1133, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36499,7 +36945,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1121, port: port_); + funcId: 1134, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36530,7 +36976,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1122, port: port_); + funcId: 1135, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36561,7 +37007,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1123, port: port_); + funcId: 1136, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36589,7 +37035,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1124, port: port_); + funcId: 1137, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36620,7 +37066,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithGoodAndOpaqueFieldWithoutOptionTwinNormal( that, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1125)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1138)!; }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -36652,7 +37098,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructWithGoodAndOpaqueFieldWithoutOptionTwinNormal( that, serializer); sse_encode_String(good, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1126)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1139)!; }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36683,7 +37129,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1128, port: port_); + funcId: 1141, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36716,7 +37162,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(expect, serializer); sse_encode_i_32(adder, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1129, port: port_); + funcId: 1142, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36746,7 +37192,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1130, port: port_); + funcId: 1143, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36777,7 +37223,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1131, port: port_); + funcId: 1144, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36807,7 +37253,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_list_prim_i_32_loose(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1132, port: port_); + funcId: 1145, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36839,7 +37285,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1133, port: port_); + funcId: 1146, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -36871,7 +37317,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( mutBorrow, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1134, port: port_); + funcId: 1147, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -36900,7 +37346,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynFnStringStringSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1135, port: port_); + funcId: 1148, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36927,7 +37373,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1136, port: port_); + funcId: 1149, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -36960,7 +37406,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerEnumWithGoodAndOpaqueWithoutOptionTwinNormal( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1137, port: port_); + funcId: 1150, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -36988,7 +37434,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleEnumTwinNormal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1138, port: port_); + funcId: 1151, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37015,7 +37461,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1139, port: port_); + funcId: 1152, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -37046,7 +37492,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_enum_with_good_and_opaque_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1140, port: port_); + funcId: 1153, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37074,7 +37520,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1141, port: port_); + funcId: 1154, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_normal, @@ -37102,7 +37548,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1142, port: port_); + funcId: 1155, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_with_good_and_opaque_twin_normal, @@ -37133,7 +37579,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { arg, serializer); sse_encode_i_32(expect, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1143, port: port_); + funcId: 1156, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37160,7 +37606,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1144, port: port_); + funcId: 1157, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -37190,7 +37636,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1145, port: port_); + funcId: 1158, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -37220,7 +37666,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: 1146, port: port_); + funcId: 1159, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37250,7 +37696,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { a, serializer); sse_encode_String(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1147, port: port_); + funcId: 1160, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37279,7 +37725,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBoxdynMyTraitTwinNormalSendSync( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1148, port: port_); + funcId: 1161, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37306,7 +37752,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1149, port: port_); + funcId: 1162, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -37334,7 +37780,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1150, port: port_); + funcId: 1163, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -37362,7 +37808,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1151, port: port_); + funcId: 1164, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -37392,7 +37838,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_i_32(initial, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1152, port: port_); + funcId: 1165, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -37420,7 +37866,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1153, port: port_); + funcId: 1166, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -37453,7 +37899,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( orange, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1154, port: port_); + funcId: 1167, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -37482,7 +37928,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal_Sse( sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1155, port: port_); + funcId: 1168, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37513,7 +37959,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: 1156, port: port_); + funcId: 1169, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37541,7 +37987,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1157, port: port_); + funcId: 1170, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -37575,7 +38021,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerNonCloneSimpleTwinNormal( b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1158, port: port_); + funcId: 1171, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37602,7 +38048,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1159, port: port_); + funcId: 1172, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_enum_opaque_twin_normal_array_5, @@ -37628,7 +38074,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1160, port: port_); + funcId: 1173, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_opaque_nested_twin_normal, @@ -37652,7 +38098,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1161, port: port_); + funcId: 1174, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinNormal, @@ -37679,7 +38125,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_opt_box_autoadd_RustOpaque_HideDataTwinNormal( opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1162, port: port_); + funcId: 1175, port: port_); }, codec: SseCodec( decodeSuccessData: @@ -37705,7 +38151,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1163, port: port_); + funcId: 1176, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueReturnTwinNormal, @@ -37731,7 +38177,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal_array_2(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1164, port: port_); + funcId: 1177, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37755,7 +38201,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1165, port: port_); + funcId: 1178, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataTwinNormal_array_2, @@ -37781,7 +38227,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_RustOpaque_HideDataTwinNormal(data, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1166, port: port_); + funcId: 1179, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37805,7 +38251,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { callFfi: (port_) { final serializer = SseSerializer(generalizedFrbRustBinding); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1167, port: port_); + funcId: 1180, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_RustOpaque_HideDataTwinNormal, @@ -37831,7 +38277,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: 1168, port: port_); + funcId: 1181, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -37857,7 +38303,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: 1169, port: port_); + funcId: 1182, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -37883,7 +38329,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_NonCloneDataTwinNormal(clone, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1170, port: port_); + funcId: 1183, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -37909,7 +38355,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1171, port: port_); + funcId: 1184, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -37935,7 +38381,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1172, port: port_); + funcId: 1185, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -37961,7 +38407,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_RustOpaque_HideDataTwinNormal(opaque, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1173, port: port_); + funcId: 1186, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_String, @@ -37985,7 +38431,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1174)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1187)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_FrbOpaqueSyncReturnTwinNormal, @@ -38009,7 +38455,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1175)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1188)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_NonCloneDataTwinNormal, @@ -38033,7 +38479,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1176)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1189)!; }, codec: SseCodec( decodeSuccessData: sse_decode_RustOpaque_HideDataAnotherTwinNormal, @@ -38058,7 +38504,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync(SyncTask( callFfi: () { final serializer = SseSerializer(generalizedFrbRustBinding); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1177)!; + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 1190)!; }, codec: SseCodec( decodeSuccessData: @@ -38087,7 +38533,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(a, serializer); sse_encode_i_32(b, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1178, port: port_); + funcId: 1191, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_i_32, @@ -38113,7 +38559,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_i_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1179, port: port_); + funcId: 1192, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38141,7 +38587,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1180, port: port_); + funcId: 1193, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38168,7 +38614,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_String_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1181, port: port_); + funcId: 1194, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38198,7 +38644,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: 1182, port: port_); + funcId: 1195, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38227,7 +38673,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: 1183, port: port_); + funcId: 1196, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38257,7 +38703,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: 1184, port: port_); + funcId: 1197, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38287,7 +38733,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: 1185, port: port_); + funcId: 1198, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38317,7 +38763,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_u_32(key, serializer); sse_encode_u_32(max, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1186, port: port_); + funcId: 1199, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38345,7 +38791,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: 1187, port: port_); + funcId: 1200, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38375,7 +38821,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_my_struct_containing_stream_sink_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1188, port: port_); + funcId: 1201, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38401,7 +38847,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_StreamSink_i_32_Sse(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1189, port: port_); + funcId: 1202, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38429,7 +38875,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_StreamSink_String_Sse(sink, serializer); sse_encode_String(arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1190, port: port_); + funcId: 1203, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38456,7 +38902,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_StreamSink_i_32_Sse(sink, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1191, port: port_); + funcId: 1204, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38475,6 +38921,67 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { argNames: ["sink"], ); + @override + Future + crateApiStructureFuncForStructWithDartKeywordFieldTwinNormal( + {required StructWithDartKeywordFieldTwinNormal arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 1205, port: port_); + }, + codec: SseCodec( + decodeSuccessData: + sse_decode_struct_with_dart_keyword_field_twin_normal, + decodeErrorData: null, + ), + constMeta: + kCrateApiStructureFuncForStructWithDartKeywordFieldTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiStructureFuncForStructWithDartKeywordFieldTwinNormalConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_dart_keyword_field_twin_normal", + argNames: ["arg"], + ); + + @override + Future + crateApiStructureFuncForStructWithFieldRenameTwinNormal( + {required StructWithFieldRenameTwinNormal arg}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_struct_with_field_rename_twin_normal( + arg, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 1206, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_struct_with_field_rename_twin_normal, + decodeErrorData: null, + ), + constMeta: + kCrateApiStructureFuncForStructWithFieldRenameTwinNormalConstMeta, + argValues: [arg], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiStructureFuncForStructWithFieldRenameTwinNormalConstMeta => + const TaskConstMeta( + debugName: "func_for_struct_with_field_rename_twin_normal", + argNames: ["arg"], + ); + @override Future crateApiStructureFuncStructWithOneFieldTwinNormal( @@ -38485,7 +38992,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_one_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1192, port: port_); + funcId: 1207, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_one_field_twin_normal, @@ -38514,7 +39021,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_two_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1193, port: port_); + funcId: 1208, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_two_field_twin_normal, @@ -38543,7 +39050,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_struct_with_zero_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1194, port: port_); + funcId: 1209, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_struct_with_zero_field_twin_normal, @@ -38572,7 +39079,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_tuple_struct_with_one_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1195, port: port_); + funcId: 1210, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_one_field_twin_normal, @@ -38602,7 +39109,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_box_autoadd_tuple_struct_with_two_field_twin_normal( arg, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1196, port: port_); + funcId: 1211, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_tuple_struct_with_two_field_twin_normal, @@ -38630,7 +39137,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_record_string_i_32(value, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1197, port: port_); + funcId: 1212, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_unit, @@ -38656,7 +39163,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: 1198, port: port_); + funcId: 1213, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_record_string_i_32, @@ -38682,7 +39189,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1199, port: port_); + funcId: 1214, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -38708,7 +39215,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1200, port: port_); + funcId: 1215, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_test_model_twin_normal, @@ -38734,7 +39241,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_u_64(input, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1201, port: port_); + funcId: 1216, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_u_64, @@ -38761,7 +39268,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: 1202, port: port_); + funcId: 1217, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_feature_uuid_twin_normal, @@ -38787,7 +39294,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_Uuid(id, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1203, port: port_); + funcId: 1218, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_Uuid, @@ -38813,7 +39320,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { final serializer = SseSerializer(generalizedFrbRustBinding); sse_encode_list_Uuid(ids, serializer); pdeCallFfi(generalizedFrbRustBinding, serializer, - funcId: 1204, port: port_); + funcId: 1219, port: port_); }, codec: SseCodec( decodeSuccessData: sse_decode_list_Uuid, @@ -39587,6 +40094,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { get rust_arc_decrement_strong_count_OpaqueTwoTwinSync => wire .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync; + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_SimpleOpaqueExternalStructWithMethod => + wire.rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethod => + wire.rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod; + RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_StaticGetterOnlyTwinNormal => wire .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal; @@ -40058,6 +40573,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return OpaqueTwoTwinSyncImpl.frbInternalDcoDecode(raw as List); } + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalDcoDecode( + raw as List); + } + @protected StaticGetterOnlyTwinNormal dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -40521,6 +41045,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { raw as List); } + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalDcoDecode( + raw as List); + } + @protected StructInMiscNoTwinExampleA dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -40644,6 +41177,34 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return raw as String; } + @protected + int dco_decode_CastedPrimitive_i_64(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError( + 'Not implemented in this codec, please use the other one'); + } + + @protected + int dco_decode_CastedPrimitive_isize(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError( + 'Not implemented in this codec, please use the other one'); + } + + @protected + int dco_decode_CastedPrimitive_u_64(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError( + 'Not implemented in this codec, please use the other one'); + } + + @protected + int dco_decode_CastedPrimitive_usize(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError( + 'Not implemented in this codec, please use the other one'); + } + @protected String dco_decode_Char(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs @@ -40674,6 +41235,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return dcoDecodeTimestamp(ts: dco_decode_i_64(raw).toInt(), isUtc: true); } + @protected + int dco_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError( + 'Not implemented in this codec, please use the other one'); + } + @protected FutureOr Function(Object) dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( @@ -41542,6 +42111,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return OpaqueTwoTwinSyncImpl.frbInternalDcoDecode(raw as List); } + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalDcoDecode( + raw as List); + } + @protected StaticGetterOnlyTwinNormal dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -43714,6 +44292,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return dco_decode_struct_in_lower_level(raw); } + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_casted_primitive_twin_normal(raw); + } + @protected StructWithCommentsTwinNormal dco_decode_box_autoadd_struct_with_comments_twin_normal(dynamic raw) { @@ -43743,6 +44329,30 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return dco_decode_struct_with_custom_name_method_twin_normal(raw); } + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_dart_keyword_field_twin_normal(raw); + } + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_dart_keyword_field_twin_rust_async(raw); + } + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_dart_keyword_field_twin_sync(raw); + } + @protected StructWithEnumTwinNormal dco_decode_box_autoadd_struct_with_enum_twin_normal( dynamic raw) { @@ -43789,6 +44399,28 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return dco_decode_struct_with_explicit_auto_opaque_field_twin_sync(raw); } + @protected + StructWithFieldRenameTwinNormal + dco_decode_box_autoadd_struct_with_field_rename_twin_normal(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_field_rename_twin_normal(raw); + } + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_field_rename_twin_rust_async(raw); + } + + @protected + StructWithFieldRenameTwinSync + dco_decode_box_autoadd_struct_with_field_rename_twin_sync(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_struct_with_field_rename_twin_sync(raw); + } + @protected StructWithGoodAndOpaqueFieldTwinNormal dco_decode_box_autoadd_struct_with_good_and_opaque_field_twin_normal( @@ -47052,7 +47684,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return MoreThanJustOneRawStringStructTwinNormal( regular: dco_decode_String(arr[0]), type: dco_decode_String(arr[1]), - async: dco_decode_bool(arr[2]), + async_: dco_decode_bool(arr[2]), another: dco_decode_String(arr[3]), ); } @@ -47068,7 +47700,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return MoreThanJustOneRawStringStructTwinRustAsync( regular: dco_decode_String(arr[0]), type: dco_decode_String(arr[1]), - async: dco_decode_bool(arr[2]), + async_: dco_decode_bool(arr[2]), another: dco_decode_String(arr[3]), ); } @@ -47083,7 +47715,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return MoreThanJustOneRawStringStructTwinSync( regular: dco_decode_String(arr[0]), type: dco_decode_String(arr[1]), - async: dco_decode_bool(arr[2]), + async_: dco_decode_bool(arr[2]), another: dco_decode_String(arr[3]), ); } @@ -49116,6 +49748,21 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); } + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_struct_with_casted_primitive_twin_normal(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 4) + throw Exception('unexpected arr length: expect 4 but see ${arr.length}'); + return StructWithCastedPrimitiveTwinNormal( + fieldI64: dco_decode_CastedPrimitive_i_64(arr[0]), + fieldU64: dco_decode_CastedPrimitive_u_64(arr[1]), + fieldI32: dco_decode_i_32(arr[2]), + fieldVecU8: dco_decode_list_prim_u_8_strict(arr[3]), + ); + } + @protected StructWithCommentsTwinNormal dco_decode_struct_with_comments_twin_normal( dynamic raw) { @@ -49164,6 +49811,45 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); } + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_struct_with_dart_keyword_field_twin_normal(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return StructWithDartKeywordFieldTwinNormal( + class_: dco_decode_i_32(arr[0]), + interface_: dco_decode_i_64(arr[1]), + ); + } + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_struct_with_dart_keyword_field_twin_rust_async(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return StructWithDartKeywordFieldTwinRustAsync( + class_: dco_decode_i_32(arr[0]), + interface_: dco_decode_i_64(arr[1]), + ); + } + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_struct_with_dart_keyword_field_twin_sync(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return StructWithDartKeywordFieldTwinSync( + class_: dco_decode_i_32(arr[0]), + interface_: dco_decode_i_64(arr[1]), + ); + } + @protected StructWithEnumTwinNormal dco_decode_struct_with_enum_twin_normal( dynamic raw) { @@ -49249,6 +49935,42 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); } + @protected + StructWithFieldRenameTwinNormal + dco_decode_struct_with_field_rename_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 StructWithFieldRenameTwinNormal( + renamed_field: dco_decode_i_32(arr[0]), + ); + } + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_struct_with_field_rename_twin_rust_async(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 StructWithFieldRenameTwinRustAsync( + renamed_field: dco_decode_i_32(arr[0]), + ); + } + + @protected + StructWithFieldRenameTwinSync dco_decode_struct_with_field_rename_twin_sync( + 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 StructWithFieldRenameTwinSync( + renamed_field: dco_decode_i_32(arr[0]), + ); + } + @protected StructWithGoodAndOpaqueFieldTwinNormal dco_decode_struct_with_good_and_opaque_field_twin_normal(dynamic raw) { @@ -50292,6 +51014,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); } + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + @protected StaticGetterOnlyTwinNormal sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -50766,6 +51497,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); } + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + @protected StructInMiscNoTwinExampleA sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -50893,6 +51633,34 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return inner; } + @protected + int sse_decode_CastedPrimitive_i_64(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_i_64(deserializer); + return inner.toInt(); + } + + @protected + int sse_decode_CastedPrimitive_isize(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_isize(deserializer); + return inner.toInt(); + } + + @protected + int sse_decode_CastedPrimitive_u_64(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_u_64(deserializer); + return inner.toInt(); + } + + @protected + int sse_decode_CastedPrimitive_usize(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_usize(deserializer); + return inner.toInt(); + } + @protected String sse_decode_Char(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -50928,6 +51696,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return DateTime.fromMicrosecondsSinceEpoch(inner.toInt(), isUtc: true); } + @protected + int sse_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_String(deserializer); + return int.parse(inner); + } + @protected Object sse_decode_DartOpaque(SseDeserializer deserializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -51758,6 +52534,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); } + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return SimpleOpaqueExternalStructWithMethodImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + @protected StaticGetterOnlyTwinNormal sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -53925,6 +54710,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return (sse_decode_struct_in_lower_level(deserializer)); } + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_casted_primitive_twin_normal(deserializer)); + } + @protected StructWithCommentsTwinNormal sse_decode_box_autoadd_struct_with_comments_twin_normal( @@ -53958,6 +54751,32 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { deserializer)); } + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_dart_keyword_field_twin_normal( + deserializer)); + } + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_dart_keyword_field_twin_rust_async( + deserializer)); + } + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_dart_keyword_field_twin_sync(deserializer)); + } + @protected StructWithEnumTwinNormal sse_decode_box_autoadd_struct_with_enum_twin_normal( SseDeserializer deserializer) { @@ -54007,6 +54826,30 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { deserializer)); } + @protected + StructWithFieldRenameTwinNormal + sse_decode_box_autoadd_struct_with_field_rename_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_field_rename_twin_normal(deserializer)); + } + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_field_rename_twin_rust_async(deserializer)); + } + + @protected + StructWithFieldRenameTwinSync + sse_decode_box_autoadd_struct_with_field_rename_twin_sync( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_struct_with_field_rename_twin_sync(deserializer)); + } + @protected StructWithGoodAndOpaqueFieldTwinNormal sse_decode_box_autoadd_struct_with_good_and_opaque_field_twin_normal( @@ -57836,12 +58679,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs var var_regular = sse_decode_String(deserializer); var var_type = sse_decode_String(deserializer); - var var_async = sse_decode_bool(deserializer); + var var_async_ = sse_decode_bool(deserializer); var var_another = sse_decode_String(deserializer); return MoreThanJustOneRawStringStructTwinNormal( regular: var_regular, type: var_type, - async: var_async, + async_: var_async_, another: var_another); } @@ -57852,12 +58695,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs var var_regular = sse_decode_String(deserializer); var var_type = sse_decode_String(deserializer); - var var_async = sse_decode_bool(deserializer); + var var_async_ = sse_decode_bool(deserializer); var var_another = sse_decode_String(deserializer); return MoreThanJustOneRawStringStructTwinRustAsync( regular: var_regular, type: var_type, - async: var_async, + async_: var_async_, another: var_another); } @@ -57868,12 +58711,12 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs var var_regular = sse_decode_String(deserializer); var var_type = sse_decode_String(deserializer); - var var_async = sse_decode_bool(deserializer); + var var_async_ = sse_decode_bool(deserializer); var var_another = sse_decode_String(deserializer); return MoreThanJustOneRawStringStructTwinSync( regular: var_regular, type: var_type, - async: var_async, + async_: var_async_, another: var_another); } @@ -59984,6 +60827,22 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return StructInUpperLevel(upper: var_upper); } + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_fieldI64 = sse_decode_CastedPrimitive_i_64(deserializer); + var var_fieldU64 = sse_decode_CastedPrimitive_u_64(deserializer); + var var_fieldI32 = sse_decode_i_32(deserializer); + var var_fieldVecU8 = sse_decode_list_prim_u_8_strict(deserializer); + return StructWithCastedPrimitiveTwinNormal( + fieldI64: var_fieldI64, + fieldU64: var_fieldU64, + fieldI32: var_fieldI32, + fieldVecU8: var_fieldVecU8); + } + @protected StructWithCommentsTwinNormal sse_decode_struct_with_comments_twin_normal( SseDeserializer deserializer) { @@ -60020,6 +60879,39 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return StructWithCustomNameMethodTwinNormal(field0: var_field0); } + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_class_ = sse_decode_i_32(deserializer); + var var_interface_ = sse_decode_i_64(deserializer); + return StructWithDartKeywordFieldTwinNormal( + class_: var_class_, interface_: var_interface_); + } + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_class_ = sse_decode_i_32(deserializer); + var var_interface_ = sse_decode_i_64(deserializer); + return StructWithDartKeywordFieldTwinRustAsync( + class_: var_class_, interface_: var_interface_); + } + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_class_ = sse_decode_i_32(deserializer); + var var_interface_ = sse_decode_i_64(deserializer); + return StructWithDartKeywordFieldTwinSync( + class_: var_class_, interface_: var_interface_); + } + @protected StructWithEnumTwinNormal sse_decode_struct_with_enum_twin_normal( SseDeserializer deserializer) { @@ -60086,6 +60978,32 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { autoOpaque: var_autoOpaque, normal: var_normal); } + @protected + StructWithFieldRenameTwinNormal + sse_decode_struct_with_field_rename_twin_normal( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_renamed_field = sse_decode_i_32(deserializer); + return StructWithFieldRenameTwinNormal(renamed_field: var_renamed_field); + } + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_renamed_field = sse_decode_i_32(deserializer); + return StructWithFieldRenameTwinRustAsync(renamed_field: var_renamed_field); + } + + @protected + StructWithFieldRenameTwinSync sse_decode_struct_with_field_rename_twin_sync( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_renamed_field = sse_decode_i_32(deserializer); + return StructWithFieldRenameTwinSync(renamed_field: var_renamed_field); + } + @protected StructWithGoodAndOpaqueFieldTwinNormal sse_decode_struct_with_good_and_opaque_field_twin_normal( @@ -61095,6 +62013,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { serializer); } + @protected + void + sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as SimpleOpaqueExternalStructWithMethodImpl) + .frbInternalSseEncode(move: true), + serializer); + } + @protected void sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -61664,6 +62593,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { serializer); } + @protected + void + sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as SimpleOpaqueExternalStructWithMethodImpl) + .frbInternalSseEncode(move: false), + serializer); + } + @protected void sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -61816,6 +62756,30 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { throw UnimplementedError('Unreachable ()'); } + @protected + void sse_encode_CastedPrimitive_i_64(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_64(sseEncodeCastedPrimitiveI64(self), serializer); + } + + @protected + void sse_encode_CastedPrimitive_isize(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_isize(sseEncodeCastedPrimitiveI64(self), serializer); + } + + @protected + void sse_encode_CastedPrimitive_u_64(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_u_64(sseEncodeCastedPrimitiveU64(self), serializer); + } + + @protected + void sse_encode_CastedPrimitive_usize(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize(sseEncodeCastedPrimitiveU64(self), serializer); + } + @protected void sse_encode_Char(String self, SseSerializer serializer) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -61849,6 +62813,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { PlatformInt64Util.from(self.microsecondsSinceEpoch), serializer); } + @protected + void + sse_encode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String(self.toString(), serializer); + } + @protected void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer) { @@ -62858,6 +63830,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { serializer); } + @protected + void + sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as SimpleOpaqueExternalStructWithMethodImpl) + .frbInternalSseEncode(move: null), + serializer); + } + @protected void sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -65113,6 +66096,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_struct_in_lower_level(self, serializer); } + @protected + void sse_encode_box_autoadd_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_casted_primitive_twin_normal(self, serializer); + } + @protected void sse_encode_box_autoadd_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer) { @@ -65141,6 +66131,27 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_struct_with_custom_name_method_twin_normal(self, serializer); } + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_dart_keyword_field_twin_normal(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_dart_keyword_field_twin_rust_async(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_dart_keyword_field_twin_sync(self, serializer); + } + @protected void sse_encode_box_autoadd_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer) { @@ -65191,6 +66202,27 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { self, serializer); } + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_field_rename_twin_normal(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_field_rename_twin_rust_async(self, serializer); + } + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_struct_with_field_rename_twin_sync(self, serializer); + } + @protected void sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_normal( StructWithGoodAndOpaqueFieldTwinNormal self, SseSerializer serializer) { @@ -68443,7 +69475,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_String(self.regular, serializer); sse_encode_String(self.type, serializer); - sse_encode_bool(self.async, serializer); + sse_encode_bool(self.async_, serializer); sse_encode_String(self.another, serializer); } @@ -68454,7 +69486,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_String(self.regular, serializer); sse_encode_String(self.type, serializer); - sse_encode_bool(self.async, serializer); + sse_encode_bool(self.async_, serializer); sse_encode_String(self.another, serializer); } @@ -68464,7 +69496,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_String(self.regular, serializer); sse_encode_String(self.type, serializer); - sse_encode_bool(self.async, serializer); + sse_encode_bool(self.async_, serializer); sse_encode_String(self.another, serializer); } @@ -70304,6 +71336,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_usize(self.upper, serializer); } + @protected + void sse_encode_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_CastedPrimitive_i_64(self.fieldI64, serializer); + sse_encode_CastedPrimitive_u_64(self.fieldU64, serializer); + sse_encode_i_32(self.fieldI32, serializer); + sse_encode_list_prim_u_8_strict(self.fieldVecU8, serializer); + } + @protected void sse_encode_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer) { @@ -70332,6 +71374,30 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(self.field0, serializer); } + @protected + void sse_encode_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.class_, serializer); + sse_encode_i_64(self.interface_, serializer); + } + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.class_, serializer); + sse_encode_i_64(self.interface_, serializer); + } + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.class_, serializer); + sse_encode_i_64(self.interface_, serializer); + } + @protected void sse_encode_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer) { @@ -70386,6 +71452,27 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { sse_encode_i_32(self.normal, serializer); } + @protected + void sse_encode_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.renamed_field, serializer); + } + + @protected + void sse_encode_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.renamed_field, serializer); + } + + @protected + void sse_encode_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.renamed_field, serializer); + } + @protected void sse_encode_struct_with_good_and_opaque_field_twin_normal( StructWithGoodAndOpaqueFieldTwinNormal self, SseSerializer serializer) { @@ -72270,6 +73357,34 @@ class RwLockHideDataTwinSyncImpl extends RustOpaque ); } +@sealed +class SimpleOpaqueExternalStructWithMethodImpl extends RustOpaque + implements SimpleOpaqueExternalStructWithMethod { + // Not to be used by end users + SimpleOpaqueExternalStructWithMethodImpl.frbInternalDcoDecode( + List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + SimpleOpaqueExternalStructWithMethodImpl.frbInternalSseDecode( + BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: RustLib.instance.api + .rust_arc_increment_strong_count_SimpleOpaqueExternalStructWithMethod, + rustArcDecrementStrongCount: RustLib.instance.api + .rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethod, + rustArcDecrementStrongCountPtr: RustLib.instance.api + .rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethodPtr, + ); + + Future simpleExternalMethod() => RustLib.instance.api + .crateApiExternalImplSimpleOpaqueExternalStructWithMethodSimpleExternalMethod( + that: this, + ); +} + @sealed class StaticGetterOnlyTwinNormalImpl extends RustOpaque implements StaticGetterOnlyTwinNormal { 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 62b20a04da..ecfae1c1a9 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 @@ -9,9 +9,11 @@ import 'api/async_misc.dart'; import 'api/async_spawn.dart'; import 'api/attribute.dart'; import 'api/benchmark_misc.dart'; +import 'api/casted_primitive.dart'; import 'api/chrono_type.dart'; import 'api/comment.dart'; import 'api/constructor.dart'; +import 'api/custom_ser_des.dart'; import 'api/customization.dart'; import 'api/dart_code.dart'; import 'api/dart_fn.dart'; @@ -351,6 +353,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { get rust_arc_decrement_strong_count_OpaqueTwoTwinSyncPtr => wire ._rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncPtr; + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethodPtr => + wire._rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethodPtr; + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_StaticGetterOnlyTwinNormalPtr => wire ._rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormalPtr; @@ -611,6 +617,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StaticGetterOnlyTwinNormal dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -871,6 +882,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StructInMiscNoTwinExampleA dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -939,6 +955,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String dco_decode_Backtrace(dynamic raw); + @protected + int dco_decode_CastedPrimitive_i_64(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_isize(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_u_64(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_usize(dynamic raw); + @protected String dco_decode_Char(dynamic raw); @@ -954,6 +982,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected DateTime dco_decode_Chrono_Utc(dynamic raw); + @protected + int dco_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + dynamic raw); + @protected FutureOr Function(Object) dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( @@ -1401,6 +1433,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StaticGetterOnlyTwinNormal dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -2423,6 +2460,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected StructInLowerLevel dco_decode_box_autoadd_struct_in_lower_level(dynamic raw); + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + dynamic raw); + @protected StructWithCommentsTwinNormal dco_decode_box_autoadd_struct_with_comments_twin_normal(dynamic raw); @@ -2440,6 +2482,21 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_box_autoadd_struct_with_custom_name_method_twin_normal( dynamic raw); + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + dynamic raw); + @protected StructWithEnumTwinNormal dco_decode_box_autoadd_struct_with_enum_twin_normal( dynamic raw); @@ -2467,6 +2524,19 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync( dynamic raw); + @protected + StructWithFieldRenameTwinNormal + dco_decode_box_autoadd_struct_with_field_rename_twin_normal(dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + dynamic raw); + + @protected + StructWithFieldRenameTwinSync + dco_decode_box_autoadd_struct_with_field_rename_twin_sync(dynamic raw); + @protected StructWithGoodAndOpaqueFieldTwinNormal dco_decode_box_autoadd_struct_with_good_and_opaque_field_twin_normal( @@ -4286,6 +4356,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected StructInUpperLevel dco_decode_struct_in_upper_level(dynamic raw); + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_struct_with_casted_primitive_twin_normal(dynamic raw); + @protected StructWithCommentsTwinNormal dco_decode_struct_with_comments_twin_normal( dynamic raw); @@ -4302,6 +4376,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithCustomNameMethodTwinNormal dco_decode_struct_with_custom_name_method_twin_normal(dynamic raw); + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_struct_with_dart_keyword_field_twin_normal(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_struct_with_dart_keyword_field_twin_rust_async(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_struct_with_dart_keyword_field_twin_sync(dynamic raw); + @protected StructWithEnumTwinNormal dco_decode_struct_with_enum_twin_normal(dynamic raw); @@ -4326,6 +4412,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithExplicitAutoOpaqueFieldTwinSync dco_decode_struct_with_explicit_auto_opaque_field_twin_sync(dynamic raw); + @protected + StructWithFieldRenameTwinNormal + dco_decode_struct_with_field_rename_twin_normal(dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_struct_with_field_rename_twin_rust_async(dynamic raw); + + @protected + StructWithFieldRenameTwinSync dco_decode_struct_with_field_rename_twin_sync( + dynamic raw); + @protected StructWithGoodAndOpaqueFieldTwinNormal dco_decode_struct_with_good_and_opaque_field_twin_normal(dynamic raw); @@ -4735,6 +4833,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StaticGetterOnlyTwinNormal sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -4995,6 +5098,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StructInMiscNoTwinExampleA sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -5063,6 +5171,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String sse_decode_Backtrace(SseDeserializer deserializer); + @protected + int sse_decode_CastedPrimitive_i_64(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_isize(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_u_64(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_usize(SseDeserializer deserializer); + @protected String sse_decode_Char(SseDeserializer deserializer); @@ -5078,6 +5198,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected DateTime sse_decode_Chrono_Utc(SseDeserializer deserializer); + @protected + int sse_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + SseDeserializer deserializer); + @protected Object sse_decode_DartOpaque(SseDeserializer deserializer); @@ -5501,6 +5625,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StaticGetterOnlyTwinNormal sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -6630,6 +6759,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructInLowerLevel sse_decode_box_autoadd_struct_in_lower_level( SseDeserializer deserializer); + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer); + @protected StructWithCommentsTwinNormal sse_decode_box_autoadd_struct_with_comments_twin_normal( @@ -6650,6 +6784,21 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_box_autoadd_struct_with_custom_name_method_twin_normal( SseDeserializer deserializer); + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer); + @protected StructWithEnumTwinNormal sse_decode_box_autoadd_struct_with_enum_twin_normal( SseDeserializer deserializer); @@ -6678,6 +6827,21 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync( SseDeserializer deserializer); + @protected + StructWithFieldRenameTwinNormal + sse_decode_box_autoadd_struct_with_field_rename_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSync + sse_decode_box_autoadd_struct_with_field_rename_twin_sync( + SseDeserializer deserializer); + @protected StructWithGoodAndOpaqueFieldTwinNormal sse_decode_box_autoadd_struct_with_good_and_opaque_field_twin_normal( @@ -8754,6 +8918,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructInUpperLevel sse_decode_struct_in_upper_level( SseDeserializer deserializer); + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer); + @protected StructWithCommentsTwinNormal sse_decode_struct_with_comments_twin_normal( SseDeserializer deserializer); @@ -8772,6 +8941,21 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_struct_with_custom_name_method_twin_normal( SseDeserializer deserializer); + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer); + @protected StructWithEnumTwinNormal sse_decode_struct_with_enum_twin_normal( SseDeserializer deserializer); @@ -8799,6 +8983,20 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_struct_with_explicit_auto_opaque_field_twin_sync( SseDeserializer deserializer); + @protected + StructWithFieldRenameTwinNormal + sse_decode_struct_with_field_rename_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSync sse_decode_struct_with_field_rename_twin_sync( + SseDeserializer deserializer); + @protected StructWithGoodAndOpaqueFieldTwinNormal sse_decode_struct_with_good_and_opaque_field_twin_normal( @@ -9247,6 +9445,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( OpaqueTwoTwinSync self, SseSerializer serializer); + @protected + void + sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -9513,6 +9716,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( OpaqueStructWithDartCodeTwinNormal self, SseSerializer serializer); + @protected + void + sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -9584,6 +9792,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_Backtrace(String self, SseSerializer serializer); + @protected + void sse_encode_CastedPrimitive_i_64(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_isize(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_u_64(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_usize(int self, SseSerializer serializer); + @protected void sse_encode_Char(String self, SseSerializer serializer); @@ -9599,6 +9819,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_Chrono_Utc(DateTime self, SseSerializer serializer); + @protected + void + sse_encode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + int self, SseSerializer serializer); + @protected void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer); @@ -10074,6 +10299,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( OpaqueTwoTwinSync self, SseSerializer serializer); + @protected + void + sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -11163,6 +11393,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_box_autoadd_struct_in_lower_level( StructInLowerLevel self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer); @@ -11179,6 +11413,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_box_autoadd_struct_with_custom_name_method_twin_normal( StructWithCustomNameMethodTwinNormal self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer); @@ -11207,6 +11453,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync( StructWithExplicitAutoOpaqueFieldTwinSync self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_normal( StructWithGoodAndOpaqueFieldTwinNormal self, SseSerializer serializer); @@ -13230,6 +13488,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_struct_in_upper_level( StructInUpperLevel self, SseSerializer serializer); + @protected + void sse_encode_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer); + @protected void sse_encode_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer); @@ -13246,6 +13508,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_struct_with_custom_name_method_twin_normal( StructWithCustomNameMethodTwinNormal self, SseSerializer serializer); + @protected + void sse_encode_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer); + @protected void sse_encode_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer); @@ -13272,6 +13546,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_struct_with_explicit_auto_opaque_field_twin_sync( StructWithExplicitAutoOpaqueFieldTwinSync self, SseSerializer serializer); + @protected + void sse_encode_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer); + @protected void sse_encode_struct_with_good_and_opaque_field_twin_normal( StructWithGoodAndOpaqueFieldTwinNormal self, SseSerializer serializer); @@ -15121,6 +15407,38 @@ class RustLibWire implements BaseWire { _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSyncPtr .asFunction)>(); + void + rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethodPtr = + _lookup)>>( + 'frbgen_frb_example_pure_dart_pde_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod'); + late final _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod = + _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethodPtr + .asFunction)>(); + + void + rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethodPtr = + _lookup)>>( + 'frbgen_frb_example_pure_dart_pde_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod'); + late final _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod = + _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethodPtr + .asFunction)>(); + void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( ffi.Pointer ptr, 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 3ebea5b47d..59f8b4f690 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 @@ -12,9 +12,11 @@ import 'api/async_misc.dart'; import 'api/async_spawn.dart'; import 'api/attribute.dart'; import 'api/benchmark_misc.dart'; +import 'api/casted_primitive.dart'; import 'api/chrono_type.dart'; import 'api/comment.dart'; import 'api/constructor.dart'; +import 'api/custom_ser_des.dart'; import 'api/customization.dart'; import 'api/dart_code.dart'; import 'api/dart_fn.dart'; @@ -353,6 +355,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { get rust_arc_decrement_strong_count_OpaqueTwoTwinSyncPtr => wire .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync; + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_SimpleOpaqueExternalStructWithMethodPtr => + wire.rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod; + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_StaticGetterOnlyTwinNormalPtr => wire .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal; @@ -613,6 +619,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StaticGetterOnlyTwinNormal dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -873,6 +884,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StructInMiscNoTwinExampleA dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -941,6 +957,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String dco_decode_Backtrace(dynamic raw); + @protected + int dco_decode_CastedPrimitive_i_64(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_isize(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_u_64(dynamic raw); + + @protected + int dco_decode_CastedPrimitive_usize(dynamic raw); + @protected String dco_decode_Char(dynamic raw); @@ -956,6 +984,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected DateTime dco_decode_Chrono_Utc(dynamic raw); + @protected + int dco_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + dynamic raw); + @protected FutureOr Function(Object) dco_decode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( @@ -1403,6 +1435,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( dynamic raw); + @protected + SimpleOpaqueExternalStructWithMethod + dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic raw); + @protected StaticGetterOnlyTwinNormal dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -2425,6 +2462,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected StructInLowerLevel dco_decode_box_autoadd_struct_in_lower_level(dynamic raw); + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + dynamic raw); + @protected StructWithCommentsTwinNormal dco_decode_box_autoadd_struct_with_comments_twin_normal(dynamic raw); @@ -2442,6 +2484,21 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_box_autoadd_struct_with_custom_name_method_twin_normal( dynamic raw); + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + dynamic raw); + @protected StructWithEnumTwinNormal dco_decode_box_autoadd_struct_with_enum_twin_normal( dynamic raw); @@ -2469,6 +2526,19 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { dco_decode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync( dynamic raw); + @protected + StructWithFieldRenameTwinNormal + dco_decode_box_autoadd_struct_with_field_rename_twin_normal(dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + dynamic raw); + + @protected + StructWithFieldRenameTwinSync + dco_decode_box_autoadd_struct_with_field_rename_twin_sync(dynamic raw); + @protected StructWithGoodAndOpaqueFieldTwinNormal dco_decode_box_autoadd_struct_with_good_and_opaque_field_twin_normal( @@ -4288,6 +4358,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected StructInUpperLevel dco_decode_struct_in_upper_level(dynamic raw); + @protected + StructWithCastedPrimitiveTwinNormal + dco_decode_struct_with_casted_primitive_twin_normal(dynamic raw); + @protected StructWithCommentsTwinNormal dco_decode_struct_with_comments_twin_normal( dynamic raw); @@ -4304,6 +4378,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithCustomNameMethodTwinNormal dco_decode_struct_with_custom_name_method_twin_normal(dynamic raw); + @protected + StructWithDartKeywordFieldTwinNormal + dco_decode_struct_with_dart_keyword_field_twin_normal(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinRustAsync + dco_decode_struct_with_dart_keyword_field_twin_rust_async(dynamic raw); + + @protected + StructWithDartKeywordFieldTwinSync + dco_decode_struct_with_dart_keyword_field_twin_sync(dynamic raw); + @protected StructWithEnumTwinNormal dco_decode_struct_with_enum_twin_normal(dynamic raw); @@ -4328,6 +4414,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructWithExplicitAutoOpaqueFieldTwinSync dco_decode_struct_with_explicit_auto_opaque_field_twin_sync(dynamic raw); + @protected + StructWithFieldRenameTwinNormal + dco_decode_struct_with_field_rename_twin_normal(dynamic raw); + + @protected + StructWithFieldRenameTwinRustAsync + dco_decode_struct_with_field_rename_twin_rust_async(dynamic raw); + + @protected + StructWithFieldRenameTwinSync dco_decode_struct_with_field_rename_twin_sync( + dynamic raw); + @protected StructWithGoodAndOpaqueFieldTwinNormal dco_decode_struct_with_good_and_opaque_field_twin_normal(dynamic raw); @@ -4737,6 +4835,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StaticGetterOnlyTwinNormal sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -4997,6 +5100,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StructInMiscNoTwinExampleA sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -5065,6 +5173,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected String sse_decode_Backtrace(SseDeserializer deserializer); + @protected + int sse_decode_CastedPrimitive_i_64(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_isize(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_u_64(SseDeserializer deserializer); + + @protected + int sse_decode_CastedPrimitive_usize(SseDeserializer deserializer); + @protected String sse_decode_Char(SseDeserializer deserializer); @@ -5080,6 +5200,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected DateTime sse_decode_Chrono_Utc(SseDeserializer deserializer); + @protected + int sse_decode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + SseDeserializer deserializer); + @protected Object sse_decode_DartOpaque(SseDeserializer deserializer); @@ -5503,6 +5627,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( SseDeserializer deserializer); + @protected + SimpleOpaqueExternalStructWithMethod + sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SseDeserializer deserializer); + @protected StaticGetterOnlyTwinNormal sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -6632,6 +6761,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructInLowerLevel sse_decode_box_autoadd_struct_in_lower_level( SseDeserializer deserializer); + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_box_autoadd_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer); + @protected StructWithCommentsTwinNormal sse_decode_box_autoadd_struct_with_comments_twin_normal( @@ -6652,6 +6786,21 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_box_autoadd_struct_with_custom_name_method_twin_normal( SseDeserializer deserializer); + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer); + @protected StructWithEnumTwinNormal sse_decode_box_autoadd_struct_with_enum_twin_normal( SseDeserializer deserializer); @@ -6680,6 +6829,21 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync( SseDeserializer deserializer); + @protected + StructWithFieldRenameTwinNormal + sse_decode_box_autoadd_struct_with_field_rename_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_box_autoadd_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSync + sse_decode_box_autoadd_struct_with_field_rename_twin_sync( + SseDeserializer deserializer); + @protected StructWithGoodAndOpaqueFieldTwinNormal sse_decode_box_autoadd_struct_with_good_and_opaque_field_twin_normal( @@ -8756,6 +8920,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { StructInUpperLevel sse_decode_struct_in_upper_level( SseDeserializer deserializer); + @protected + StructWithCastedPrimitiveTwinNormal + sse_decode_struct_with_casted_primitive_twin_normal( + SseDeserializer deserializer); + @protected StructWithCommentsTwinNormal sse_decode_struct_with_comments_twin_normal( SseDeserializer deserializer); @@ -8774,6 +8943,21 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_struct_with_custom_name_method_twin_normal( SseDeserializer deserializer); + @protected + StructWithDartKeywordFieldTwinNormal + sse_decode_struct_with_dart_keyword_field_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinRustAsync + sse_decode_struct_with_dart_keyword_field_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithDartKeywordFieldTwinSync + sse_decode_struct_with_dart_keyword_field_twin_sync( + SseDeserializer deserializer); + @protected StructWithEnumTwinNormal sse_decode_struct_with_enum_twin_normal( SseDeserializer deserializer); @@ -8801,6 +8985,20 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_decode_struct_with_explicit_auto_opaque_field_twin_sync( SseDeserializer deserializer); + @protected + StructWithFieldRenameTwinNormal + sse_decode_struct_with_field_rename_twin_normal( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinRustAsync + sse_decode_struct_with_field_rename_twin_rust_async( + SseDeserializer deserializer); + + @protected + StructWithFieldRenameTwinSync sse_decode_struct_with_field_rename_twin_sync( + SseDeserializer deserializer); + @protected StructWithGoodAndOpaqueFieldTwinNormal sse_decode_struct_with_good_and_opaque_field_twin_normal( @@ -9249,6 +9447,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( OpaqueTwoTwinSync self, SseSerializer serializer); + @protected + void + sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -9515,6 +9718,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueStructWithDartCodeTwinNormal( OpaqueStructWithDartCodeTwinNormal self, SseSerializer serializer); + @protected + void + sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStructInMiscNoTwinExampleA( @@ -9586,6 +9794,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_Backtrace(String self, SseSerializer serializer); + @protected + void sse_encode_CastedPrimitive_i_64(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_isize(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_u_64(int self, SseSerializer serializer); + + @protected + void sse_encode_CastedPrimitive_usize(int self, SseSerializer serializer); + @protected void sse_encode_Char(String self, SseSerializer serializer); @@ -9601,6 +9821,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected void sse_encode_Chrono_Utc(DateTime self, SseSerializer serializer); + @protected + void + sse_encode_CustomSerializer_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMessageWithCustomSerializerTwinNormal( + int self, SseSerializer serializer); + @protected void sse_encode_DartFn_Inputs_DartOpaque_Output_unit_AnyhowException( FutureOr Function(Object) self, SseSerializer serializer); @@ -10076,6 +10301,11 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( OpaqueTwoTwinSync self, SseSerializer serializer); + @protected + void + sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + SimpleOpaqueExternalStructWithMethod self, SseSerializer serializer); + @protected void sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( @@ -11165,6 +11395,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_box_autoadd_struct_in_lower_level( StructInLowerLevel self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer); @@ -11181,6 +11415,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_box_autoadd_struct_with_custom_name_method_twin_normal( StructWithCustomNameMethodTwinNormal self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer); @@ -11209,6 +11455,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_box_autoadd_struct_with_explicit_auto_opaque_field_twin_sync( StructWithExplicitAutoOpaqueFieldTwinSync self, SseSerializer serializer); + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer); + @protected void sse_encode_box_autoadd_struct_with_good_and_opaque_field_twin_normal( StructWithGoodAndOpaqueFieldTwinNormal self, SseSerializer serializer); @@ -13232,6 +13490,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_struct_in_upper_level( StructInUpperLevel self, SseSerializer serializer); + @protected + void sse_encode_struct_with_casted_primitive_twin_normal( + StructWithCastedPrimitiveTwinNormal self, SseSerializer serializer); + @protected void sse_encode_struct_with_comments_twin_normal( StructWithCommentsTwinNormal self, SseSerializer serializer); @@ -13248,6 +13510,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_struct_with_custom_name_method_twin_normal( StructWithCustomNameMethodTwinNormal self, SseSerializer serializer); + @protected + void sse_encode_struct_with_dart_keyword_field_twin_normal( + StructWithDartKeywordFieldTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_rust_async( + StructWithDartKeywordFieldTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_dart_keyword_field_twin_sync( + StructWithDartKeywordFieldTwinSync self, SseSerializer serializer); + @protected void sse_encode_struct_with_enum_twin_normal( StructWithEnumTwinNormal self, SseSerializer serializer); @@ -13274,6 +13548,18 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { void sse_encode_struct_with_explicit_auto_opaque_field_twin_sync( StructWithExplicitAutoOpaqueFieldTwinSync self, SseSerializer serializer); + @protected + void sse_encode_struct_with_field_rename_twin_normal( + StructWithFieldRenameTwinNormal self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_rust_async( + StructWithFieldRenameTwinRustAsync self, SseSerializer serializer); + + @protected + void sse_encode_struct_with_field_rename_twin_sync( + StructWithFieldRenameTwinSync self, SseSerializer serializer); + @protected void sse_encode_struct_with_good_and_opaque_field_twin_normal( StructWithGoodAndOpaqueFieldTwinNormal self, SseSerializer serializer); @@ -14128,6 +14414,18 @@ class RustLibWire implements BaseWire { .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( ptr); + void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic ptr) => + wasmModule + .rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr); + + void rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic ptr) => + wasmModule + .rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr); + void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( dynamic ptr) => wasmModule @@ -14735,6 +15033,14 @@ class RustLibWasmModule { rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOpaqueTwoTwinSync( dynamic ptr); + external void + rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic ptr); + + external void + rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + dynamic ptr); + external void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( dynamic ptr); diff --git a/frb_example/pure_dart_pde/rust/src/api/casted_primitive.rs b/frb_example/pure_dart_pde/rust/src/api/casted_primitive.rs new file mode 100644 index 0000000000..f1c6a41c99 --- /dev/null +++ b/frb_example/pure_dart_pde/rust/src/api/casted_primitive.rs @@ -0,0 +1,50 @@ +// AUTO-GENERATED FROM frb_example/pure_dart, DO NOT EDIT + +// FRB_INTERNAL_GENERATOR: {"forbiddenDuplicatorModes": ["sync", "rustAsync", "sse", "sync sse", "rustAsync sse"]} + +use flutter_rust_bridge::frb; + +#[frb(serialize)] +#[frb(type_64bit_int)] +pub fn casted_primitive_i64_twin_normal(arg: i64) -> i64 { + arg +} + +#[frb(serialize)] +#[frb(type_64bit_int)] +pub fn casted_primitive_u64_twin_normal(arg: u64) -> u64 { + arg +} + +#[frb(serialize)] +#[frb(type_64bit_int)] +pub fn casted_primitive_isize_twin_normal(arg: isize) -> isize { + arg +} + +#[frb(serialize)] +#[frb(type_64bit_int)] +pub fn casted_primitive_usize_twin_normal(arg: usize) -> usize { + arg +} + +#[frb(serialize)] +#[frb(type_64bit_int)] +pub fn casted_primitive_multi_arg_twin_normal(a: i32, b: i64, c: usize, d: i128) { + let _ = (a, b, c, d); +} + +#[frb(type_64bit_int)] +pub struct StructWithCastedPrimitiveTwinNormal { + pub field_i64: i64, + pub field_u64: u64, + pub field_i32: i32, + pub field_vec_u8: Vec, +} + +#[frb(serialize)] +pub fn function_for_struct_with_casted_primitive_twin_normal( + arg: StructWithCastedPrimitiveTwinNormal, +) -> StructWithCastedPrimitiveTwinNormal { + arg +} diff --git a/frb_example/pure_dart_pde/rust/src/api/custom_ser_des.rs b/frb_example/pure_dart_pde/rust/src/api/custom_ser_des.rs new file mode 100644 index 0000000000..18f038513d --- /dev/null +++ b/frb_example/pure_dart_pde/rust/src/api/custom_ser_des.rs @@ -0,0 +1,27 @@ +// AUTO-GENERATED FROM frb_example/pure_dart, DO NOT EDIT + +// FRB_INTERNAL_GENERATOR: {"forbiddenDuplicatorModes": ["sync", "rustAsync", "sse", "sync sse", "rustAsync sse"]} + +use flutter_rust_bridge::frb; + +#[frb(opaque)] +pub struct MessageWithCustomSerializerTwinNormal(i32); + +#[frb(rust2dart(dart_type = "int", dart_code = "int.parse({})"))] +#[frb(serialize)] +pub fn serializer_my_type(raw: MessageWithCustomSerializerTwinNormal) -> String { + raw.0.to_string() +} + +#[frb(dart2rust(dart_type = "int", dart_code = "{}.toString()"))] +#[frb(serialize)] +pub fn deserializer_my_type(raw: String) -> MessageWithCustomSerializerTwinNormal { + MessageWithCustomSerializerTwinNormal(raw.parse().unwrap()) +} + +#[frb(serialize)] +pub fn function_using_type_with_custom_serializer( + arg: MessageWithCustomSerializerTwinNormal, +) -> MessageWithCustomSerializerTwinNormal { + arg +} diff --git a/frb_example/pure_dart_pde/rust/src/api/mod.rs b/frb_example/pure_dart_pde/rust/src/api/mod.rs index 8f6efad3f1..0e6de120d0 100644 --- a/frb_example/pure_dart_pde/rust/src/api/mod.rs +++ b/frb_example/pure_dart_pde/rust/src/api/mod.rs @@ -4,12 +4,14 @@ pub mod async_misc; pub mod async_spawn; pub mod attribute; pub mod benchmark_misc; +pub mod casted_primitive; pub mod chrono_type; pub mod comment; #[cfg(target_os = "non_existent_os")] pub mod conditionally_compiled_module; pub mod constructor; pub mod custom_handler; +pub mod custom_ser_des; pub mod customization; pub mod dart_code; pub mod dart_fn; diff --git a/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/structure_twin_rust_async.rs b/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/structure_twin_rust_async.rs index 984c4a0f87..8f56d9d29e 100644 --- a/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/structure_twin_rust_async.rs +++ b/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/structure_twin_rust_async.rs @@ -4,6 +4,8 @@ // AUTO-GENERATED FROM frb_example/pure_dart, DO NOT EDIT +use flutter_rust_bridge::frb; + pub struct StructWithZeroFieldTwinRustAsync {} pub async fn func_struct_with_zero_field_twin_rust_async( @@ -48,3 +50,26 @@ pub async fn func_tuple_struct_with_two_field_twin_rust_async( ) -> TupleStructWithTwoFieldTwinRustAsync { arg } + +#[frb] +pub struct StructWithFieldRenameTwinRustAsync { + #[frb(name = "renamed_field")] + pub class: i32, +} + +pub async fn func_for_struct_with_field_rename_twin_rust_async( + arg: StructWithFieldRenameTwinRustAsync, +) -> StructWithFieldRenameTwinRustAsync { + arg +} + +pub struct StructWithDartKeywordFieldTwinRustAsync { + pub class: i32, + pub interface: i64, +} + +pub async fn func_for_struct_with_dart_keyword_field_twin_rust_async( + arg: StructWithDartKeywordFieldTwinRustAsync, +) -> StructWithDartKeywordFieldTwinRustAsync { + arg +} diff --git a/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/structure_twin_sync.rs b/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/structure_twin_sync.rs index ec56c339d2..2751e8dc5d 100644 --- a/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/structure_twin_sync.rs +++ b/frb_example/pure_dart_pde/rust/src/api/pseudo_manual/structure_twin_sync.rs @@ -4,6 +4,8 @@ // AUTO-GENERATED FROM frb_example/pure_dart, DO NOT EDIT +use flutter_rust_bridge::frb; + pub struct StructWithZeroFieldTwinSync {} #[flutter_rust_bridge::frb(sync)] @@ -53,3 +55,28 @@ pub fn func_tuple_struct_with_two_field_twin_sync( ) -> TupleStructWithTwoFieldTwinSync { arg } + +#[frb] +pub struct StructWithFieldRenameTwinSync { + #[frb(name = "renamed_field")] + pub class: i32, +} + +#[flutter_rust_bridge::frb(sync)] +pub fn func_for_struct_with_field_rename_twin_sync( + arg: StructWithFieldRenameTwinSync, +) -> StructWithFieldRenameTwinSync { + arg +} + +pub struct StructWithDartKeywordFieldTwinSync { + pub class: i32, + pub interface: i64, +} + +#[flutter_rust_bridge::frb(sync)] +pub fn func_for_struct_with_dart_keyword_field_twin_sync( + arg: StructWithDartKeywordFieldTwinSync, +) -> StructWithDartKeywordFieldTwinSync { + arg +} diff --git a/frb_example/pure_dart_pde/rust/src/api/structure.rs b/frb_example/pure_dart_pde/rust/src/api/structure.rs index 0e0873e905..289dca2751 100644 --- a/frb_example/pure_dart_pde/rust/src/api/structure.rs +++ b/frb_example/pure_dart_pde/rust/src/api/structure.rs @@ -1,5 +1,7 @@ // AUTO-GENERATED FROM frb_example/pure_dart, DO NOT EDIT +use flutter_rust_bridge::frb; + pub struct StructWithZeroFieldTwinNormal {} pub fn func_struct_with_zero_field_twin_normal( @@ -44,3 +46,26 @@ pub fn func_tuple_struct_with_two_field_twin_normal( ) -> TupleStructWithTwoFieldTwinNormal { arg } + +#[frb] +pub struct StructWithFieldRenameTwinNormal { + #[frb(name = "renamed_field")] + pub class: i32, +} + +pub fn func_for_struct_with_field_rename_twin_normal( + arg: StructWithFieldRenameTwinNormal, +) -> StructWithFieldRenameTwinNormal { + arg +} + +pub struct StructWithDartKeywordFieldTwinNormal { + pub class: i32, + pub interface: i64, +} + +pub fn func_for_struct_with_dart_keyword_field_twin_normal( + arg: StructWithDartKeywordFieldTwinNormal, +) -> StructWithDartKeywordFieldTwinNormal { + arg +} diff --git a/frb_example/pure_dart_pde/rust/src/frb_generated.io.rs b/frb_example/pure_dart_pde/rust/src/frb_generated.io.rs index c08156c0b6..bc23992286 100644 --- a/frb_example/pure_dart_pde/rust/src/frb_generated.io.rs +++ b/frb_example/pure_dart_pde/rust/src/frb_generated.io.rs @@ -5,10 +5,12 @@ use super::*; use crate::api::constructor::*; +use crate::api::custom_ser_des::*; use crate::api::dart_code::*; use crate::api::dropping::*; use crate::api::dyn_trait::SimpleTraitForDynTwinNormal; use crate::api::dyn_trait::*; +use crate::api::external_impl::*; use crate::api::impl_trait::SimpleTraitTwinNormal; use crate::api::impl_trait::*; use crate::api::method::*; @@ -846,6 +848,28 @@ pub extern "C" fn frbgen_frb_example_pure_dart_pde_rust_arc_decrement_strong_cou MoiArc::>::decrement_strong_count(ptr as _); } +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_pde_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr: *const std::ffi::c_void, +) { + MoiArc::< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >::increment_strong_count(ptr as _); +} + +#[no_mangle] +pub extern "C" fn frbgen_frb_example_pure_dart_pde_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr: *const std::ffi::c_void, +) { + MoiArc::< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >::decrement_strong_count(ptr as _); +} + #[no_mangle] pub extern "C" fn frbgen_frb_example_pure_dart_pde_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( ptr: *const std::ffi::c_void, 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 40b94c678a..232694b08d 100644 --- a/frb_example/pure_dart_pde/rust/src/frb_generated.rs +++ b/frb_example/pure_dart_pde/rust/src/frb_generated.rs @@ -22,10 +22,12 @@ // Section: imports use crate::api::constructor::*; +use crate::api::custom_ser_des::*; use crate::api::dart_code::*; use crate::api::dropping::*; use crate::api::dyn_trait::SimpleTraitForDynTwinNormal; use crate::api::dyn_trait::*; +use crate::api::external_impl::*; use crate::api::impl_trait::SimpleTraitTwinNormal; use crate::api::impl_trait::*; use crate::api::method::*; @@ -57,7 +59,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.38"; -pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 2063949598; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -263748021; // Section: executor @@ -743,6 +745,196 @@ fn wire__crate__api__benchmark_misc__benchmark_void_semi_serialize_impl( }, ) } +fn wire__crate__api__casted_primitive__casted_primitive_i64_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: "casted_primitive_i64_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::casted_primitive::casted_primitive_i64_twin_normal(api_arg), + ) + })()) + } + }, + ) +} +fn wire__crate__api__casted_primitive__casted_primitive_isize_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: "casted_primitive_isize_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::casted_primitive::casted_primitive_isize_twin_normal(api_arg), + ) + })()) + } + }, + ) +} +fn wire__crate__api__casted_primitive__casted_primitive_multi_arg_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: "casted_primitive_multi_arg_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_a = ::sse_decode(&mut deserializer); + let api_b = ::sse_decode(&mut deserializer); + let api_c = ::sse_decode(&mut deserializer); + let api_d = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse((move || { + Result::<_, ()>::Ok({ + crate::api::casted_primitive::casted_primitive_multi_arg_twin_normal( + api_a, api_b, api_c, api_d, + ); + }) + })()) + } + }, + ) +} +fn wire__crate__api__casted_primitive__casted_primitive_u64_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: "casted_primitive_u64_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::casted_primitive::casted_primitive_u64_twin_normal(api_arg), + ) + })()) + } + }, + ) +} +fn wire__crate__api__casted_primitive__casted_primitive_usize_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: "casted_primitive_usize_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::casted_primitive::casted_primitive_usize_twin_normal(api_arg), + ) + })()) + } + }, + ) +} +fn wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_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_for_struct_with_casted_primitive_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::casted_primitive::function_for_struct_with_casted_primitive_twin_normal(api_arg)) + })()) + } }) +} fn wire__crate__api__chrono_type__datetime_local_twin_normal_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -1587,6 +1779,42 @@ fn wire__crate__api__constructor__constructor_translatable_sync_struct_twin_norm }, ) } +fn wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer_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_using_type_with_custom_serializer", + 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::custom_ser_des::function_using_type_with_custom_serializer( + api_arg, + ), + ) + })()) + } + }, + ) +} fn wire__crate__api__customization__check_init_done_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -4577,6 +4805,61 @@ fn wire__crate__api__exception__throw_anyhow_twin_normal_impl( }, ) } +fn wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new_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: "SimpleOpaqueExternalStructWithMethod_new", + 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_a = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse((move || { + Result::<_, ()>::Ok( + crate::api::external_impl::SimpleOpaqueExternalStructWithMethod::new(api_a), + ) + })()) + }, + ) +} +fn wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method_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: "SimpleOpaqueExternalStructWithMethod_simple_external_method", 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_that = >>::sse_decode(&mut deserializer);deserializer.end(); move |context| { + transform_result_sse((move || { + let mut api_that_decoded = None; +let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]); + for i in decode_indices_ { + match i { + 0 => api_that_decoded = Some(api_that.lockable_decode_sync_ref()), + _ => unreachable!(), + } + } + let api_that = &*api_that_decoded.unwrap(); + Result::<_,()>::Ok(crate::api::external_impl::SimpleOpaqueExternalStructWithMethod::simple_external_method(api_that)) + })()) + } }) +} fn wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -23952,6 +24235,36 @@ fn wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_v })().await) } }) } +fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_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: "func_for_struct_with_dart_keyword_field_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::structure_twin_rust_async::func_for_struct_with_dart_keyword_field_twin_rust_async(api_arg).await) + })().await) + } }) +} +fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_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: "func_for_struct_with_field_rename_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::structure_twin_rust_async::func_for_struct_with_field_rename_twin_rust_async(api_arg).await) + })().await) + } }) +} fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_struct_with_one_field_twin_rust_async_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -24027,6 +24340,32 @@ fn wire__crate__api__pseudo_manual__structure_twin_rust_async__func_tuple_struct })().await) } }) } +fn wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_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: "func_for_struct_with_dart_keyword_field_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::structure_twin_sync::func_for_struct_with_dart_keyword_field_twin_sync(api_arg)) + })()) }) +} +fn wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_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: "func_for_struct_with_field_rename_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::structure_twin_sync::func_for_struct_with_field_rename_twin_sync(api_arg)) + })()) }) +} fn wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync_impl( ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, rust_vec_len_: i32, @@ -26918,6 +27257,82 @@ fn wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal_impl( }, ) } +fn wire__crate__api__structure__func_for_struct_with_dart_keyword_field_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: "func_for_struct_with_dart_keyword_field_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::structure::func_for_struct_with_dart_keyword_field_twin_normal( + api_arg, + ), + ) + })()) + } + }, + ) +} +fn wire__crate__api__structure__func_for_struct_with_field_rename_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: "func_for_struct_with_field_rename_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::structure::func_for_struct_with_field_rename_twin_normal( + api_arg, + ), + ) + })()) + } + }, + ) +} fn wire__crate__api__structure__func_struct_with_one_field_twin_normal_impl( port_: flutter_rust_bridge::for_generated::DartNativeSendPort, ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, @@ -27932,6 +28347,9 @@ flutter_rust_bridge::frb_generated_moi_arc_impl_value!( flutter_rust_bridge::frb_generated_moi_arc_impl_value!( flutter_rust_bridge::for_generated::RustAutoOpaqueInner ); +flutter_rust_bridge::frb_generated_moi_arc_impl_value!( + flutter_rust_bridge::for_generated::RustAutoOpaqueInner +); flutter_rust_bridge::frb_generated_moi_arc_impl_value!( flutter_rust_bridge::for_generated::RustAutoOpaqueInner ); @@ -28707,6 +29125,18 @@ impl SseDecode for OpaqueTwoTwinSync { } } +impl SseDecode for SimpleOpaqueExternalStructWithMethod { + // 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 flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner); + } +} + impl SseDecode for StaticGetterOnlyTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -28940,6 +29370,14 @@ impl SseDecode for chrono::DateTime { } } +impl SseDecode for MessageWithCustomSerializerTwinNormal { + // 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 crate::api::custom_ser_des::deserializer_my_type(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 { @@ -29927,6 +30365,20 @@ impl SseDecode } } +impl SseDecode + for RustOpaqueMoi< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + > +{ + // 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 RustOpaqueMoi< flutter_rust_bridge::for_generated::RustAutoOpaqueInner, @@ -35172,12 +35624,12 @@ impl SseDecode for crate::api::raw_string::MoreThanJustOneRawStringStructTwinNor fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { let mut var_regular = ::sse_decode(deserializer); let mut var_type = ::sse_decode(deserializer); - let mut var_async = ::sse_decode(deserializer); + let mut var_async_ = ::sse_decode(deserializer); let mut var_another = ::sse_decode(deserializer); return crate::api::raw_string::MoreThanJustOneRawStringStructTwinNormal { regular: var_regular, r#type: var_type, - r#async: var_async, + r#async: var_async_, another: var_another, }; } @@ -35187,9 +35639,9 @@ impl SseDecode for crate::api::pseudo_manual::raw_string_twin_rust_async::MoreTh // 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_regular = ::sse_decode(deserializer); let mut var_type = ::sse_decode(deserializer); -let mut var_async = ::sse_decode(deserializer); +let mut var_async_ = ::sse_decode(deserializer); let mut var_another = ::sse_decode(deserializer); -return crate::api::pseudo_manual::raw_string_twin_rust_async::MoreThanJustOneRawStringStructTwinRustAsync{regular: var_regular, r#type: var_type, r#async: var_async, another: var_another};} +return crate::api::pseudo_manual::raw_string_twin_rust_async::MoreThanJustOneRawStringStructTwinRustAsync{regular: var_regular, r#type: var_type, r#async: var_async_, another: var_another};} } impl SseDecode @@ -35199,9 +35651,9 @@ impl SseDecode fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { let mut var_regular = ::sse_decode(deserializer); let mut var_type = ::sse_decode(deserializer); - let mut var_async = ::sse_decode(deserializer); + let mut var_async_ = ::sse_decode(deserializer); let mut var_another = ::sse_decode(deserializer); - return crate::api::pseudo_manual::raw_string_twin_sync::MoreThanJustOneRawStringStructTwinSync{regular: var_regular, r#type: var_type, r#async: var_async, another: var_another}; + return crate::api::pseudo_manual::raw_string_twin_sync::MoreThanJustOneRawStringStructTwinSync{regular: var_regular, r#type: var_type, r#async: var_async_, another: var_another}; } } @@ -37559,6 +38011,22 @@ impl SseDecode for crate::deliberate_name_conflict::StructInUpperLevel { } } +impl SseDecode for crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal { + // 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_fieldI64 = ::sse_decode(deserializer); + let mut var_fieldU64 = ::sse_decode(deserializer); + let mut var_fieldI32 = ::sse_decode(deserializer); + let mut var_fieldVecU8 = >::sse_decode(deserializer); + return crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal { + field_i64: var_fieldI64, + field_u64: var_fieldU64, + field_i32: var_fieldI32, + field_vec_u8: var_fieldVecU8, + }; + } +} + impl SseDecode for crate::api::comment::StructWithCommentsTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -37599,6 +38067,36 @@ impl SseDecode for crate::api::misc_no_twin_example_a::StructWithCustomNameMetho } } +impl SseDecode for crate::api::structure::StructWithDartKeywordFieldTwinNormal { + // 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_class_ = ::sse_decode(deserializer); + let mut var_interface_ = ::sse_decode(deserializer); + return crate::api::structure::StructWithDartKeywordFieldTwinNormal { + class: var_class_, + interface: var_interface_, + }; + } +} + +impl SseDecode for crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + // 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_class_ = ::sse_decode(deserializer); +let mut var_interface_ = ::sse_decode(deserializer); +return crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync{class: var_class_, interface: var_interface_};} + } + +impl SseDecode + for crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync +{ + // 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_class_ = ::sse_decode(deserializer); + let mut var_interface_ = ::sse_decode(deserializer); + return crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync{class: var_class_, interface: var_interface_}; + } +} + 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 { @@ -37673,6 +38171,36 @@ let mut var_normal = ::sse_decode(deserializer); return crate::api::pseudo_manual::rust_auto_opaque_twin_sync::StructWithExplicitAutoOpaqueFieldTwinSync{auto_opaque: var_autoOpaque, normal: var_normal};} } +impl SseDecode for crate::api::structure::StructWithFieldRenameTwinNormal { + // 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_renamed_field = ::sse_decode(deserializer); + return crate::api::structure::StructWithFieldRenameTwinNormal { + class: var_renamed_field, + }; + } +} + +impl SseDecode + for crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync +{ + // 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_renamed_field = ::sse_decode(deserializer); + return crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync{class: var_renamed_field}; + } +} + +impl SseDecode for crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + // 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_renamed_field = ::sse_decode(deserializer); + return crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + class: var_renamed_field, + }; + } +} + impl SseDecode for crate::api::rust_auto_opaque::StructWithGoodAndOpaqueFieldTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -38359,778 +38887,790 @@ fn pde_ffi_dispatcher_primary_impl( 17 => wire__crate__api__async_spawn__simple_use_async_spawn_local_impl(port, ptr, rust_vec_len, data_len), 18 => wire__crate__api__attribute__handle_customized_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), 19 => wire__crate__api__attribute__next_user_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), -21 => wire__crate__api__chrono_type__datetime_local_twin_normal_impl(port, ptr, rust_vec_len, data_len), -22 => wire__crate__api__chrono_type__datetime_utc_twin_normal_impl(port, ptr, rust_vec_len, data_len), -23 => wire__crate__api__chrono_type__duration_twin_normal_impl(port, ptr, rust_vec_len, data_len), -24 => wire__crate__api__chrono_type__handle_durations_twin_normal_impl(port, ptr, rust_vec_len, data_len), -25 => wire__crate__api__chrono_type__handle_timestamps_twin_normal_impl(port, ptr, rust_vec_len, data_len), -26 => wire__crate__api__chrono_type__how_long_does_it_take_twin_normal_impl(port, ptr, rust_vec_len, data_len), -27 => wire__crate__api__chrono_type__naivedatetime_twin_normal_impl(port, ptr, rust_vec_len, data_len), -28 => wire__crate__api__chrono_type__optional_empty_datetime_utc_twin_normal_impl(port, ptr, rust_vec_len, data_len), -29 => wire__crate__api__chrono_type__test_chrono_twin_normal_impl(port, ptr, rust_vec_len, data_len), -30 => wire__crate__api__chrono_type__test_precise_chrono_twin_normal_impl(port, ptr, rust_vec_len, data_len), -31 => wire__crate__api__comment__function_with_comments_slash_star_star_twin_normal_impl(port, ptr, rust_vec_len, data_len), -32 => wire__crate__api__comment__function_with_comments_triple_slash_multi_line_twin_normal_impl(port, ptr, rust_vec_len, data_len), -33 => wire__crate__api__comment__function_with_comments_triple_slash_single_line_twin_normal_impl(port, ptr, rust_vec_len, data_len), -34 => wire__crate__api__comment__struct_with_comments_twin_normal_instance_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -35 => wire__crate__api__comment__struct_with_comments_twin_normal_static_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -38 => wire__crate__api__constructor__ConstructorOpaqueStructTwinNormal_new_impl(port, ptr, rust_vec_len, data_len), -44 => wire__crate__api__constructor__constructor_translatable_struct_twin_normal_new_impl(port, ptr, rust_vec_len, data_len), -46 => wire__crate__api__customization__check_init_done_impl(port, ptr, rust_vec_len, data_len), -47 => wire__crate__api__customization__init_app_impl(port, ptr, rust_vec_len, data_len), -48 => wire__crate__api__customization__my_init_one_impl(port, ptr, rust_vec_len, data_len), -49 => wire__crate__api__customization__my_init_two_impl(port, ptr, rust_vec_len, data_len), -50 => wire__crate__api__dart_code__OpaqueStructWithDartCodeTwinNormal_normal_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -51 => wire__crate__api__dart_code__translatable_struct_with_dart_code_twin_normal_normal_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -52 => wire__crate__api__dart_fn__rust_call_dart_loopback_twin_normal_impl(port, ptr, rust_vec_len, data_len), -53 => wire__crate__api__dart_fn__rust_call_dart_multi_times_twin_normal_impl(port, ptr, rust_vec_len, data_len), -54 => wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -55 => wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), -56 => wire__crate__api__dart_fn__rust_call_dart_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -57 => wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl(port, ptr, rust_vec_len, data_len), -58 => wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal_impl(port, ptr, rust_vec_len, data_len), -59 => wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -60 => wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), -61 => wire__crate__api__dart_opaque__async_accept_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -62 => wire__crate__api__dart_opaque__clone_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -63 => wire__crate__api__dart_opaque__create_enum_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -64 => wire__crate__api__dart_opaque__create_nested_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -65 => wire__crate__api__dart_opaque__drop_static_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -66 => wire__crate__api__dart_opaque__get_enum_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -67 => wire__crate__api__dart_opaque__get_nested_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -68 => wire__crate__api__dart_opaque__loop_back_array_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), -69 => wire__crate__api__dart_opaque__loop_back_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), -70 => wire__crate__api__dart_opaque__loop_back_option_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), -71 => wire__crate__api__dart_opaque__loop_back_option_twin_normal_impl(port, ptr, rust_vec_len, data_len), -72 => wire__crate__api__dart_opaque__loop_back_twin_normal_impl(port, ptr, rust_vec_len, data_len), -73 => wire__crate__api__dart_opaque__loop_back_vec_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), -74 => wire__crate__api__dart_opaque__loop_back_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), -75 => wire__crate__api__dart_opaque__panic_unwrap_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -76 => wire__crate__api__dart_opaque__set_static_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -82 => 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), -85 => wire__crate__api__dropping__DroppableTwinNormal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), -86 => wire__crate__api__dropping__DroppableTwinNormal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -87 => wire__crate__api__dyn_trait__StructOneWithTraitForDynTwinNormal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), -90 => wire__crate__api__dyn_trait__StructOneWithTraitForDynTwinNormal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -91 => wire__crate__api__dyn_trait__StructTwoWithTraitForDynTwinNormal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), -94 => wire__crate__api__dyn_trait__StructTwoWithTraitForDynTwinNormal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -96 => wire__crate__api__dyn_trait__func_arg_dyn_trait_twin_normal_impl(port, ptr, rust_vec_len, data_len), -97 => wire__crate__api__enumeration__func_enum_simple_twin_normal_impl(port, ptr, rust_vec_len, data_len), -98 => wire__crate__api__enumeration__func_enum_with_discriminant_twin_normal_impl(port, ptr, rust_vec_len, data_len), -99 => wire__crate__api__enumeration__func_enum_with_item_mixed_twin_normal_impl(port, ptr, rust_vec_len, data_len), -100 => wire__crate__api__enumeration__func_enum_with_item_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -101 => wire__crate__api__enumeration__func_enum_with_item_tuple_twin_normal_impl(port, ptr, rust_vec_len, data_len), -102 => wire__crate__api__enumeration__handle_enum_parameter_twin_normal_impl(port, ptr, rust_vec_len, data_len), -103 => wire__crate__api__enumeration__handle_enum_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -104 => wire__crate__api__enumeration__handle_return_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -105 => wire__crate__api__enumeration__multiply_by_ten_twin_normal_impl(port, ptr, rust_vec_len, data_len), -106 => wire__crate__api__enumeration__print_note_twin_normal_impl(port, ptr, rust_vec_len, data_len), -107 => wire__crate__api__event_listener__close_event_listener_twin_normal_impl(port, ptr, rust_vec_len, data_len), -109 => wire__crate__api__event_listener__create_event_twin_normal_impl(port, ptr, rust_vec_len, data_len), -110 => wire__crate__api__event_listener__event_twin_normal_as_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -111 => wire__crate__api__event_listener__register_event_listener_twin_normal_impl(port, ptr, rust_vec_len, data_len), -112 => wire__crate__api__exception__custom_enum_error_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -113 => wire__crate__api__exception__custom_enum_error_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -114 => wire__crate__api__exception__custom_enum_error_return_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), -115 => wire__crate__api__exception__custom_nested_error_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -116 => wire__crate__api__exception__custom_struct_error_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -117 => wire__crate__api__exception__custom_struct_twin_normal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), -118 => wire__crate__api__exception__custom_struct_twin_normal_nonstatic_return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -119 => wire__crate__api__exception__custom_struct_twin_normal_nonstatic_return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), -120 => wire__crate__api__exception__custom_struct_twin_normal_static_return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -121 => wire__crate__api__exception__custom_struct_twin_normal_static_return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), -122 => wire__crate__api__exception__func_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -123 => wire__crate__api__exception__func_type_fallible_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -124 => wire__crate__api__exception__func_type_infallible_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -125 => wire__crate__api__exception__panic_with_custom_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), -126 => wire__crate__api__exception__return_custom_nested_error_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), -127 => wire__crate__api__exception__return_custom_nested_error_1_variant1_twin_normal_impl(port, ptr, rust_vec_len, data_len), -128 => wire__crate__api__exception__return_custom_nested_error_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), -129 => wire__crate__api__exception__return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -130 => wire__crate__api__exception__return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), -131 => wire__crate__api__exception__return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -132 => wire__crate__api__exception__return_error_variant_twin_normal_impl(port, ptr, rust_vec_len, data_len), -133 => wire__crate__api__exception__return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -134 => wire__crate__api__exception__some_struct_twin_normal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), -135 => wire__crate__api__exception__some_struct_twin_normal_non_static_return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -136 => wire__crate__api__exception__some_struct_twin_normal_non_static_return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -137 => wire__crate__api__exception__some_struct_twin_normal_static_return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -138 => wire__crate__api__exception__some_struct_twin_normal_static_return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -139 => wire__crate__api__exception__stream_sink_throw_anyhow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -140 => wire__crate__api__exception__throw_anyhow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -141 => wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method_impl(port, ptr, rust_vec_len, data_len), -142 => wire__crate__api__external_type_in_crate__call_new_module_system_twin_normal_impl(port, ptr, rust_vec_len, data_len), -143 => wire__crate__api__external_type_in_crate__call_old_module_system_twin_normal_impl(port, ptr, rust_vec_len, data_len), -144 => wire__crate__api__external_type_in_crate__use_imported_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -145 => wire__crate__api__external_type_in_crate__use_imported_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -148 => wire__crate__api__impl_trait__StructOneWithTraitTwinNormal_simple_trait_fn_receiver_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -149 => wire__crate__api__impl_trait__StructOneWithTraitTwinNormal_simple_trait_fn_twin_normal_impl(port, ptr, rust_vec_len, data_len), -150 => wire__crate__api__impl_trait__StructOneWithTraitTwinNormal_simple_trait_fn_with_default_impl_twin_normal_impl(port, ptr, rust_vec_len, data_len), -153 => wire__crate__api__impl_trait__StructTwoWithTraitTwinNormal_simple_trait_fn_receiver_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -154 => wire__crate__api__impl_trait__StructTwoWithTraitTwinNormal_simple_trait_fn_twin_normal_impl(port, ptr, rust_vec_len, data_len), -155 => wire__crate__api__impl_trait__StructTwoWithTraitTwinNormal_simple_trait_fn_with_default_impl_twin_normal_impl(port, ptr, rust_vec_len, data_len), -159 => wire__crate__api__inside_macro__another_macro_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -160 => wire__crate__api__inside_macro__func_macro_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -161 => wire__crate__api__map_and_set__func_hash_map_i32_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -162 => wire__crate__api__map_and_set__func_hash_map_string_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -163 => wire__crate__api__map_and_set__func_hash_map_string_complex_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -164 => wire__crate__api__map_and_set__func_hash_map_string_simple_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -165 => wire__crate__api__map_and_set__func_hash_map_string_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -166 => wire__crate__api__map_and_set__func_hash_map_string_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -167 => wire__crate__api__map_and_set__func_hash_set_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -168 => wire__crate__api__map_and_set__func_hash_set_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -169 => wire__crate__api__method__StaticGetterOnlyTwinNormal_static_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), -170 => wire__crate__api__method__concatenate_with_twin_normal_concatenate_static_twin_normal_impl(port, ptr, rust_vec_len, data_len), -171 => wire__crate__api__method__concatenate_with_twin_normal_concatenate_twin_normal_impl(port, ptr, rust_vec_len, data_len), -172 => 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), -173 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_static_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), -174 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_stream_sink_at_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), -175 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), -176 => wire__crate__api__method__concatenate_with_twin_normal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), -177 => wire__crate__api__method__concatenate_with_twin_normal_simple_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), -178 => wire__crate__api__method__get_sum_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), -179 => wire__crate__api__method__get_sum_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -180 => wire__crate__api__method__my_callable_twin_normal_call_impl(port, ptr, rust_vec_len, data_len), -181 => wire__crate__api__method__simple_enum_twin_normal_return_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), -182 => wire__crate__api__method__simple_enum_twin_normal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -183 => wire__crate__api__method__simple_primitive_enum_twin_normal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -184 => wire__crate__api__method__simple_struct_twin_normal_arg_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), -185 => wire__crate__api__method__simple_struct_twin_normal_receiver_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -186 => wire__crate__api__method__simple_struct_twin_normal_receiver_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -187 => wire__crate__api__method__simple_struct_twin_normal_return_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), -188 => wire__crate__api__method__simple_struct_twin_normal_vec_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), -189 => wire__crate__api__method__static_only_twin_normal_static_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -190 => wire__crate__api__method__sum_with_twin_normal_sum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -191 => wire__crate__api__mirror__app_settings_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -192 => wire__crate__api__mirror__app_settings_vec_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -193 => wire__crate__api__mirror__first_number_twin_normal_impl(port, ptr, rust_vec_len, data_len), -194 => wire__crate__api__mirror__first_sequence_twin_normal_impl(port, ptr, rust_vec_len, data_len), -195 => wire__crate__api__mirror__get_app_settings_twin_normal_impl(port, ptr, rust_vec_len, data_len), -196 => wire__crate__api__mirror__get_fallible_app_settings_twin_normal_impl(port, ptr, rust_vec_len, data_len), -197 => wire__crate__api__mirror__get_message_twin_normal_impl(port, ptr, rust_vec_len, data_len), -198 => wire__crate__api__mirror__is_app_embedded_twin_normal_impl(port, ptr, rust_vec_len, data_len), -199 => wire__crate__api__mirror__mirror_array_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -200 => wire__crate__api__mirror__mirror_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -201 => wire__crate__api__mirror__mirror_map_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -202 => wire__crate__api__mirror__mirror_option_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -203 => wire__crate__api__mirror__mirror_set_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -204 => wire__crate__api__mirror__mirror_struct_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -205 => wire__crate__api__mirror__mirror_tuple_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -206 => wire__crate__api__mirror__mirror_vec_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), -207 => wire__crate__api__mirror__repeat_number_twin_normal_impl(port, ptr, rust_vec_len, data_len), -208 => wire__crate__api__mirror__repeat_sequence_twin_normal_impl(port, ptr, rust_vec_len, data_len), -209 => wire__crate__api__mirror__test_contains_mirrored_sub_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -210 => wire__crate__api__mirror__test_fallible_of_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -211 => wire__crate__api__mirror__test_hashmap_with_mirrored_value_twin_normal_impl(port, ptr, rust_vec_len, data_len), -212 => wire__crate__api__mirror__test_list_of_nested_enums_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -213 => wire__crate__api__mirror__test_list_of_raw_nested_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -214 => wire__crate__api__mirror__test_nested_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -215 => wire__crate__api__mirror__test_raw_string_enum_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -216 => wire__crate__api__mirror__test_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), -217 => wire__crate__api__misc_example__handle_big_buffers_twin_normal_impl(port, ptr, rust_vec_len, data_len), -218 => wire__crate__api__misc_example__handle_char_twin_normal_impl(port, ptr, rust_vec_len, data_len), -219 => wire__crate__api__misc_example__handle_complex_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -220 => wire__crate__api__misc_example__handle_nested_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -221 => wire__crate__api__misc_example__handle_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -222 => wire__crate__api__misc_example__handle_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -223 => wire__crate__api__misc_example__handle_vec_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -224 => wire__crate__api__misc_example__list_of_primitive_enums_twin_normal_impl(port, ptr, rust_vec_len, data_len), -225 => wire__crate__api__misc_example__positional_arguments_twin_normal_impl(port, ptr, rust_vec_len, data_len), -226 => wire__crate__api__misc_example__test_abc_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -227 => wire__crate__api__misc_example__test_struct_with_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -228 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_dummy_function_twin_normal_impl(port, ptr, rust_vec_len, data_len), -241 => wire__crate__api__misc_no_twin_example_a__ItemContainerSolutionOneTwinNormal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), -242 => wire__crate__api__misc_no_twin_example_a__ItemContainerSolutionOneTwinNormal_get_item_contents_twin_normal_impl(port, ptr, rust_vec_len, data_len), -245 => wire__crate__api__misc_no_twin_example_a__StructInMiscNoTwinExampleA_sample_function_a_impl(port, ptr, rust_vec_len, data_len), -246 => wire__crate__api__misc_no_twin_example_a__StructWithImplBlockInMultiFile_method_in_a_impl(port, ptr, rust_vec_len, data_len), -247 => wire__crate__api__misc_no_twin_example_a__StructWithImplBlockInMultiFile_method_in_b_impl(port, ptr, rust_vec_len, data_len), -253 => wire__crate__api__misc_no_twin_example_a__function_with_arg_type_name_override_impl(port, ptr, rust_vec_len, data_len), -254 => wire__crate__api__misc_no_twin_example_a__function_with_custom_name_twin_normal_impl(port, ptr, rust_vec_len, data_len), -255 => wire__crate__api__misc_no_twin_example_a__item_container_solution_two_twin_normal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), -256 => wire__crate__api__misc_no_twin_example_a__item_container_solution_two_twin_normal_get_item_contents_twin_normal_impl(port, ptr, rust_vec_len, data_len), -257 => wire__crate__api__misc_no_twin_example_a__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), -259 => wire__crate__api__misc_no_twin_example_a__struct_with_impl_block_in_another_file_f_impl(port, ptr, rust_vec_len, data_len), -260 => 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), -261 => wire__crate__api__misc_no_twin_example_b__StructInMiscNoTwinExampleB_sample_function_b_impl(port, ptr, rust_vec_len, data_len), -262 => wire__crate__api__misc_no_twin_example_b__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), -263 => wire__crate__api__misc_type__empty_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -264 => wire__crate__api__misc_type__func_return_unit_twin_normal_impl(port, ptr, rust_vec_len, data_len), -265 => wire__crate__api__misc_type__handle_list_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -266 => wire__crate__api__misc_type__handle_string_list_twin_normal_impl(port, ptr, rust_vec_len, data_len), -267 => wire__crate__api__newtype_pattern__handle_newtype_twin_normal_impl(port, ptr, rust_vec_len, data_len), -268 => wire__crate__api__optional__handle_increment_boxed_optional_twin_normal_impl(port, ptr, rust_vec_len, data_len), -269 => wire__crate__api__optional__handle_option_box_arguments_twin_normal_impl(port, ptr, rust_vec_len, data_len), -270 => wire__crate__api__optional__handle_optional_increment_twin_normal_impl(port, ptr, rust_vec_len, data_len), -271 => wire__crate__api__optional__handle_optional_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -272 => wire__crate__api__optional__handle_optional_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -273 => wire__crate__api__optional__handle_vec_of_opts_twin_normal_impl(port, ptr, rust_vec_len, data_len), -274 => wire__crate__api__optional_primitive_misc__primitive_optional_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), -275 => wire__crate__api__ownership__borrow_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -276 => wire__crate__api__ownership__borrow_slice_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -277 => wire__crate__api__ownership__borrow_slice_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -278 => wire__crate__api__ownership__borrow_str_twin_normal_impl(port, ptr, rust_vec_len, data_len), -279 => wire__crate__api__ownership__borrow_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -280 => wire__crate__api__ownership__borrow_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -281 => wire__crate__api__primitive_list_misc__handle_vec_of_primitive_twin_normal_impl(port, ptr, rust_vec_len, data_len), -282 => wire__crate__api__primitive_misc__primitive_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), -283 => wire__crate__api__primitive_misc__primitive_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -284 => wire__crate__api__proxy__MyAudioParamTwinNormal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), -285 => wire__crate__api__proxy__MyAudioParamTwinNormal_my_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), -286 => wire__crate__api__proxy__MyNodeTwinNormal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), -289 => wire__crate__api__pseudo_manual__array_twin_rust_async__boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -290 => wire__crate__api__pseudo_manual__array_twin_rust_async__func_test_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -291 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -292 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_complex_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -293 => wire__crate__api__pseudo_manual__array_twin_rust_async__last_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -294 => wire__crate__api__pseudo_manual__array_twin_rust_async__nested_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -295 => wire__crate__api__pseudo_manual__array_twin_rust_async__new_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -296 => wire__crate__api__pseudo_manual__array_twin_rust_async__return_boxed_feed_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -297 => 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), -298 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -299 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -311 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__handle_customized_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -312 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__next_user_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -315 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -316 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -317 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), -318 => wire__crate__api__pseudo_manual__basic__example_basic_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -319 => wire__crate__api__pseudo_manual__basic__example_basic_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -320 => wire__crate__api__pseudo_manual__basic__example_basic_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -321 => wire__crate__api__pseudo_manual__basic__example_basic_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -322 => wire__crate__api__pseudo_manual__basic__example_basic_type_i128_twin_normal_impl(port, ptr, rust_vec_len, data_len), -323 => wire__crate__api__pseudo_manual__basic__example_basic_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -324 => wire__crate__api__pseudo_manual__basic__example_basic_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -325 => wire__crate__api__pseudo_manual__basic__example_basic_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -326 => wire__crate__api__pseudo_manual__basic__example_basic_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -327 => wire__crate__api__pseudo_manual__basic__example_basic_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -328 => wire__crate__api__pseudo_manual__basic__example_basic_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -329 => wire__crate__api__pseudo_manual__basic__example_basic_type_u128_twin_normal_impl(port, ptr, rust_vec_len, data_len), -330 => wire__crate__api__pseudo_manual__basic__example_basic_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -331 => wire__crate__api__pseudo_manual__basic__example_basic_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -332 => wire__crate__api__pseudo_manual__basic__example_basic_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -333 => wire__crate__api__pseudo_manual__basic__example_basic_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -334 => wire__crate__api__pseudo_manual__basic__example_basic_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -335 => 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), -336 => 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), -337 => 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), -338 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -339 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -340 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -341 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -342 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -343 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -344 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -345 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -346 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -347 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -348 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -349 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -350 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -351 => 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), -352 => 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), -353 => 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), -354 => 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), -355 => 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), -356 => 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), -357 => 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), -358 => 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), -359 => 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), -360 => 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), -361 => 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), -362 => 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), -363 => 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), -364 => 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), -365 => 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), -366 => 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), -383 => 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), -384 => 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), -385 => 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), -386 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -387 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -388 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -389 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -390 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i128_twin_normal_impl(port, ptr, rust_vec_len, data_len), -391 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -392 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -393 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -394 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -395 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -396 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -397 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u128_twin_normal_impl(port, ptr, rust_vec_len, data_len), -398 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -399 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -400 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -401 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -402 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -403 => 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), -404 => 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), -405 => 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), -406 => 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), -407 => 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), -408 => 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), -409 => 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), -410 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -411 => 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), -412 => 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), -413 => 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), -414 => 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), -415 => 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), -416 => 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), -417 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -418 => 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), -419 => 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), -420 => 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), -421 => 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), -422 => 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), -443 => 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), -444 => 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), -445 => 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), -446 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), -447 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -448 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -449 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -450 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i128_twin_normal_impl(port, ptr, rust_vec_len, data_len), -451 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -452 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -453 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -454 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -455 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -456 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), -457 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u128_twin_normal_impl(port, ptr, rust_vec_len, data_len), -458 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), -459 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), -460 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), -461 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), -462 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), -463 => 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), -464 => 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), -465 => 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), -466 => 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), -467 => 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), -468 => 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), -469 => 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), -470 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -471 => 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), -472 => 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), -473 => 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), -474 => 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), -475 => 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), -476 => 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), -477 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -478 => 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), -479 => 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), -480 => 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), -481 => 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), -482 => 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), -503 => 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), -504 => 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), -505 => 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), -506 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -507 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -508 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -509 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -510 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -511 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -512 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -513 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -514 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -515 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -516 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -517 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -518 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -519 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -520 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -521 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -522 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -543 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -544 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -545 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), -546 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -547 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -548 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), -549 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -550 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -551 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), -552 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), -553 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), -554 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), -555 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_input_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -556 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_output_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), -557 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_void_twin_normal_impl(port, ptr, rust_vec_len, data_len), -558 => 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), -559 => 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), -560 => 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), -561 => 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), -562 => 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), -563 => 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), -564 => 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), -565 => 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), -566 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -567 => 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), -568 => 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), -569 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -570 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_input_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -571 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_output_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -572 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_void_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -588 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_local_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -589 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_utc_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -590 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__duration_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -591 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_durations_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -592 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_timestamps_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -593 => 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), -594 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__naivedatetime_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -595 => 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), -596 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -597 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_precise_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -608 => 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), -609 => 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), -610 => 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), -611 => 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), -612 => 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), -618 => 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), -619 => 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), -620 => 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), -621 => 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), -622 => 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), -623 => 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), -624 => 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), -625 => 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), -626 => 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), -627 => 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), -628 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__clone_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -629 => 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), -630 => 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), -631 => 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), -632 => 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), -633 => 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), -634 => 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), -635 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -636 => 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), -637 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_option_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -638 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -639 => 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), -640 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -641 => 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), -642 => 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), -659 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_create_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -660 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_get_drop_count_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -661 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -662 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -667 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_simple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -668 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_discriminant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -669 => 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), -670 => 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), -671 => 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), -672 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_parameter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -673 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -674 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_return_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -675 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__multiply_by_ten_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -676 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__print_note_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -687 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__close_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -688 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__create_event_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -689 => 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), -690 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__register_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -691 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -692 => 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), -693 => 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), -694 => 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), -695 => 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), -696 => 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), -697 => 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), -698 => 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), -699 => 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), -700 => 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), -701 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -702 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_fallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -703 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_infallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -704 => wire__crate__api__pseudo_manual__exception_twin_rust_async__panic_with_custom_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -705 => 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), -706 => 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), -707 => 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), -708 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -709 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -710 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -711 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_error_variant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -712 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -713 => 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), -714 => 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), -715 => 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), -716 => 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), -717 => 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), -718 => wire__crate__api__pseudo_manual__exception_twin_rust_async__stream_sink_throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -719 => wire__crate__api__pseudo_manual__exception_twin_rust_async__throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -749 => 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), -750 => 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), -751 => 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), -752 => 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), -759 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructOneWithTraitTwinSync_simple_trait_fn_receiver_borrow_twin_sync_impl(port, ptr, rust_vec_len, data_len), -760 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructOneWithTraitTwinSync_simple_trait_fn_twin_sync_impl(port, ptr, rust_vec_len, data_len), -761 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructOneWithTraitTwinSync_simple_trait_fn_with_default_impl_twin_sync_impl(port, ptr, rust_vec_len, data_len), -764 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructTwoWithTraitTwinSync_simple_trait_fn_receiver_borrow_twin_sync_impl(port, ptr, rust_vec_len, data_len), -765 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructTwoWithTraitTwinSync_simple_trait_fn_twin_sync_impl(port, ptr, rust_vec_len, data_len), -766 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructTwoWithTraitTwinSync_simple_trait_fn_with_default_impl_twin_sync_impl(port, ptr, rust_vec_len, data_len), -770 => 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), -771 => 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), -772 => 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), -773 => 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), -774 => 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), -775 => 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), -776 => 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), -777 => 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), -786 => wire__crate__api__pseudo_manual__method_twin_rust_async__StaticGetterOnlyTwinRustAsync_static_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -787 => 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), -788 => 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), -789 => 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), -790 => 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), -791 => 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), -792 => 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), -793 => 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), -794 => 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), -795 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -796 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -797 => wire__crate__api__pseudo_manual__method_twin_rust_async__my_callable_twin_rust_async_call_impl(port, ptr, rust_vec_len, data_len), -798 => 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), -799 => 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), -800 => 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), -801 => 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), -802 => 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), -803 => 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), -804 => 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), -805 => 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), -806 => 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), -807 => 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), -830 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -831 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_vec_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -832 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -833 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -834 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -835 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_fallible_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -836 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_message_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -837 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__is_app_embedded_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -838 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_array_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -839 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -840 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_map_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -841 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_option_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -842 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_set_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -843 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_struct_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -844 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_tuple_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -845 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_vec_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -846 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -847 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -848 => 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), -849 => 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), -850 => 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), -851 => 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), -852 => 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), -853 => 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), -854 => 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), -855 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -882 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_big_buffers_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -883 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_char_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -884 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_complex_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -885 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_nested_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -886 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -887 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -888 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_vec_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -889 => 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), -890 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__positional_arguments_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -891 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__test_abc_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -892 => 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), -904 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__empty_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -905 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__func_return_unit_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -906 => 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), -907 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__handle_string_list_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -912 => wire__crate__api__pseudo_manual__newtype_pattern_twin_rust_async__handle_newtype_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -914 => 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), -916 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_increment_boxed_optional_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -917 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_option_box_arguments_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -918 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_increment_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -919 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -920 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -921 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_vec_of_opts_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -928 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -929 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_slice_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -930 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_slice_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -931 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_str_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -932 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -933 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -940 => 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), -942 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_types_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -943 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -946 => 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), -947 => 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), -950 => 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), -951 => 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), -952 => 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), -953 => 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), -954 => 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), -955 => 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), -956 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -957 => 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), -958 => 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), -959 => 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), -960 => 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), -961 => 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), -965 => 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), -966 => 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), -967 => 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), -968 => 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), -969 => 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), -970 => 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), -971 => 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), -972 => 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), -973 => 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), -974 => 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), -975 => 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), -976 => 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), -977 => 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), -978 => 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), -979 => 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), -980 => 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), -981 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_return_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -982 => 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), -983 => 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), -984 => 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), -985 => 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), -986 => 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), -987 => 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), -988 => 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), -989 => 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), -990 => 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), -991 => 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), -992 => 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), -993 => 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), -994 => 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), -995 => 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), -1042 => 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), -1043 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1044 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1045 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_option_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1046 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__frb_generator_test_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1047 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1048 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1049 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1050 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1051 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_enum_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1052 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1053 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_non_clone_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1054 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1055 => 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), -1056 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__unwrap_rust_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1072 => wire__crate__api__pseudo_manual__simple_twin_rust_async__simple_adder_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1074 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_add_value_and_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1075 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1076 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1077 => 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), -1078 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_of_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1079 => 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), -1080 => 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), -1081 => 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), -1082 => 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), -1083 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1084 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1085 => 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), -1086 => 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), -1087 => 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), -1088 => 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), -1089 => 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), -1095 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1096 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1099 => 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), -1100 => 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), -1101 => 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), -1105 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_nested_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1106 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1107 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), -1111 => wire__crate__api__raw_string__test_more_than_just_one_raw_string_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1112 => wire__crate__api__raw_string__test_raw_string_item_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1113 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1114 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1115 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1116 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1117 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1118 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_custom_name_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1119 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1120 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_with_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1121 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1122 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1123 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1124 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1128 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1129 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1130 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_and_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1131 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1132 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1133 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1134 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1135 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1136 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1137 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_dummy_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1138 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1139 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1140 => 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), -1141 => 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), -1142 => 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), -1143 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1144 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_return_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1145 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1146 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1147 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_normal_and_opaque_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1148 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1149 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1150 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_one_and_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1151 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1152 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1153 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1154 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_sleep_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1155 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1156 => 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), -1157 => 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), -1158 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_two_args_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1159 => wire__crate__api__rust_opaque__create_array_opaque_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1160 => wire__crate__api__rust_opaque__create_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1161 => wire__crate__api__rust_opaque__create_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1162 => wire__crate__api__rust_opaque__create_option_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1163 => wire__crate__api__rust_opaque__frb_generator_test_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1164 => wire__crate__api__rust_opaque__opaque_array_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1165 => wire__crate__api__rust_opaque__opaque_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1166 => wire__crate__api__rust_opaque__opaque_vec_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1167 => wire__crate__api__rust_opaque__opaque_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1168 => wire__crate__api__rust_opaque__run_enum_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1169 => wire__crate__api__rust_opaque__run_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1170 => wire__crate__api__rust_opaque__run_non_clone_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1171 => wire__crate__api__rust_opaque__run_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1172 => wire__crate__api__rust_opaque__run_opaque_with_delay_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1173 => wire__crate__api__rust_opaque__unwrap_rust_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1178 => wire__crate__api__simple__simple_adder_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1179 => wire__crate__api__stream__func_stream_add_value_and_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1180 => wire__crate__api__stream__func_stream_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1181 => wire__crate__api__stream__func_stream_return_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1182 => wire__crate__api__stream__func_stream_sink_arg_position_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1183 => wire__crate__api__stream__handle_stream_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1184 => wire__crate__api__stream__handle_stream_sink_at_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1185 => wire__crate__api__stream__handle_stream_sink_at_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1186 => wire__crate__api__stream__handle_stream_sink_at_3_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1187 => wire__crate__api__stream__stream_sink_fixed_sized_primitive_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1188 => wire__crate__api__stream__stream_sink_inside_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1189 => wire__crate__api__stream__stream_sink_inside_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1190 => wire__crate__api__stream_misc__func_stream_realistic_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1191 => wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1192 => wire__crate__api__structure__func_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1193 => wire__crate__api__structure__func_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1194 => wire__crate__api__structure__func_struct_with_zero_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1195 => wire__crate__api__structure__func_tuple_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1196 => wire__crate__api__structure__func_tuple_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1197 => wire__crate__api__tuple__test_tuple_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1198 => wire__crate__api__tuple__test_tuple_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1199 => wire__crate__api__type_alias__handle_type_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1200 => wire__crate__api__type_alias__handle_type_alias_model_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1201 => wire__crate__api__type_alias__handle_type_nest_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1202 => wire__crate__api__uuid_type__handle_nested_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1203 => wire__crate__api__uuid_type__handle_uuid_twin_normal_impl(port, ptr, rust_vec_len, data_len), -1204 => wire__crate__api__uuid_type__handle_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), +21 => wire__crate__api__casted_primitive__casted_primitive_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +22 => wire__crate__api__casted_primitive__casted_primitive_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +23 => wire__crate__api__casted_primitive__casted_primitive_multi_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +24 => wire__crate__api__casted_primitive__casted_primitive_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +25 => wire__crate__api__casted_primitive__casted_primitive_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +26 => wire__crate__api__casted_primitive__function_for_struct_with_casted_primitive_twin_normal_impl(port, ptr, rust_vec_len, data_len), +27 => wire__crate__api__chrono_type__datetime_local_twin_normal_impl(port, ptr, rust_vec_len, data_len), +28 => wire__crate__api__chrono_type__datetime_utc_twin_normal_impl(port, ptr, rust_vec_len, data_len), +29 => wire__crate__api__chrono_type__duration_twin_normal_impl(port, ptr, rust_vec_len, data_len), +30 => wire__crate__api__chrono_type__handle_durations_twin_normal_impl(port, ptr, rust_vec_len, data_len), +31 => wire__crate__api__chrono_type__handle_timestamps_twin_normal_impl(port, ptr, rust_vec_len, data_len), +32 => wire__crate__api__chrono_type__how_long_does_it_take_twin_normal_impl(port, ptr, rust_vec_len, data_len), +33 => wire__crate__api__chrono_type__naivedatetime_twin_normal_impl(port, ptr, rust_vec_len, data_len), +34 => wire__crate__api__chrono_type__optional_empty_datetime_utc_twin_normal_impl(port, ptr, rust_vec_len, data_len), +35 => wire__crate__api__chrono_type__test_chrono_twin_normal_impl(port, ptr, rust_vec_len, data_len), +36 => wire__crate__api__chrono_type__test_precise_chrono_twin_normal_impl(port, ptr, rust_vec_len, data_len), +37 => wire__crate__api__comment__function_with_comments_slash_star_star_twin_normal_impl(port, ptr, rust_vec_len, data_len), +38 => wire__crate__api__comment__function_with_comments_triple_slash_multi_line_twin_normal_impl(port, ptr, rust_vec_len, data_len), +39 => wire__crate__api__comment__function_with_comments_triple_slash_single_line_twin_normal_impl(port, ptr, rust_vec_len, data_len), +40 => wire__crate__api__comment__struct_with_comments_twin_normal_instance_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +41 => wire__crate__api__comment__struct_with_comments_twin_normal_static_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +44 => wire__crate__api__constructor__ConstructorOpaqueStructTwinNormal_new_impl(port, ptr, rust_vec_len, data_len), +50 => wire__crate__api__constructor__constructor_translatable_struct_twin_normal_new_impl(port, ptr, rust_vec_len, data_len), +52 => wire__crate__api__custom_ser_des__function_using_type_with_custom_serializer_impl(port, ptr, rust_vec_len, data_len), +53 => wire__crate__api__customization__check_init_done_impl(port, ptr, rust_vec_len, data_len), +54 => wire__crate__api__customization__init_app_impl(port, ptr, rust_vec_len, data_len), +55 => wire__crate__api__customization__my_init_one_impl(port, ptr, rust_vec_len, data_len), +56 => wire__crate__api__customization__my_init_two_impl(port, ptr, rust_vec_len, data_len), +57 => wire__crate__api__dart_code__OpaqueStructWithDartCodeTwinNormal_normal_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +58 => wire__crate__api__dart_code__translatable_struct_with_dart_code_twin_normal_normal_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +59 => wire__crate__api__dart_fn__rust_call_dart_loopback_twin_normal_impl(port, ptr, rust_vec_len, data_len), +60 => wire__crate__api__dart_fn__rust_call_dart_multi_times_twin_normal_impl(port, ptr, rust_vec_len, data_len), +61 => wire__crate__api__dart_fn__rust_call_dart_one_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +62 => wire__crate__api__dart_fn__rust_call_dart_return_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), +63 => wire__crate__api__dart_fn__rust_call_dart_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +64 => wire__crate__api__dart_fn__rust_call_dart_simple_twin_normal_impl(port, ptr, rust_vec_len, data_len), +65 => wire__crate__api__dart_fn__rust_call_dart_two_args_twin_normal_impl(port, ptr, rust_vec_len, data_len), +66 => wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +67 => wire__crate__api__dart_fn__rust_call_dart_with_dart_opaque_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), +68 => wire__crate__api__dart_opaque__async_accept_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +69 => 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), +71 => 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), +73 => wire__crate__api__dart_opaque__get_enum_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +74 => wire__crate__api__dart_opaque__get_nested_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +75 => wire__crate__api__dart_opaque__loop_back_array_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), +76 => wire__crate__api__dart_opaque__loop_back_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), +77 => wire__crate__api__dart_opaque__loop_back_option_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), +78 => wire__crate__api__dart_opaque__loop_back_option_twin_normal_impl(port, ptr, rust_vec_len, data_len), +79 => wire__crate__api__dart_opaque__loop_back_twin_normal_impl(port, ptr, rust_vec_len, data_len), +80 => wire__crate__api__dart_opaque__loop_back_vec_get_twin_normal_impl(port, ptr, rust_vec_len, data_len), +81 => wire__crate__api__dart_opaque__loop_back_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), +82 => wire__crate__api__dart_opaque__panic_unwrap_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +83 => wire__crate__api__dart_opaque__set_static_dart_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +89 => wire__crate__api__deliberate_name_conflict__test_duplicated_module_names_impl(port, ptr, rust_vec_len, data_len), +90 => wire__crate__api__dropping__DroppableTwinNormal_create_stream_impl(port, ptr, rust_vec_len, data_len), +91 => wire__crate__api__dropping__DroppableTwinNormal_get_drop_count_twin_normal_impl(port, ptr, rust_vec_len, data_len), +92 => wire__crate__api__dropping__DroppableTwinNormal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), +93 => wire__crate__api__dropping__DroppableTwinNormal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +94 => wire__crate__api__dyn_trait__StructOneWithTraitForDynTwinNormal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), +97 => wire__crate__api__dyn_trait__StructOneWithTraitForDynTwinNormal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +98 => wire__crate__api__dyn_trait__StructTwoWithTraitForDynTwinNormal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), +101 => wire__crate__api__dyn_trait__StructTwoWithTraitForDynTwinNormal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +103 => wire__crate__api__dyn_trait__func_arg_dyn_trait_twin_normal_impl(port, ptr, rust_vec_len, data_len), +104 => wire__crate__api__enumeration__func_enum_simple_twin_normal_impl(port, ptr, rust_vec_len, data_len), +105 => wire__crate__api__enumeration__func_enum_with_discriminant_twin_normal_impl(port, ptr, rust_vec_len, data_len), +106 => wire__crate__api__enumeration__func_enum_with_item_mixed_twin_normal_impl(port, ptr, rust_vec_len, data_len), +107 => wire__crate__api__enumeration__func_enum_with_item_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +108 => wire__crate__api__enumeration__func_enum_with_item_tuple_twin_normal_impl(port, ptr, rust_vec_len, data_len), +109 => wire__crate__api__enumeration__handle_enum_parameter_twin_normal_impl(port, ptr, rust_vec_len, data_len), +110 => wire__crate__api__enumeration__handle_enum_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +111 => wire__crate__api__enumeration__handle_return_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +112 => wire__crate__api__enumeration__multiply_by_ten_twin_normal_impl(port, ptr, rust_vec_len, data_len), +113 => wire__crate__api__enumeration__print_note_twin_normal_impl(port, ptr, rust_vec_len, data_len), +114 => wire__crate__api__event_listener__close_event_listener_twin_normal_impl(port, ptr, rust_vec_len, data_len), +116 => wire__crate__api__event_listener__create_event_twin_normal_impl(port, ptr, rust_vec_len, data_len), +117 => wire__crate__api__event_listener__event_twin_normal_as_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +118 => wire__crate__api__event_listener__register_event_listener_twin_normal_impl(port, ptr, rust_vec_len, data_len), +119 => wire__crate__api__exception__custom_enum_error_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +120 => wire__crate__api__exception__custom_enum_error_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +121 => wire__crate__api__exception__custom_enum_error_return_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), +122 => wire__crate__api__exception__custom_nested_error_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +123 => 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), +125 => wire__crate__api__exception__custom_struct_twin_normal_nonstatic_return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +126 => wire__crate__api__exception__custom_struct_twin_normal_nonstatic_return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), +127 => wire__crate__api__exception__custom_struct_twin_normal_static_return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +128 => wire__crate__api__exception__custom_struct_twin_normal_static_return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), +129 => wire__crate__api__exception__func_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +130 => wire__crate__api__exception__func_type_fallible_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +131 => wire__crate__api__exception__func_type_infallible_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +132 => wire__crate__api__exception__panic_with_custom_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), +133 => wire__crate__api__exception__return_custom_nested_error_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), +134 => wire__crate__api__exception__return_custom_nested_error_1_variant1_twin_normal_impl(port, ptr, rust_vec_len, data_len), +135 => wire__crate__api__exception__return_custom_nested_error_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), +136 => wire__crate__api__exception__return_custom_struct_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +137 => wire__crate__api__exception__return_custom_struct_ok_twin_normal_impl(port, ptr, rust_vec_len, data_len), +138 => wire__crate__api__exception__return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +139 => wire__crate__api__exception__return_error_variant_twin_normal_impl(port, ptr, rust_vec_len, data_len), +140 => wire__crate__api__exception__return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +141 => wire__crate__api__exception__some_struct_twin_normal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), +142 => wire__crate__api__exception__some_struct_twin_normal_non_static_return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +143 => wire__crate__api__exception__some_struct_twin_normal_non_static_return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +144 => wire__crate__api__exception__some_struct_twin_normal_static_return_err_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +145 => wire__crate__api__exception__some_struct_twin_normal_static_return_ok_custom_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +146 => wire__crate__api__exception__stream_sink_throw_anyhow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +147 => wire__crate__api__exception__throw_anyhow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +149 => wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_simple_external_method_impl(port, ptr, rust_vec_len, data_len), +150 => wire__crate__api__external_impl__simple_translatable_external_struct_with_method_simple_external_method_impl(port, ptr, rust_vec_len, data_len), +151 => wire__crate__api__external_type_in_crate__call_new_module_system_twin_normal_impl(port, ptr, rust_vec_len, data_len), +152 => wire__crate__api__external_type_in_crate__call_old_module_system_twin_normal_impl(port, ptr, rust_vec_len, data_len), +153 => wire__crate__api__external_type_in_crate__use_imported_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +154 => wire__crate__api__external_type_in_crate__use_imported_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +157 => wire__crate__api__impl_trait__StructOneWithTraitTwinNormal_simple_trait_fn_receiver_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +158 => wire__crate__api__impl_trait__StructOneWithTraitTwinNormal_simple_trait_fn_twin_normal_impl(port, ptr, rust_vec_len, data_len), +159 => wire__crate__api__impl_trait__StructOneWithTraitTwinNormal_simple_trait_fn_with_default_impl_twin_normal_impl(port, ptr, rust_vec_len, data_len), +162 => wire__crate__api__impl_trait__StructTwoWithTraitTwinNormal_simple_trait_fn_receiver_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +163 => wire__crate__api__impl_trait__StructTwoWithTraitTwinNormal_simple_trait_fn_twin_normal_impl(port, ptr, rust_vec_len, data_len), +164 => wire__crate__api__impl_trait__StructTwoWithTraitTwinNormal_simple_trait_fn_with_default_impl_twin_normal_impl(port, ptr, rust_vec_len, data_len), +168 => wire__crate__api__inside_macro__another_macro_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +169 => wire__crate__api__inside_macro__func_macro_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +170 => wire__crate__api__map_and_set__func_hash_map_i32_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +171 => wire__crate__api__map_and_set__func_hash_map_string_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +172 => wire__crate__api__map_and_set__func_hash_map_string_complex_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +173 => wire__crate__api__map_and_set__func_hash_map_string_simple_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +174 => wire__crate__api__map_and_set__func_hash_map_string_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +175 => wire__crate__api__map_and_set__func_hash_map_string_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +176 => wire__crate__api__map_and_set__func_hash_set_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +177 => wire__crate__api__map_and_set__func_hash_set_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +178 => wire__crate__api__method__StaticGetterOnlyTwinNormal_static_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), +179 => wire__crate__api__method__concatenate_with_twin_normal_concatenate_static_twin_normal_impl(port, ptr, rust_vec_len, data_len), +180 => wire__crate__api__method__concatenate_with_twin_normal_concatenate_twin_normal_impl(port, ptr, rust_vec_len, data_len), +181 => 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), +182 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_static_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), +183 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_stream_sink_at_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), +184 => wire__crate__api__method__concatenate_with_twin_normal_handle_some_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), +185 => wire__crate__api__method__concatenate_with_twin_normal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), +186 => wire__crate__api__method__concatenate_with_twin_normal_simple_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), +187 => wire__crate__api__method__get_sum_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), +188 => wire__crate__api__method__get_sum_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +189 => wire__crate__api__method__my_callable_twin_normal_call_impl(port, ptr, rust_vec_len, data_len), +190 => wire__crate__api__method__simple_enum_twin_normal_return_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), +191 => wire__crate__api__method__simple_enum_twin_normal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +192 => wire__crate__api__method__simple_primitive_enum_twin_normal_simple_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +193 => wire__crate__api__method__simple_struct_twin_normal_arg_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), +194 => wire__crate__api__method__simple_struct_twin_normal_receiver_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +195 => wire__crate__api__method__simple_struct_twin_normal_receiver_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +196 => wire__crate__api__method__simple_struct_twin_normal_return_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), +197 => wire__crate__api__method__simple_struct_twin_normal_vec_self_twin_normal_impl(port, ptr, rust_vec_len, data_len), +198 => wire__crate__api__method__static_only_twin_normal_static_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +199 => wire__crate__api__method__sum_with_twin_normal_sum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +200 => wire__crate__api__mirror__app_settings_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +201 => wire__crate__api__mirror__app_settings_vec_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +202 => wire__crate__api__mirror__first_number_twin_normal_impl(port, ptr, rust_vec_len, data_len), +203 => wire__crate__api__mirror__first_sequence_twin_normal_impl(port, ptr, rust_vec_len, data_len), +204 => wire__crate__api__mirror__get_app_settings_twin_normal_impl(port, ptr, rust_vec_len, data_len), +205 => wire__crate__api__mirror__get_fallible_app_settings_twin_normal_impl(port, ptr, rust_vec_len, data_len), +206 => wire__crate__api__mirror__get_message_twin_normal_impl(port, ptr, rust_vec_len, data_len), +207 => wire__crate__api__mirror__is_app_embedded_twin_normal_impl(port, ptr, rust_vec_len, data_len), +208 => wire__crate__api__mirror__mirror_array_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +209 => wire__crate__api__mirror__mirror_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +210 => wire__crate__api__mirror__mirror_map_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +211 => wire__crate__api__mirror__mirror_option_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +212 => wire__crate__api__mirror__mirror_set_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +213 => wire__crate__api__mirror__mirror_struct_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +214 => wire__crate__api__mirror__mirror_tuple_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +215 => wire__crate__api__mirror__mirror_vec_enum_stream_twin_normal_impl(port, ptr, rust_vec_len, data_len), +216 => wire__crate__api__mirror__repeat_number_twin_normal_impl(port, ptr, rust_vec_len, data_len), +217 => wire__crate__api__mirror__repeat_sequence_twin_normal_impl(port, ptr, rust_vec_len, data_len), +218 => wire__crate__api__mirror__test_contains_mirrored_sub_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +219 => wire__crate__api__mirror__test_fallible_of_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +220 => wire__crate__api__mirror__test_hashmap_with_mirrored_value_twin_normal_impl(port, ptr, rust_vec_len, data_len), +221 => wire__crate__api__mirror__test_list_of_nested_enums_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +222 => wire__crate__api__mirror__test_list_of_raw_nested_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +223 => wire__crate__api__mirror__test_nested_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +224 => wire__crate__api__mirror__test_raw_string_enum_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +225 => wire__crate__api__mirror__test_raw_string_mirrored_twin_normal_impl(port, ptr, rust_vec_len, data_len), +226 => wire__crate__api__misc_example__handle_big_buffers_twin_normal_impl(port, ptr, rust_vec_len, data_len), +227 => wire__crate__api__misc_example__handle_char_twin_normal_impl(port, ptr, rust_vec_len, data_len), +228 => wire__crate__api__misc_example__handle_complex_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +229 => wire__crate__api__misc_example__handle_nested_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +230 => wire__crate__api__misc_example__handle_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +231 => wire__crate__api__misc_example__handle_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +232 => wire__crate__api__misc_example__handle_vec_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +233 => wire__crate__api__misc_example__list_of_primitive_enums_twin_normal_impl(port, ptr, rust_vec_len, data_len), +234 => wire__crate__api__misc_example__positional_arguments_twin_normal_impl(port, ptr, rust_vec_len, data_len), +235 => wire__crate__api__misc_example__test_abc_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +236 => wire__crate__api__misc_example__test_struct_with_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +237 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_dummy_function_twin_normal_impl(port, ptr, rust_vec_len, data_len), +250 => wire__crate__api__misc_no_twin_example_a__ItemContainerSolutionOneTwinNormal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), +251 => wire__crate__api__misc_no_twin_example_a__ItemContainerSolutionOneTwinNormal_get_item_contents_twin_normal_impl(port, ptr, rust_vec_len, data_len), +254 => wire__crate__api__misc_no_twin_example_a__StructInMiscNoTwinExampleA_sample_function_a_impl(port, ptr, rust_vec_len, data_len), +255 => wire__crate__api__misc_no_twin_example_a__StructWithImplBlockInMultiFile_method_in_a_impl(port, ptr, rust_vec_len, data_len), +256 => wire__crate__api__misc_no_twin_example_a__StructWithImplBlockInMultiFile_method_in_b_impl(port, ptr, rust_vec_len, data_len), +262 => wire__crate__api__misc_no_twin_example_a__function_with_arg_type_name_override_impl(port, ptr, rust_vec_len, data_len), +263 => wire__crate__api__misc_no_twin_example_a__function_with_custom_name_twin_normal_impl(port, ptr, rust_vec_len, data_len), +264 => wire__crate__api__misc_no_twin_example_a__item_container_solution_two_twin_normal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), +265 => wire__crate__api__misc_no_twin_example_a__item_container_solution_two_twin_normal_get_item_contents_twin_normal_impl(port, ptr, rust_vec_len, data_len), +266 => wire__crate__api__misc_no_twin_example_a__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), +268 => wire__crate__api__misc_no_twin_example_a__struct_with_impl_block_in_another_file_f_impl(port, ptr, rust_vec_len, data_len), +269 => 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), +270 => wire__crate__api__misc_no_twin_example_b__StructInMiscNoTwinExampleB_sample_function_b_impl(port, ptr, rust_vec_len, data_len), +271 => wire__crate__api__misc_no_twin_example_b__same_function_name_in_different_files_impl(port, ptr, rust_vec_len, data_len), +272 => wire__crate__api__misc_type__empty_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +273 => wire__crate__api__misc_type__func_return_unit_twin_normal_impl(port, ptr, rust_vec_len, data_len), +274 => wire__crate__api__misc_type__handle_list_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +275 => wire__crate__api__misc_type__handle_string_list_twin_normal_impl(port, ptr, rust_vec_len, data_len), +276 => wire__crate__api__newtype_pattern__handle_newtype_twin_normal_impl(port, ptr, rust_vec_len, data_len), +277 => wire__crate__api__optional__handle_increment_boxed_optional_twin_normal_impl(port, ptr, rust_vec_len, data_len), +278 => wire__crate__api__optional__handle_option_box_arguments_twin_normal_impl(port, ptr, rust_vec_len, data_len), +279 => wire__crate__api__optional__handle_optional_increment_twin_normal_impl(port, ptr, rust_vec_len, data_len), +280 => wire__crate__api__optional__handle_optional_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +281 => wire__crate__api__optional__handle_optional_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +282 => wire__crate__api__optional__handle_vec_of_opts_twin_normal_impl(port, ptr, rust_vec_len, data_len), +283 => wire__crate__api__optional_primitive_misc__primitive_optional_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), +284 => wire__crate__api__ownership__borrow_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +285 => wire__crate__api__ownership__borrow_slice_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +286 => wire__crate__api__ownership__borrow_slice_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +287 => wire__crate__api__ownership__borrow_str_twin_normal_impl(port, ptr, rust_vec_len, data_len), +288 => wire__crate__api__ownership__borrow_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +289 => wire__crate__api__ownership__borrow_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +290 => wire__crate__api__primitive_list_misc__handle_vec_of_primitive_twin_normal_impl(port, ptr, rust_vec_len, data_len), +291 => wire__crate__api__primitive_misc__primitive_types_twin_normal_impl(port, ptr, rust_vec_len, data_len), +292 => wire__crate__api__primitive_misc__primitive_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +293 => wire__crate__api__proxy__MyAudioParamTwinNormal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), +294 => wire__crate__api__proxy__MyAudioParamTwinNormal_my_method_twin_normal_impl(port, ptr, rust_vec_len, data_len), +295 => wire__crate__api__proxy__MyNodeTwinNormal_create_twin_normal_impl(port, ptr, rust_vec_len, data_len), +298 => wire__crate__api__pseudo_manual__array_twin_rust_async__boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +299 => wire__crate__api__pseudo_manual__array_twin_rust_async__func_test_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +300 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +301 => wire__crate__api__pseudo_manual__array_twin_rust_async__get_complex_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +302 => wire__crate__api__pseudo_manual__array_twin_rust_async__last_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +303 => wire__crate__api__pseudo_manual__array_twin_rust_async__nested_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +304 => wire__crate__api__pseudo_manual__array_twin_rust_async__new_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +305 => wire__crate__api__pseudo_manual__array_twin_rust_async__return_boxed_feed_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +306 => 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), +307 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_boxed_blob_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +308 => wire__crate__api__pseudo_manual__array_twin_rust_async__use_msgid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +320 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__handle_customized_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +321 => wire__crate__api__pseudo_manual__attribute_twin_rust_async__next_user_id_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +324 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_general_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +325 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_primitive_enum_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +326 => wire__crate__api__pseudo_manual__basic__example_basic_type_basic_struct_twin_normal_twin_normal_impl(port, ptr, rust_vec_len, data_len), +327 => wire__crate__api__pseudo_manual__basic__example_basic_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +328 => wire__crate__api__pseudo_manual__basic__example_basic_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +329 => wire__crate__api__pseudo_manual__basic__example_basic_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +330 => wire__crate__api__pseudo_manual__basic__example_basic_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +331 => wire__crate__api__pseudo_manual__basic__example_basic_type_i128_twin_normal_impl(port, ptr, rust_vec_len, data_len), +332 => wire__crate__api__pseudo_manual__basic__example_basic_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +333 => wire__crate__api__pseudo_manual__basic__example_basic_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +334 => wire__crate__api__pseudo_manual__basic__example_basic_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +335 => wire__crate__api__pseudo_manual__basic__example_basic_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +336 => wire__crate__api__pseudo_manual__basic__example_basic_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +337 => wire__crate__api__pseudo_manual__basic__example_basic_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +338 => wire__crate__api__pseudo_manual__basic__example_basic_type_u128_twin_normal_impl(port, ptr, rust_vec_len, data_len), +339 => wire__crate__api__pseudo_manual__basic__example_basic_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +340 => wire__crate__api__pseudo_manual__basic__example_basic_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +341 => wire__crate__api__pseudo_manual__basic__example_basic_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +342 => wire__crate__api__pseudo_manual__basic__example_basic_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +343 => wire__crate__api__pseudo_manual__basic__example_basic_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +344 => 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), +345 => 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), +346 => 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), +347 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +348 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +349 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +350 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +351 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +352 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +353 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +354 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +355 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +356 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +357 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +358 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +359 => wire__crate__api__pseudo_manual__basic_list__example_basic_list_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +360 => 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), +361 => 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), +362 => 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), +363 => 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), +364 => 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), +365 => 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), +366 => 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), +367 => 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), +368 => 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), +369 => 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), +370 => 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), +371 => 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), +372 => 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), +373 => 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), +374 => 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), +375 => 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), +392 => 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), +393 => 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), +394 => 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), +395 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +396 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +397 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +398 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +399 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i128_twin_normal_impl(port, ptr, rust_vec_len, data_len), +400 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +401 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +402 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +403 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +404 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +405 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +406 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u128_twin_normal_impl(port, ptr, rust_vec_len, data_len), +407 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +408 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +409 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +410 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +411 => wire__crate__api__pseudo_manual__basic_map__example_basic_map_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +412 => 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), +413 => 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), +414 => 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), +415 => 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), +416 => 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), +417 => 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), +418 => 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), +419 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_i128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +420 => 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), +421 => 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), +422 => 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), +423 => 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), +424 => 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), +425 => 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), +426 => wire__crate__api__pseudo_manual__basic_map_twin_rust_async__example_basic_map_type_u128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +427 => 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), +428 => 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), +429 => 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), +430 => 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), +431 => 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), +452 => 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), +453 => 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), +454 => 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), +455 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bool_twin_normal_impl(port, ptr, rust_vec_len, data_len), +456 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +457 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +458 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_f64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +459 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i128_twin_normal_impl(port, ptr, rust_vec_len, data_len), +460 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +461 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +462 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +463 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_i8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +464 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_isize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +465 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_string_twin_normal_impl(port, ptr, rust_vec_len, data_len), +466 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u128_twin_normal_impl(port, ptr, rust_vec_len, data_len), +467 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u16_twin_normal_impl(port, ptr, rust_vec_len, data_len), +468 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u32_twin_normal_impl(port, ptr, rust_vec_len, data_len), +469 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u64_twin_normal_impl(port, ptr, rust_vec_len, data_len), +470 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_u8_twin_normal_impl(port, ptr, rust_vec_len, data_len), +471 => wire__crate__api__pseudo_manual__basic_optional__example_basic_optional_type_usize_twin_normal_impl(port, ptr, rust_vec_len, data_len), +472 => 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), +473 => 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), +474 => 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), +475 => 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), +476 => 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), +477 => 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), +478 => 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), +479 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_i128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +480 => 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), +481 => 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), +482 => 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), +483 => 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), +484 => 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), +485 => 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), +486 => wire__crate__api__pseudo_manual__basic_optional_twin_rust_async__example_basic_optional_type_u128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +487 => 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), +488 => 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), +489 => 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), +490 => 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), +491 => 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), +512 => 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), +513 => 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), +514 => 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), +515 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bool_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +516 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +517 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +518 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_f64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +519 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +520 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +521 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +522 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +523 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_i8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +524 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_isize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +525 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +526 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u128_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +527 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u16_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +528 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +529 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u64_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +530 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +531 => wire__crate__api__pseudo_manual__basic_twin_rust_async__example_basic_type_usize_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +552 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +553 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +554 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), +555 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +556 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +557 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_binary_tree_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), +558 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +559 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +560 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_input_twin_normal_impl(port, ptr, rust_vec_len, data_len), +561 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_json_twin_normal_impl(port, ptr, rust_vec_len, data_len), +562 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_protobuf_twin_normal_impl(port, ptr, rust_vec_len, data_len), +563 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_blob_output_twin_normal_impl(port, ptr, rust_vec_len, data_len), +564 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_input_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +565 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_output_bytes_twin_normal_impl(port, ptr, rust_vec_len, data_len), +566 => wire__crate__api__pseudo_manual__benchmark_api__benchmark_void_twin_normal_impl(port, ptr, rust_vec_len, data_len), +567 => 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), +568 => 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), +569 => 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), +570 => 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), +571 => 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), +572 => 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), +573 => 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), +574 => 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), +575 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_input_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +576 => 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), +577 => 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), +578 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_blob_output_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +579 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_input_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +580 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_output_bytes_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +581 => wire__crate__api__pseudo_manual__benchmark_api_twin_rust_async__benchmark_void_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +597 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_local_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +598 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__datetime_utc_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +599 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__duration_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +600 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_durations_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +601 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__handle_timestamps_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +602 => 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), +603 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__naivedatetime_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +604 => 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), +605 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +606 => wire__crate__api__pseudo_manual__chrono_type_twin_rust_async__test_precise_chrono_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +617 => 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), +618 => 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), +619 => 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), +620 => 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), +621 => 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), +627 => 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), +628 => 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), +629 => 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), +630 => 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), +631 => 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), +632 => 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), +633 => 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), +634 => 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), +635 => 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), +636 => 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), +637 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__clone_dart_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +638 => 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), +639 => 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), +640 => 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), +641 => 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), +642 => 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), +643 => 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), +644 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +645 => 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), +646 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_option_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +647 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +648 => 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), +649 => wire__crate__api__pseudo_manual__dart_opaque_twin_rust_async__loop_back_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +650 => 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), +651 => 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), +668 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_create_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +669 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_get_drop_count_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +670 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +671 => wire__crate__api__pseudo_manual__dropping_twin_rust_async__DroppableTwinRustAsync_simple_method_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +676 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_simple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +677 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__func_enum_with_discriminant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +678 => 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), +679 => 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), +680 => 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), +681 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_parameter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +682 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_enum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +683 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__handle_return_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +684 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__multiply_by_ten_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +685 => wire__crate__api__pseudo_manual__enumeration_twin_rust_async__print_note_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +696 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__close_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +697 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__create_event_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +698 => 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), +699 => wire__crate__api__pseudo_manual__event_listener_twin_rust_async__register_event_listener_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +700 => wire__crate__api__pseudo_manual__exception_twin_rust_async__custom_enum_error_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +701 => 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), +702 => 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), +703 => 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), +704 => 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), +705 => 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), +706 => 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), +707 => 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), +708 => 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), +709 => 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), +710 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +711 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_fallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +712 => wire__crate__api__pseudo_manual__exception_twin_rust_async__func_type_infallible_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +713 => wire__crate__api__pseudo_manual__exception_twin_rust_async__panic_with_custom_result_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +714 => 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), +715 => 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), +716 => 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), +717 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +718 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_custom_struct_ok_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +719 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_err_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +720 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_error_variant_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +721 => wire__crate__api__pseudo_manual__exception_twin_rust_async__return_ok_custom_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +722 => 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), +723 => 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), +724 => 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), +725 => 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), +726 => 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), +727 => wire__crate__api__pseudo_manual__exception_twin_rust_async__stream_sink_throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +728 => wire__crate__api__pseudo_manual__exception_twin_rust_async__throw_anyhow_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +758 => 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), +759 => 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), +760 => 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), +761 => 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), +768 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructOneWithTraitTwinSync_simple_trait_fn_receiver_borrow_twin_sync_impl(port, ptr, rust_vec_len, data_len), +769 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructOneWithTraitTwinSync_simple_trait_fn_twin_sync_impl(port, ptr, rust_vec_len, data_len), +770 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructOneWithTraitTwinSync_simple_trait_fn_with_default_impl_twin_sync_impl(port, ptr, rust_vec_len, data_len), +773 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructTwoWithTraitTwinSync_simple_trait_fn_receiver_borrow_twin_sync_impl(port, ptr, rust_vec_len, data_len), +774 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructTwoWithTraitTwinSync_simple_trait_fn_twin_sync_impl(port, ptr, rust_vec_len, data_len), +775 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructTwoWithTraitTwinSync_simple_trait_fn_with_default_impl_twin_sync_impl(port, ptr, rust_vec_len, data_len), +779 => 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), +780 => 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), +781 => 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), +782 => 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), +783 => 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), +784 => 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), +785 => 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), +786 => 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), +795 => wire__crate__api__pseudo_manual__method_twin_rust_async__StaticGetterOnlyTwinRustAsync_static_getter_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +796 => 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), +797 => 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), +798 => 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), +799 => 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), +800 => 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), +801 => 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), +802 => 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), +803 => 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), +804 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +805 => wire__crate__api__pseudo_manual__method_twin_rust_async__get_sum_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +806 => wire__crate__api__pseudo_manual__method_twin_rust_async__my_callable_twin_rust_async_call_impl(port, ptr, rust_vec_len, data_len), +807 => 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), +808 => 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), +809 => 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), +810 => 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), +811 => 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), +812 => 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), +813 => 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), +814 => 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), +815 => 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), +816 => 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), +839 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +840 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__app_settings_vec_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +841 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +842 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__first_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +843 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +844 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_fallible_app_settings_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +845 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__get_message_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +846 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__is_app_embedded_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +847 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_array_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +848 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +849 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_map_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +850 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_option_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +851 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_set_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +852 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_struct_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +853 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_tuple_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +854 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__mirror_vec_enum_stream_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +855 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_number_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +856 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__repeat_sequence_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +857 => 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), +858 => 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), +859 => 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), +860 => 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), +861 => 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), +862 => 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), +863 => 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), +864 => wire__crate__api__pseudo_manual__mirror_twin_rust_async__test_raw_string_mirrored_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +891 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_big_buffers_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +892 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_char_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +893 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_complex_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +894 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_nested_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +895 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +896 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +897 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__handle_vec_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +898 => 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), +899 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__positional_arguments_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +900 => wire__crate__api__pseudo_manual__misc_example_twin_rust_async__test_abc_enum_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +901 => 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), +913 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__empty_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +914 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__func_return_unit_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +915 => 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), +916 => wire__crate__api__pseudo_manual__misc_type_twin_rust_async__handle_string_list_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +921 => wire__crate__api__pseudo_manual__newtype_pattern_twin_rust_async__handle_newtype_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +923 => 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), +925 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_increment_boxed_optional_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +926 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_option_box_arguments_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +927 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_increment_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +928 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_return_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +929 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_optional_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +930 => wire__crate__api__pseudo_manual__optional_twin_rust_async__handle_vec_of_opts_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +937 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_i32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +938 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_slice_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +939 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_slice_u8_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +940 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_str_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +941 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_string_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +942 => wire__crate__api__pseudo_manual__ownership_twin_rust_async__borrow_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +949 => 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), +951 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_types_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +952 => wire__crate__api__pseudo_manual__primitive_misc_twin_rust_async__primitive_u32_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +955 => 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), +956 => 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), +959 => 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), +960 => 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), +961 => 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), +962 => 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), +963 => 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), +964 => 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), +965 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__NonCloneSimpleTwinRustAsync_new_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +966 => 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), +967 => 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), +968 => 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), +969 => 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), +970 => 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), +974 => 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), +975 => 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), +976 => 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), +977 => 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), +978 => 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), +979 => 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), +980 => 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), +981 => 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), +982 => 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), +983 => 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), +984 => 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), +985 => 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), +986 => 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), +987 => 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), +988 => 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), +989 => 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), +990 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__rust_auto_opaque_explicit_return_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +991 => 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), +992 => 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), +993 => 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), +994 => 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), +995 => 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), +996 => 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), +997 => 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), +998 => 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), +999 => 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), +1000 => 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), +1001 => 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), +1002 => 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), +1003 => 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), +1004 => 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), +1051 => 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), +1052 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1053 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1054 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__create_option_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1055 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__frb_generator_test_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1056 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1057 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_array_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1058 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_run_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1059 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__opaque_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1060 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_enum_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1061 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_nested_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1062 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_non_clone_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1063 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__run_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1064 => 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), +1065 => wire__crate__api__pseudo_manual__rust_opaque_twin_rust_async__unwrap_rust_opaque_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1081 => wire__crate__api__pseudo_manual__simple_twin_rust_async__simple_adder_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1083 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_add_value_and_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1084 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_error_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1085 => wire__crate__api__pseudo_manual__stream_twin_rust_async__func_stream_return_panic_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1086 => 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), +1087 => wire__crate__api__pseudo_manual__stream_twin_rust_async__handle_stream_of_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1088 => 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), +1089 => 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), +1090 => 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), +1091 => 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), +1092 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_struct_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1093 => wire__crate__api__pseudo_manual__stream_twin_rust_async__stream_sink_inside_vec_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1094 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_dart_keyword_field_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1095 => wire__crate__api__pseudo_manual__structure_twin_rust_async__func_for_struct_with_field_rename_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1096 => 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), +1097 => 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), +1098 => 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), +1099 => 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), +1100 => 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), +1108 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_2_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1109 => wire__crate__api__pseudo_manual__tuple_twin_rust_async__test_tuple_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1112 => 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), +1113 => 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), +1114 => 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), +1118 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_nested_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1119 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuid_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1120 => wire__crate__api__pseudo_manual__uuid_type_twin_rust_async__handle_uuids_twin_rust_async_impl(port, ptr, rust_vec_len, data_len), +1124 => wire__crate__api__raw_string__test_more_than_just_one_raw_string_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1125 => wire__crate__api__raw_string__test_raw_string_item_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1126 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1127 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1128 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1129 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_getter_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1130 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_instance_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1131 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_custom_name_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1132 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1133 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_new_with_result_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1134 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1135 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1136 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1137 => wire__crate__api__rust_auto_opaque__NonCloneSimpleTwinNormal_static_method_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1141 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1142 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1143 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_and_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1144 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1145 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_arg_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1146 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1147 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_borrow_and_mut_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1148 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1149 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_callable_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1150 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_dummy_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1151 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_arg_borrow_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1152 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_enum_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1153 => 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), +1154 => 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), +1155 => 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), +1156 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1157 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_return_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1158 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1159 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_explicit_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1160 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_normal_and_opaque_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1161 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_arg_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1162 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_plus_sign_return_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1163 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_one_and_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1164 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_opaque_two_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1165 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1166 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_return_vec_own_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1167 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_sleep_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1168 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_stream_sink_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1169 => 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), +1170 => 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), +1171 => wire__crate__api__rust_auto_opaque__rust_auto_opaque_two_args_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1172 => wire__crate__api__rust_opaque__create_array_opaque_enum_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1173 => wire__crate__api__rust_opaque__create_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1174 => wire__crate__api__rust_opaque__create_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1175 => wire__crate__api__rust_opaque__create_option_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1176 => wire__crate__api__rust_opaque__frb_generator_test_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1177 => wire__crate__api__rust_opaque__opaque_array_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1178 => wire__crate__api__rust_opaque__opaque_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1179 => wire__crate__api__rust_opaque__opaque_vec_run_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1180 => wire__crate__api__rust_opaque__opaque_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1181 => wire__crate__api__rust_opaque__run_enum_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1182 => wire__crate__api__rust_opaque__run_nested_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1183 => wire__crate__api__rust_opaque__run_non_clone_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1184 => wire__crate__api__rust_opaque__run_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1185 => wire__crate__api__rust_opaque__run_opaque_with_delay_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1186 => wire__crate__api__rust_opaque__unwrap_rust_opaque_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1191 => wire__crate__api__simple__simple_adder_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1192 => wire__crate__api__stream__func_stream_add_value_and_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1193 => wire__crate__api__stream__func_stream_return_error_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1194 => wire__crate__api__stream__func_stream_return_panic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1195 => wire__crate__api__stream__func_stream_sink_arg_position_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1196 => wire__crate__api__stream__handle_stream_of_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1197 => wire__crate__api__stream__handle_stream_sink_at_1_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1198 => wire__crate__api__stream__handle_stream_sink_at_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1199 => wire__crate__api__stream__handle_stream_sink_at_3_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1200 => wire__crate__api__stream__stream_sink_fixed_sized_primitive_array_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1201 => wire__crate__api__stream__stream_sink_inside_struct_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1202 => wire__crate__api__stream__stream_sink_inside_vec_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1203 => wire__crate__api__stream_misc__func_stream_realistic_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1204 => wire__crate__api__stream_misc__stream_sink_dart_async_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1205 => wire__crate__api__structure__func_for_struct_with_dart_keyword_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1206 => wire__crate__api__structure__func_for_struct_with_field_rename_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1207 => wire__crate__api__structure__func_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1208 => wire__crate__api__structure__func_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1209 => wire__crate__api__structure__func_struct_with_zero_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1210 => wire__crate__api__structure__func_tuple_struct_with_one_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1211 => wire__crate__api__structure__func_tuple_struct_with_two_field_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1212 => wire__crate__api__tuple__test_tuple_2_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1213 => wire__crate__api__tuple__test_tuple_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1214 => wire__crate__api__type_alias__handle_type_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1215 => wire__crate__api__type_alias__handle_type_alias_model_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1216 => wire__crate__api__type_alias__handle_type_nest_alias_id_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1217 => wire__crate__api__uuid_type__handle_nested_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1218 => wire__crate__api__uuid_type__handle_uuid_twin_normal_impl(port, ptr, rust_vec_len, data_len), +1219 => wire__crate__api__uuid_type__handle_uuids_twin_normal_impl(port, ptr, rust_vec_len, data_len), _ => unreachable!(), } } @@ -39144,406 +39684,409 @@ fn pde_ffi_dispatcher_sync_impl( // Codec=Pde (Serialization + dispatch), see doc to use other codecs match func_id { 20 => wire__crate__api__benchmark_misc__benchmark_void_semi_serialize_impl(ptr, rust_vec_len, data_len), -36 => wire__crate__api__constructor__ConstructorOpaqueStructTwinNormal_check_impl(ptr, rust_vec_len, data_len), -37 => wire__crate__api__constructor__ConstructorOpaqueStructTwinNormal_get_one_impl(ptr, rust_vec_len, data_len), -39 => wire__crate__api__constructor__ConstructorOpaqueStructTwinNormal_set_one_impl(ptr, rust_vec_len, data_len), -40 => wire__crate__api__constructor__ConstructorOpaqueSyncStructTwinNormal_check_impl(ptr, rust_vec_len, data_len), -41 => wire__crate__api__constructor__ConstructorOpaqueSyncStructTwinNormal_get_one_impl(ptr, rust_vec_len, data_len), -42 => wire__crate__api__constructor__ConstructorOpaqueSyncStructTwinNormal_new_impl(ptr, rust_vec_len, data_len), -43 => wire__crate__api__constructor__ConstructorOpaqueSyncStructTwinNormal_set_one_impl(ptr, rust_vec_len, data_len), -45 => wire__crate__api__constructor__constructor_translatable_sync_struct_twin_normal_new_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), -78 => 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), -80 => wire__crate__api__dart_opaque_sync__sync_option_loopback_twin_normal_impl(ptr, rust_vec_len, data_len), -81 => wire__crate__api__dart_opaque_sync__unwrap_dart_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), -88 => wire__crate__api__dyn_trait__StructOneWithTraitForDynTwinNormal_get_one_impl(ptr, rust_vec_len, data_len), -89 => wire__crate__api__dyn_trait__StructOneWithTraitForDynTwinNormal_set_one_impl(ptr, rust_vec_len, data_len), -92 => wire__crate__api__dyn_trait__StructTwoWithTraitForDynTwinNormal_get_two_impl(ptr, rust_vec_len, data_len), -93 => wire__crate__api__dyn_trait__StructTwoWithTraitForDynTwinNormal_set_two_impl(ptr, rust_vec_len, data_len), -108 => wire__crate__api__event_listener__create_event_sync_twin_normal_impl(ptr, rust_vec_len, data_len), -146 => wire__crate__api__impl_trait__StructOneWithTraitTwinNormal_get_one_impl(ptr, rust_vec_len, data_len), -147 => wire__crate__api__impl_trait__StructOneWithTraitTwinNormal_set_one_impl(ptr, rust_vec_len, data_len), -151 => wire__crate__api__impl_trait__StructTwoWithTraitTwinNormal_get_two_impl(ptr, rust_vec_len, data_len), -152 => wire__crate__api__impl_trait__StructTwoWithTraitTwinNormal_set_two_impl(ptr, rust_vec_len, data_len), -229 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_deliberate_bad_field_a_impl(ptr, rust_vec_len, data_len), -230 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_deliberate_bad_field_b_impl(ptr, rust_vec_len, data_len), -231 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_deliberate_bad_field_c_impl(ptr, rust_vec_len, data_len), -232 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_good_field_a_impl(ptr, rust_vec_len, data_len), -233 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_good_field_b_impl(ptr, rust_vec_len, data_len), -234 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_good_field_c_impl(ptr, rust_vec_len, data_len), -235 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_deliberate_bad_field_a_impl(ptr, rust_vec_len, data_len), -236 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_deliberate_bad_field_b_impl(ptr, rust_vec_len, data_len), -237 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_deliberate_bad_field_c_impl(ptr, rust_vec_len, data_len), -238 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_good_field_a_impl(ptr, rust_vec_len, data_len), -239 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_good_field_b_impl(ptr, rust_vec_len, data_len), -240 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_good_field_c_impl(ptr, rust_vec_len, data_len), -243 => wire__crate__api__misc_no_twin_example_a__ItemContainerSolutionOneTwinNormal_get_name_impl(ptr, rust_vec_len, data_len), -244 => wire__crate__api__misc_no_twin_example_a__ItemContainerSolutionOneTwinNormal_set_name_impl(ptr, rust_vec_len, data_len), -248 => wire__crate__api__misc_no_twin_example_a__StructWithSimpleSetterTwinNormal_get_something_impl(ptr, rust_vec_len, data_len), -249 => wire__crate__api__misc_no_twin_example_a__StructWithSimpleSetterTwinNormal_new_impl(ptr, rust_vec_len, data_len), -250 => wire__crate__api__misc_no_twin_example_a__StructWithSimpleSetterTwinNormal_set_something_impl(ptr, rust_vec_len, data_len), -251 => wire__crate__api__misc_no_twin_example_a__StructWithSimpleSetterTwinNormal_simple_getter_impl(ptr, rust_vec_len, data_len), -252 => wire__crate__api__misc_no_twin_example_a__StructWithSimpleSetterTwinNormal_simple_setter_impl(ptr, rust_vec_len, data_len), -258 => 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), -300 => wire__crate__api__pseudo_manual__array_twin_sync__boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), -301 => wire__crate__api__pseudo_manual__array_twin_sync__func_test_id_twin_sync_impl(ptr, rust_vec_len, data_len), -302 => wire__crate__api__pseudo_manual__array_twin_sync__get_array_twin_sync_impl(ptr, rust_vec_len, data_len), -303 => wire__crate__api__pseudo_manual__array_twin_sync__get_complex_array_twin_sync_impl(ptr, rust_vec_len, data_len), -304 => wire__crate__api__pseudo_manual__array_twin_sync__last_number_twin_sync_impl(ptr, rust_vec_len, data_len), -305 => wire__crate__api__pseudo_manual__array_twin_sync__nested_id_twin_sync_impl(ptr, rust_vec_len, data_len), -306 => wire__crate__api__pseudo_manual__array_twin_sync__new_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), -307 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), -308 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_raw_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), -309 => wire__crate__api__pseudo_manual__array_twin_sync__use_boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), -310 => wire__crate__api__pseudo_manual__array_twin_sync__use_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), -313 => wire__crate__api__pseudo_manual__attribute_twin_sync__handle_customized_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -314 => wire__crate__api__pseudo_manual__attribute_twin_sync__next_user_id_twin_sync_impl(ptr, rust_vec_len, data_len), -367 => 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), -368 => 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), -369 => 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), -370 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -371 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -372 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -373 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -374 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -375 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -376 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -377 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -378 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -379 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -380 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -381 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -382 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -423 => 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), -424 => 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), -425 => 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), -426 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -427 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -428 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -429 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -430 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i128_twin_sync_impl(ptr, rust_vec_len, data_len), -431 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -432 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -433 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -434 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -435 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), -436 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -437 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u128_twin_sync_impl(ptr, rust_vec_len, data_len), -438 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -439 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -440 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -441 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -442 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), -483 => 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), -484 => 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), -485 => 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), -486 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -487 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -488 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -489 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -490 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i128_twin_sync_impl(ptr, rust_vec_len, data_len), -491 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -492 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -493 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -494 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -495 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), -496 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -497 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u128_twin_sync_impl(ptr, rust_vec_len, data_len), -498 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -499 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -500 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -501 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -502 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), -523 => 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), -524 => 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), -525 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), -526 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), -527 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -528 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), -529 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), -530 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i128_twin_sync_impl(ptr, rust_vec_len, data_len), -531 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), -532 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -533 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), -534 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), -535 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), -536 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), -537 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u128_twin_sync_impl(ptr, rust_vec_len, data_len), -538 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), -539 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -540 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), -541 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -542 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), -573 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), -574 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -575 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_twin_sync_impl(ptr, rust_vec_len, data_len), -576 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), -577 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -578 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_twin_sync_impl(ptr, rust_vec_len, data_len), -579 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), -580 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -581 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_twin_sync_impl(ptr, rust_vec_len, data_len), -582 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), -583 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), -584 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_twin_sync_impl(ptr, rust_vec_len, data_len), -585 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_input_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -586 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_output_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -587 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_void_twin_sync_impl(ptr, rust_vec_len, data_len), -598 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_local_twin_sync_impl(ptr, rust_vec_len, data_len), -599 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), -600 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__duration_twin_sync_impl(ptr, rust_vec_len, data_len), -601 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_durations_twin_sync_impl(ptr, rust_vec_len, data_len), -602 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_timestamps_twin_sync_impl(ptr, rust_vec_len, data_len), -603 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__how_long_does_it_take_twin_sync_impl(ptr, rust_vec_len, data_len), -604 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__naivedatetime_twin_sync_impl(ptr, rust_vec_len, data_len), -605 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__optional_empty_datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), -606 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), -607 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_precise_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), -613 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_slash_star_star_twin_sync_impl(ptr, rust_vec_len, data_len), -614 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_multi_line_twin_sync_impl(ptr, rust_vec_len, data_len), -615 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_single_line_twin_sync_impl(ptr, rust_vec_len, data_len), -616 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_instance_method_twin_sync_impl(ptr, rust_vec_len, data_len), -617 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), -643 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__async_accept_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -644 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__clone_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -645 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -646 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -647 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__drop_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -648 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -649 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -650 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_get_twin_sync_impl(ptr, rust_vec_len, data_len), -651 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_twin_sync_impl(ptr, rust_vec_len, data_len), -652 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_get_twin_sync_impl(ptr, rust_vec_len, data_len), -653 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_twin_sync_impl(ptr, rust_vec_len, data_len), -654 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_twin_sync_impl(ptr, rust_vec_len, data_len), -655 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_get_twin_sync_impl(ptr, rust_vec_len, data_len), -656 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_twin_sync_impl(ptr, rust_vec_len, data_len), -657 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__panic_unwrap_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -658 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__set_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -663 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_create_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -664 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_get_drop_count_twin_sync_impl(ptr, rust_vec_len, data_len), -665 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -666 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), -677 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_simple_twin_sync_impl(ptr, rust_vec_len, data_len), -678 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_discriminant_twin_sync_impl(ptr, rust_vec_len, data_len), -679 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_mixed_twin_sync_impl(ptr, rust_vec_len, data_len), -680 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -681 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), -682 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_parameter_twin_sync_impl(ptr, rust_vec_len, data_len), -683 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -684 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_return_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -685 => wire__crate__api__pseudo_manual__enumeration_twin_sync__multiply_by_ten_twin_sync_impl(ptr, rust_vec_len, data_len), -686 => wire__crate__api__pseudo_manual__enumeration_twin_sync__print_note_twin_sync_impl(ptr, rust_vec_len, data_len), -720 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_panic_twin_sync_impl(ptr, rust_vec_len, data_len), -721 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -722 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_ok_twin_sync_impl(ptr, rust_vec_len, data_len), -723 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_nested_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -724 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -725 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -726 => 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), -727 => 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), -728 => 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), -729 => 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), -730 => wire__crate__api__pseudo_manual__exception_twin_sync__func_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), -731 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_fallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), -732 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_infallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), -733 => wire__crate__api__pseudo_manual__exception_twin_sync__panic_with_custom_result_twin_sync_impl(ptr, rust_vec_len, data_len), -734 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_twin_sync_impl(ptr, rust_vec_len, data_len), -735 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_variant1_twin_sync_impl(ptr, rust_vec_len, data_len), -736 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_2_twin_sync_impl(ptr, rust_vec_len, data_len), -737 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), -738 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), -739 => wire__crate__api__pseudo_manual__exception_twin_sync__return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -740 => wire__crate__api__pseudo_manual__exception_twin_sync__return_error_variant_twin_sync_impl(ptr, rust_vec_len, data_len), -741 => wire__crate__api__pseudo_manual__exception_twin_sync__return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), -742 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -743 => 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), -744 => 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), -745 => 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), -746 => 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), -747 => wire__crate__api__pseudo_manual__exception_twin_sync__stream_sink_throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), -748 => wire__crate__api__pseudo_manual__exception_twin_sync__throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), -753 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_new_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), -754 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_old_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), -755 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -756 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -757 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructOneWithTraitTwinSync_get_one_impl(ptr, rust_vec_len, data_len), -758 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructOneWithTraitTwinSync_set_one_impl(ptr, rust_vec_len, data_len), -762 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructTwoWithTraitTwinSync_get_two_impl(ptr, rust_vec_len, data_len), -763 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructTwoWithTraitTwinSync_set_two_impl(ptr, rust_vec_len, data_len), -778 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_i32_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -779 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), -780 => 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), -781 => 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), -782 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_string_twin_sync_impl(ptr, rust_vec_len, data_len), -783 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -784 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -785 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_string_twin_sync_impl(ptr, rust_vec_len, data_len), -808 => wire__crate__api__pseudo_manual__method_twin_sync__StaticGetterOnlyTwinSync_static_getter_twin_sync_impl(ptr, rust_vec_len, data_len), -809 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_static_twin_sync_impl(ptr, rust_vec_len, data_len), -810 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_twin_sync_impl(ptr, rust_vec_len, data_len), -811 => 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), -812 => 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), -813 => 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), -814 => 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), -815 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -816 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_simple_getter_twin_sync_impl(ptr, rust_vec_len, data_len), -817 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_array_twin_sync_impl(ptr, rust_vec_len, data_len), -818 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -819 => wire__crate__api__pseudo_manual__method_twin_sync__my_callable_twin_sync_call_impl(ptr, rust_vec_len, data_len), -820 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), -821 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), -822 => wire__crate__api__pseudo_manual__method_twin_sync__simple_primitive_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), -823 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_arg_self_twin_sync_impl(ptr, rust_vec_len, data_len), -824 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -825 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_own_twin_sync_impl(ptr, rust_vec_len, data_len), -826 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), -827 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_vec_self_twin_sync_impl(ptr, rust_vec_len, data_len), -828 => wire__crate__api__pseudo_manual__method_twin_sync__static_only_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), -829 => wire__crate__api__pseudo_manual__method_twin_sync__sum_with_twin_sync_sum_twin_sync_impl(ptr, rust_vec_len, data_len), -856 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -857 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_vec_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -858 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_number_twin_sync_impl(ptr, rust_vec_len, data_len), -859 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), -860 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), -861 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_fallible_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), -862 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_message_twin_sync_impl(ptr, rust_vec_len, data_len), -863 => wire__crate__api__pseudo_manual__mirror_twin_sync__is_app_embedded_twin_sync_impl(ptr, rust_vec_len, data_len), -864 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_array_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -865 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -866 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_map_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -867 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_option_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -868 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_set_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -869 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_struct_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -870 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_tuple_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -871 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_vec_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), -872 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_number_twin_sync_impl(ptr, rust_vec_len, data_len), -873 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), -874 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_contains_mirrored_sub_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -875 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_fallible_of_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -876 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_hashmap_with_mirrored_value_twin_sync_impl(ptr, rust_vec_len, data_len), -877 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_nested_enums_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -878 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_raw_nested_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -879 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_nested_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -880 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_enum_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -881 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), -893 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_big_buffers_twin_sync_impl(ptr, rust_vec_len, data_len), -894 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_char_twin_sync_impl(ptr, rust_vec_len, data_len), -895 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_complex_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -896 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_nested_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -897 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_string_twin_sync_impl(ptr, rust_vec_len, data_len), -898 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -899 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_vec_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -900 => wire__crate__api__pseudo_manual__misc_example_twin_sync__list_of_primitive_enums_twin_sync_impl(ptr, rust_vec_len, data_len), -901 => wire__crate__api__pseudo_manual__misc_example_twin_sync__positional_arguments_twin_sync_impl(ptr, rust_vec_len, data_len), -902 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_abc_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -903 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_struct_with_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -908 => wire__crate__api__pseudo_manual__misc_type_twin_sync__empty_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -909 => wire__crate__api__pseudo_manual__misc_type_twin_sync__func_return_unit_twin_sync_impl(ptr, rust_vec_len, data_len), -910 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_list_of_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -911 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_string_list_twin_sync_impl(ptr, rust_vec_len, data_len), -913 => wire__crate__api__pseudo_manual__newtype_pattern_twin_sync__handle_newtype_twin_sync_impl(ptr, rust_vec_len, data_len), -915 => wire__crate__api__pseudo_manual__optional_primitive_misc_twin_sync__primitive_optional_types_twin_sync_impl(ptr, rust_vec_len, data_len), -922 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_increment_boxed_optional_twin_sync_impl(ptr, rust_vec_len, data_len), -923 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_option_box_arguments_twin_sync_impl(ptr, rust_vec_len, data_len), -924 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_increment_twin_sync_impl(ptr, rust_vec_len, data_len), -925 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_return_twin_sync_impl(ptr, rust_vec_len, data_len), -926 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -927 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_vec_of_opts_twin_sync_impl(ptr, rust_vec_len, data_len), -934 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_i32_twin_sync_impl(ptr, rust_vec_len, data_len), -935 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_slice_string_twin_sync_impl(ptr, rust_vec_len, data_len), -936 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_slice_u8_twin_sync_impl(ptr, rust_vec_len, data_len), -937 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_str_twin_sync_impl(ptr, rust_vec_len, data_len), -938 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_string_twin_sync_impl(ptr, rust_vec_len, data_len), -939 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -941 => wire__crate__api__pseudo_manual__primitive_list_misc_twin_sync__handle_vec_of_primitive_twin_sync_impl(ptr, rust_vec_len, data_len), -944 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_types_twin_sync_impl(ptr, rust_vec_len, data_len), -945 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_u32_twin_sync_impl(ptr, rust_vec_len, data_len), -948 => 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), -949 => wire__crate__api__pseudo_manual__raw_string_twin_sync__test_raw_string_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -962 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__StructWithGoodAndOpaqueFieldWithoutOptionTwinRustAsync_get_good_impl(ptr, rust_vec_len, data_len), -963 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__StructWithGoodAndOpaqueFieldWithoutOptionTwinRustAsync_set_good_impl(ptr, rust_vec_len, data_len), -996 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -997 => 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), -998 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -999 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_getter_twin_sync_impl(ptr, rust_vec_len, data_len), -1000 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -1001 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_custom_name_twin_sync_impl(ptr, rust_vec_len, data_len), -1002 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), -1003 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_with_result_twin_sync_impl(ptr, rust_vec_len, data_len), -1004 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -1005 => 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), -1006 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -1007 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -1008 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__StructWithGoodAndOpaqueFieldWithoutOptionTwinSync_get_good_impl(ptr, rust_vec_len, data_len), -1009 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__StructWithGoodAndOpaqueFieldWithoutOptionTwinSync_set_good_impl(ptr, rust_vec_len, data_len), -1011 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), -1012 => 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), -1013 => 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), -1014 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), -1015 => 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), -1016 => 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), -1017 => 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), -1018 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -1019 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_return_twin_sync_impl(ptr, rust_vec_len, data_len), -1020 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_dummy_twin_sync_impl(ptr, rust_vec_len, data_len), -1021 => 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), -1022 => 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), -1023 => 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), -1024 => 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), -1025 => 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), -1026 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_arg_twin_sync_impl(ptr, rust_vec_len, data_len), -1027 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_return_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -1028 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_return_twin_sync_impl(ptr, rust_vec_len, data_len), -1029 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_struct_twin_sync_impl(ptr, rust_vec_len, data_len), -1030 => 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), -1031 => 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), -1032 => 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), -1033 => 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), -1034 => 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), -1035 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), -1036 => 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), -1037 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_sleep_twin_sync_impl(ptr, rust_vec_len, data_len), -1038 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), -1039 => 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), -1040 => 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), -1041 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_two_args_twin_sync_impl(ptr, rust_vec_len, data_len), -1057 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_array_opaque_enum_twin_sync_impl(ptr, rust_vec_len, data_len), -1058 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -1059 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -1060 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_option_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -1061 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__frb_generator_test_twin_sync_impl(ptr, rust_vec_len, data_len), -1062 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_run_twin_sync_impl(ptr, rust_vec_len, data_len), -1063 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_twin_sync_impl(ptr, rust_vec_len, data_len), -1064 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_run_twin_sync_impl(ptr, rust_vec_len, data_len), -1065 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_twin_sync_impl(ptr, rust_vec_len, data_len), -1066 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_enum_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -1067 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -1068 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_non_clone_twin_sync_impl(ptr, rust_vec_len, data_len), -1069 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -1070 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_with_delay_twin_sync_impl(ptr, rust_vec_len, data_len), -1071 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__unwrap_rust_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), -1073 => wire__crate__api__pseudo_manual__simple_twin_sync__simple_adder_twin_sync_impl(ptr, rust_vec_len, data_len), -1090 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1091 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1092 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_zero_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1093 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1094 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), -1097 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_2_twin_sync_impl(ptr, rust_vec_len, data_len), -1098 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), -1102 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), -1103 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_model_twin_sync_impl(ptr, rust_vec_len, data_len), -1104 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_nest_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), -1108 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_nested_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), -1109 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuid_twin_sync_impl(ptr, rust_vec_len, data_len), -1110 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), -1125 => wire__crate__api__rust_auto_opaque__StructWithGoodAndOpaqueFieldWithoutOptionTwinNormal_get_good_impl(ptr, rust_vec_len, data_len), -1126 => wire__crate__api__rust_auto_opaque__StructWithGoodAndOpaqueFieldWithoutOptionTwinNormal_set_good_impl(ptr, rust_vec_len, data_len), -1174 => wire__crate__api__rust_opaque_sync__frb_sync_generator_test_twin_normal_impl(ptr, rust_vec_len, data_len), -1175 => wire__crate__api__rust_opaque_sync__sync_create_non_clone_twin_normal_impl(ptr, rust_vec_len, data_len), -1176 => wire__crate__api__rust_opaque_sync__sync_create_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), -1177 => wire__crate__api__rust_opaque_sync__sync_option_rust_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +42 => wire__crate__api__constructor__ConstructorOpaqueStructTwinNormal_check_impl(ptr, rust_vec_len, data_len), +43 => wire__crate__api__constructor__ConstructorOpaqueStructTwinNormal_get_one_impl(ptr, rust_vec_len, data_len), +45 => wire__crate__api__constructor__ConstructorOpaqueStructTwinNormal_set_one_impl(ptr, rust_vec_len, data_len), +46 => wire__crate__api__constructor__ConstructorOpaqueSyncStructTwinNormal_check_impl(ptr, rust_vec_len, data_len), +47 => wire__crate__api__constructor__ConstructorOpaqueSyncStructTwinNormal_get_one_impl(ptr, rust_vec_len, data_len), +48 => wire__crate__api__constructor__ConstructorOpaqueSyncStructTwinNormal_new_impl(ptr, rust_vec_len, data_len), +49 => wire__crate__api__constructor__ConstructorOpaqueSyncStructTwinNormal_set_one_impl(ptr, rust_vec_len, data_len), +51 => wire__crate__api__constructor__constructor_translatable_sync_struct_twin_normal_new_impl(ptr, rust_vec_len, data_len), +84 => wire__crate__api__dart_opaque_sync__sync_accept_dart_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +85 => wire__crate__api__dart_opaque_sync__sync_loopback_twin_normal_impl(ptr, rust_vec_len, data_len), +86 => wire__crate__api__dart_opaque_sync__sync_option_dart_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +87 => wire__crate__api__dart_opaque_sync__sync_option_loopback_twin_normal_impl(ptr, rust_vec_len, data_len), +88 => wire__crate__api__dart_opaque_sync__unwrap_dart_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +95 => wire__crate__api__dyn_trait__StructOneWithTraitForDynTwinNormal_get_one_impl(ptr, rust_vec_len, data_len), +96 => wire__crate__api__dyn_trait__StructOneWithTraitForDynTwinNormal_set_one_impl(ptr, rust_vec_len, data_len), +99 => wire__crate__api__dyn_trait__StructTwoWithTraitForDynTwinNormal_get_two_impl(ptr, rust_vec_len, data_len), +100 => wire__crate__api__dyn_trait__StructTwoWithTraitForDynTwinNormal_set_two_impl(ptr, rust_vec_len, data_len), +115 => wire__crate__api__event_listener__create_event_sync_twin_normal_impl(ptr, rust_vec_len, data_len), +148 => wire__crate__api__external_impl__SimpleOpaqueExternalStructWithMethod_new_impl(ptr, rust_vec_len, data_len), +155 => wire__crate__api__impl_trait__StructOneWithTraitTwinNormal_get_one_impl(ptr, rust_vec_len, data_len), +156 => wire__crate__api__impl_trait__StructOneWithTraitTwinNormal_set_one_impl(ptr, rust_vec_len, data_len), +160 => wire__crate__api__impl_trait__StructTwoWithTraitTwinNormal_get_two_impl(ptr, rust_vec_len, data_len), +161 => wire__crate__api__impl_trait__StructTwoWithTraitTwinNormal_set_two_impl(ptr, rust_vec_len, data_len), +238 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_deliberate_bad_field_a_impl(ptr, rust_vec_len, data_len), +239 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_deliberate_bad_field_b_impl(ptr, rust_vec_len, data_len), +240 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_deliberate_bad_field_c_impl(ptr, rust_vec_len, data_len), +241 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_good_field_a_impl(ptr, rust_vec_len, data_len), +242 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_good_field_b_impl(ptr, rust_vec_len, data_len), +243 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_get_good_field_c_impl(ptr, rust_vec_len, data_len), +244 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_deliberate_bad_field_a_impl(ptr, rust_vec_len, data_len), +245 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_deliberate_bad_field_b_impl(ptr, rust_vec_len, data_len), +246 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_deliberate_bad_field_c_impl(ptr, rust_vec_len, data_len), +247 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_good_field_a_impl(ptr, rust_vec_len, data_len), +248 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_good_field_b_impl(ptr, rust_vec_len, data_len), +249 => wire__crate__api__misc_no_twin_example_a__DeliberateFailSanityCheckTwinNormal_set_good_field_c_impl(ptr, rust_vec_len, data_len), +252 => wire__crate__api__misc_no_twin_example_a__ItemContainerSolutionOneTwinNormal_get_name_impl(ptr, rust_vec_len, data_len), +253 => wire__crate__api__misc_no_twin_example_a__ItemContainerSolutionOneTwinNormal_set_name_impl(ptr, rust_vec_len, data_len), +257 => wire__crate__api__misc_no_twin_example_a__StructWithSimpleSetterTwinNormal_get_something_impl(ptr, rust_vec_len, data_len), +258 => wire__crate__api__misc_no_twin_example_a__StructWithSimpleSetterTwinNormal_new_impl(ptr, rust_vec_len, data_len), +259 => wire__crate__api__misc_no_twin_example_a__StructWithSimpleSetterTwinNormal_set_something_impl(ptr, rust_vec_len, data_len), +260 => wire__crate__api__misc_no_twin_example_a__StructWithSimpleSetterTwinNormal_simple_getter_impl(ptr, rust_vec_len, data_len), +261 => wire__crate__api__misc_no_twin_example_a__StructWithSimpleSetterTwinNormal_simple_setter_impl(ptr, rust_vec_len, data_len), +267 => 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), +309 => wire__crate__api__pseudo_manual__array_twin_sync__boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), +310 => wire__crate__api__pseudo_manual__array_twin_sync__func_test_id_twin_sync_impl(ptr, rust_vec_len, data_len), +311 => wire__crate__api__pseudo_manual__array_twin_sync__get_array_twin_sync_impl(ptr, rust_vec_len, data_len), +312 => wire__crate__api__pseudo_manual__array_twin_sync__get_complex_array_twin_sync_impl(ptr, rust_vec_len, data_len), +313 => wire__crate__api__pseudo_manual__array_twin_sync__last_number_twin_sync_impl(ptr, rust_vec_len, data_len), +314 => wire__crate__api__pseudo_manual__array_twin_sync__nested_id_twin_sync_impl(ptr, rust_vec_len, data_len), +315 => wire__crate__api__pseudo_manual__array_twin_sync__new_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), +316 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), +317 => wire__crate__api__pseudo_manual__array_twin_sync__return_boxed_raw_feed_id_twin_sync_impl(ptr, rust_vec_len, data_len), +318 => wire__crate__api__pseudo_manual__array_twin_sync__use_boxed_blob_twin_sync_impl(ptr, rust_vec_len, data_len), +319 => wire__crate__api__pseudo_manual__array_twin_sync__use_msgid_twin_sync_impl(ptr, rust_vec_len, data_len), +322 => wire__crate__api__pseudo_manual__attribute_twin_sync__handle_customized_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +323 => wire__crate__api__pseudo_manual__attribute_twin_sync__next_user_id_twin_sync_impl(ptr, rust_vec_len, data_len), +376 => 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), +377 => 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), +378 => 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), +379 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +380 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +381 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +382 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +383 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +384 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +385 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +386 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +387 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +388 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +389 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +390 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +391 => wire__crate__api__pseudo_manual__basic_list_twin_sync__example_basic_list_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +432 => 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), +433 => 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), +434 => 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), +435 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +436 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +437 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +438 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +439 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i128_twin_sync_impl(ptr, rust_vec_len, data_len), +440 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +441 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +442 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +443 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +444 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), +445 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +446 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u128_twin_sync_impl(ptr, rust_vec_len, data_len), +447 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +448 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +449 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +450 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +451 => wire__crate__api__pseudo_manual__basic_map_twin_sync__example_basic_map_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), +492 => 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), +493 => 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), +494 => 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), +495 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +496 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +497 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +498 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +499 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i128_twin_sync_impl(ptr, rust_vec_len, data_len), +500 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +501 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +502 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +503 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +504 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), +505 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +506 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u128_twin_sync_impl(ptr, rust_vec_len, data_len), +507 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +508 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +509 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +510 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +511 => wire__crate__api__pseudo_manual__basic_optional_twin_sync__example_basic_optional_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), +532 => 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), +533 => 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), +534 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_basic_struct_twin_sync_twin_sync_impl(ptr, rust_vec_len, data_len), +535 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bool_twin_sync_impl(ptr, rust_vec_len, data_len), +536 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +537 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f32_twin_sync_impl(ptr, rust_vec_len, data_len), +538 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_f64_twin_sync_impl(ptr, rust_vec_len, data_len), +539 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i128_twin_sync_impl(ptr, rust_vec_len, data_len), +540 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i16_twin_sync_impl(ptr, rust_vec_len, data_len), +541 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +542 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i64_twin_sync_impl(ptr, rust_vec_len, data_len), +543 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_i8_twin_sync_impl(ptr, rust_vec_len, data_len), +544 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_isize_twin_sync_impl(ptr, rust_vec_len, data_len), +545 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_string_twin_sync_impl(ptr, rust_vec_len, data_len), +546 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u128_twin_sync_impl(ptr, rust_vec_len, data_len), +547 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u16_twin_sync_impl(ptr, rust_vec_len, data_len), +548 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +549 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u64_twin_sync_impl(ptr, rust_vec_len, data_len), +550 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +551 => wire__crate__api__pseudo_manual__basic_twin_sync__example_basic_type_usize_twin_sync_impl(ptr, rust_vec_len, data_len), +582 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), +583 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +584 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_input_twin_sync_impl(ptr, rust_vec_len, data_len), +585 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), +586 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +587 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_binary_tree_output_twin_sync_impl(ptr, rust_vec_len, data_len), +588 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_json_twin_sync_impl(ptr, rust_vec_len, data_len), +589 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +590 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_input_twin_sync_impl(ptr, rust_vec_len, data_len), +591 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_json_twin_sync_impl(ptr, rust_vec_len, data_len), +592 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_protobuf_twin_sync_impl(ptr, rust_vec_len, data_len), +593 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_blob_output_twin_sync_impl(ptr, rust_vec_len, data_len), +594 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_input_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +595 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_output_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +596 => wire__crate__api__pseudo_manual__benchmark_api_twin_sync__benchmark_void_twin_sync_impl(ptr, rust_vec_len, data_len), +607 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_local_twin_sync_impl(ptr, rust_vec_len, data_len), +608 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), +609 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__duration_twin_sync_impl(ptr, rust_vec_len, data_len), +610 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_durations_twin_sync_impl(ptr, rust_vec_len, data_len), +611 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__handle_timestamps_twin_sync_impl(ptr, rust_vec_len, data_len), +612 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__how_long_does_it_take_twin_sync_impl(ptr, rust_vec_len, data_len), +613 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__naivedatetime_twin_sync_impl(ptr, rust_vec_len, data_len), +614 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__optional_empty_datetime_utc_twin_sync_impl(ptr, rust_vec_len, data_len), +615 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), +616 => wire__crate__api__pseudo_manual__chrono_type_twin_sync__test_precise_chrono_twin_sync_impl(ptr, rust_vec_len, data_len), +622 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_slash_star_star_twin_sync_impl(ptr, rust_vec_len, data_len), +623 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_multi_line_twin_sync_impl(ptr, rust_vec_len, data_len), +624 => wire__crate__api__pseudo_manual__comment_twin_sync__function_with_comments_triple_slash_single_line_twin_sync_impl(ptr, rust_vec_len, data_len), +625 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_instance_method_twin_sync_impl(ptr, rust_vec_len, data_len), +626 => wire__crate__api__pseudo_manual__comment_twin_sync__struct_with_comments_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), +652 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__async_accept_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +653 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__clone_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +654 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +655 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__create_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +656 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__drop_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +657 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_enum_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +658 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__get_nested_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +659 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_get_twin_sync_impl(ptr, rust_vec_len, data_len), +660 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_array_twin_sync_impl(ptr, rust_vec_len, data_len), +661 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_get_twin_sync_impl(ptr, rust_vec_len, data_len), +662 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_option_twin_sync_impl(ptr, rust_vec_len, data_len), +663 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_twin_sync_impl(ptr, rust_vec_len, data_len), +664 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_get_twin_sync_impl(ptr, rust_vec_len, data_len), +665 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__loop_back_vec_twin_sync_impl(ptr, rust_vec_len, data_len), +666 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__panic_unwrap_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +667 => wire__crate__api__pseudo_manual__dart_opaque_twin_sync__set_static_dart_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +672 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_create_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +673 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_get_drop_count_twin_sync_impl(ptr, rust_vec_len, data_len), +674 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +675 => wire__crate__api__pseudo_manual__dropping_twin_sync__DroppableTwinSync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), +686 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_simple_twin_sync_impl(ptr, rust_vec_len, data_len), +687 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_discriminant_twin_sync_impl(ptr, rust_vec_len, data_len), +688 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_mixed_twin_sync_impl(ptr, rust_vec_len, data_len), +689 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +690 => wire__crate__api__pseudo_manual__enumeration_twin_sync__func_enum_with_item_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), +691 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_parameter_twin_sync_impl(ptr, rust_vec_len, data_len), +692 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_enum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +693 => wire__crate__api__pseudo_manual__enumeration_twin_sync__handle_return_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +694 => wire__crate__api__pseudo_manual__enumeration_twin_sync__multiply_by_ten_twin_sync_impl(ptr, rust_vec_len, data_len), +695 => wire__crate__api__pseudo_manual__enumeration_twin_sync__print_note_twin_sync_impl(ptr, rust_vec_len, data_len), +729 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_panic_twin_sync_impl(ptr, rust_vec_len, data_len), +730 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +731 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_enum_error_return_ok_twin_sync_impl(ptr, rust_vec_len, data_len), +732 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_nested_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +733 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_error_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +734 => wire__crate__api__pseudo_manual__exception_twin_sync__custom_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +735 => 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), +736 => 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), +737 => 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), +738 => 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), +739 => wire__crate__api__pseudo_manual__exception_twin_sync__func_return_error_twin_sync_impl(ptr, rust_vec_len, data_len), +740 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_fallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), +741 => wire__crate__api__pseudo_manual__exception_twin_sync__func_type_infallible_panic_twin_sync_impl(ptr, rust_vec_len, data_len), +742 => wire__crate__api__pseudo_manual__exception_twin_sync__panic_with_custom_result_twin_sync_impl(ptr, rust_vec_len, data_len), +743 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_twin_sync_impl(ptr, rust_vec_len, data_len), +744 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_1_variant1_twin_sync_impl(ptr, rust_vec_len, data_len), +745 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_nested_error_2_twin_sync_impl(ptr, rust_vec_len, data_len), +746 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_error_twin_sync_impl(ptr, rust_vec_len, data_len), +747 => wire__crate__api__pseudo_manual__exception_twin_sync__return_custom_struct_ok_twin_sync_impl(ptr, rust_vec_len, data_len), +748 => wire__crate__api__pseudo_manual__exception_twin_sync__return_err_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +749 => wire__crate__api__pseudo_manual__exception_twin_sync__return_error_variant_twin_sync_impl(ptr, rust_vec_len, data_len), +750 => wire__crate__api__pseudo_manual__exception_twin_sync__return_ok_custom_error_twin_sync_impl(ptr, rust_vec_len, data_len), +751 => wire__crate__api__pseudo_manual__exception_twin_sync__some_struct_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +752 => 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), +753 => 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), +754 => 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), +755 => 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), +756 => wire__crate__api__pseudo_manual__exception_twin_sync__stream_sink_throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), +757 => wire__crate__api__pseudo_manual__exception_twin_sync__throw_anyhow_twin_sync_impl(ptr, rust_vec_len, data_len), +762 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_new_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), +763 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__call_old_module_system_twin_sync_impl(ptr, rust_vec_len, data_len), +764 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +765 => wire__crate__api__pseudo_manual__external_type_in_crate_twin_sync__use_imported_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +766 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructOneWithTraitTwinSync_get_one_impl(ptr, rust_vec_len, data_len), +767 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructOneWithTraitTwinSync_set_one_impl(ptr, rust_vec_len, data_len), +771 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructTwoWithTraitTwinSync_get_two_impl(ptr, rust_vec_len, data_len), +772 => wire__crate__api__pseudo_manual__impl_trait_twin_sync__StructTwoWithTraitTwinSync_set_two_impl(ptr, rust_vec_len, data_len), +787 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_i32_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +788 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_bytes_twin_sync_impl(ptr, rust_vec_len, data_len), +789 => 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), +790 => 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), +791 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_string_twin_sync_impl(ptr, rust_vec_len, data_len), +792 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_map_string_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +793 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +794 => wire__crate__api__pseudo_manual__map_and_set_twin_sync__func_hash_set_string_twin_sync_impl(ptr, rust_vec_len, data_len), +817 => wire__crate__api__pseudo_manual__method_twin_sync__StaticGetterOnlyTwinSync_static_getter_twin_sync_impl(ptr, rust_vec_len, data_len), +818 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_static_twin_sync_impl(ptr, rust_vec_len, data_len), +819 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_concatenate_twin_sync_impl(ptr, rust_vec_len, data_len), +820 => 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), +821 => 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), +822 => 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), +823 => 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), +824 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +825 => wire__crate__api__pseudo_manual__method_twin_sync__concatenate_with_twin_sync_simple_getter_twin_sync_impl(ptr, rust_vec_len, data_len), +826 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_array_twin_sync_impl(ptr, rust_vec_len, data_len), +827 => wire__crate__api__pseudo_manual__method_twin_sync__get_sum_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +828 => wire__crate__api__pseudo_manual__method_twin_sync__my_callable_twin_sync_call_impl(ptr, rust_vec_len, data_len), +829 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), +830 => wire__crate__api__pseudo_manual__method_twin_sync__simple_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), +831 => wire__crate__api__pseudo_manual__method_twin_sync__simple_primitive_enum_twin_sync_simple_method_twin_sync_impl(ptr, rust_vec_len, data_len), +832 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_arg_self_twin_sync_impl(ptr, rust_vec_len, data_len), +833 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +834 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_receiver_own_twin_sync_impl(ptr, rust_vec_len, data_len), +835 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_return_self_twin_sync_impl(ptr, rust_vec_len, data_len), +836 => wire__crate__api__pseudo_manual__method_twin_sync__simple_struct_twin_sync_vec_self_twin_sync_impl(ptr, rust_vec_len, data_len), +837 => wire__crate__api__pseudo_manual__method_twin_sync__static_only_twin_sync_static_method_twin_sync_impl(ptr, rust_vec_len, data_len), +838 => wire__crate__api__pseudo_manual__method_twin_sync__sum_with_twin_sync_sum_twin_sync_impl(ptr, rust_vec_len, data_len), +865 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +866 => wire__crate__api__pseudo_manual__mirror_twin_sync__app_settings_vec_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +867 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_number_twin_sync_impl(ptr, rust_vec_len, data_len), +868 => wire__crate__api__pseudo_manual__mirror_twin_sync__first_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), +869 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), +870 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_fallible_app_settings_twin_sync_impl(ptr, rust_vec_len, data_len), +871 => wire__crate__api__pseudo_manual__mirror_twin_sync__get_message_twin_sync_impl(ptr, rust_vec_len, data_len), +872 => wire__crate__api__pseudo_manual__mirror_twin_sync__is_app_embedded_twin_sync_impl(ptr, rust_vec_len, data_len), +873 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_array_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +874 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +875 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_map_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +876 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_option_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +877 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_set_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +878 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_struct_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +879 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_tuple_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +880 => wire__crate__api__pseudo_manual__mirror_twin_sync__mirror_vec_enum_stream_twin_sync_impl(ptr, rust_vec_len, data_len), +881 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_number_twin_sync_impl(ptr, rust_vec_len, data_len), +882 => wire__crate__api__pseudo_manual__mirror_twin_sync__repeat_sequence_twin_sync_impl(ptr, rust_vec_len, data_len), +883 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_contains_mirrored_sub_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +884 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_fallible_of_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +885 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_hashmap_with_mirrored_value_twin_sync_impl(ptr, rust_vec_len, data_len), +886 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_nested_enums_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +887 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_list_of_raw_nested_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +888 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_nested_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +889 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_enum_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +890 => wire__crate__api__pseudo_manual__mirror_twin_sync__test_raw_string_mirrored_twin_sync_impl(ptr, rust_vec_len, data_len), +902 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_big_buffers_twin_sync_impl(ptr, rust_vec_len, data_len), +903 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_char_twin_sync_impl(ptr, rust_vec_len, data_len), +904 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_complex_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +905 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_nested_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +906 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_string_twin_sync_impl(ptr, rust_vec_len, data_len), +907 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +908 => wire__crate__api__pseudo_manual__misc_example_twin_sync__handle_vec_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +909 => wire__crate__api__pseudo_manual__misc_example_twin_sync__list_of_primitive_enums_twin_sync_impl(ptr, rust_vec_len, data_len), +910 => wire__crate__api__pseudo_manual__misc_example_twin_sync__positional_arguments_twin_sync_impl(ptr, rust_vec_len, data_len), +911 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_abc_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +912 => wire__crate__api__pseudo_manual__misc_example_twin_sync__test_struct_with_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +917 => wire__crate__api__pseudo_manual__misc_type_twin_sync__empty_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +918 => wire__crate__api__pseudo_manual__misc_type_twin_sync__func_return_unit_twin_sync_impl(ptr, rust_vec_len, data_len), +919 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_list_of_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +920 => wire__crate__api__pseudo_manual__misc_type_twin_sync__handle_string_list_twin_sync_impl(ptr, rust_vec_len, data_len), +922 => wire__crate__api__pseudo_manual__newtype_pattern_twin_sync__handle_newtype_twin_sync_impl(ptr, rust_vec_len, data_len), +924 => wire__crate__api__pseudo_manual__optional_primitive_misc_twin_sync__primitive_optional_types_twin_sync_impl(ptr, rust_vec_len, data_len), +931 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_increment_boxed_optional_twin_sync_impl(ptr, rust_vec_len, data_len), +932 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_option_box_arguments_twin_sync_impl(ptr, rust_vec_len, data_len), +933 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_increment_twin_sync_impl(ptr, rust_vec_len, data_len), +934 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_return_twin_sync_impl(ptr, rust_vec_len, data_len), +935 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_optional_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +936 => wire__crate__api__pseudo_manual__optional_twin_sync__handle_vec_of_opts_twin_sync_impl(ptr, rust_vec_len, data_len), +943 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_i32_twin_sync_impl(ptr, rust_vec_len, data_len), +944 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_slice_string_twin_sync_impl(ptr, rust_vec_len, data_len), +945 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_slice_u8_twin_sync_impl(ptr, rust_vec_len, data_len), +946 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_str_twin_sync_impl(ptr, rust_vec_len, data_len), +947 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_string_twin_sync_impl(ptr, rust_vec_len, data_len), +948 => wire__crate__api__pseudo_manual__ownership_twin_sync__borrow_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +950 => wire__crate__api__pseudo_manual__primitive_list_misc_twin_sync__handle_vec_of_primitive_twin_sync_impl(ptr, rust_vec_len, data_len), +953 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_types_twin_sync_impl(ptr, rust_vec_len, data_len), +954 => wire__crate__api__pseudo_manual__primitive_misc_twin_sync__primitive_u32_twin_sync_impl(ptr, rust_vec_len, data_len), +957 => 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), +958 => wire__crate__api__pseudo_manual__raw_string_twin_sync__test_raw_string_item_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +971 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__StructWithGoodAndOpaqueFieldWithoutOptionTwinRustAsync_get_good_impl(ptr, rust_vec_len, data_len), +972 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_rust_async__StructWithGoodAndOpaqueFieldWithoutOptionTwinRustAsync_set_good_impl(ptr, rust_vec_len, data_len), +1005 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +1006 => 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), +1007 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +1008 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_getter_twin_sync_impl(ptr, rust_vec_len, data_len), +1009 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_instance_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +1010 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_custom_name_twin_sync_impl(ptr, rust_vec_len, data_len), +1011 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_twin_sync_impl(ptr, rust_vec_len, data_len), +1012 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_new_with_result_twin_sync_impl(ptr, rust_vec_len, data_len), +1013 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +1014 => 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), +1015 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +1016 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__NonCloneSimpleTwinSync_static_method_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +1017 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__StructWithGoodAndOpaqueFieldWithoutOptionTwinSync_get_good_impl(ptr, rust_vec_len, data_len), +1018 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__StructWithGoodAndOpaqueFieldWithoutOptionTwinSync_set_good_impl(ptr, rust_vec_len, data_len), +1020 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_borrow_twin_sync_impl(ptr, rust_vec_len, data_len), +1021 => 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), +1022 => 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), +1023 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_arg_own_twin_sync_impl(ptr, rust_vec_len, data_len), +1024 => 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), +1025 => 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), +1026 => 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), +1027 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +1028 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_callable_return_twin_sync_impl(ptr, rust_vec_len, data_len), +1029 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_dummy_twin_sync_impl(ptr, rust_vec_len, data_len), +1030 => 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), +1031 => 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), +1032 => 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), +1033 => 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), +1034 => 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), +1035 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_arg_twin_sync_impl(ptr, rust_vec_len, data_len), +1036 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_return_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +1037 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_return_twin_sync_impl(ptr, rust_vec_len, data_len), +1038 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_explicit_struct_twin_sync_impl(ptr, rust_vec_len, data_len), +1039 => 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), +1040 => 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), +1041 => 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), +1042 => 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), +1043 => 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), +1044 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_return_own_twin_sync_impl(ptr, rust_vec_len, data_len), +1045 => 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), +1046 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_sleep_twin_sync_impl(ptr, rust_vec_len, data_len), +1047 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_stream_sink_twin_sync_impl(ptr, rust_vec_len, data_len), +1048 => 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), +1049 => 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), +1050 => wire__crate__api__pseudo_manual__rust_auto_opaque_twin_sync__rust_auto_opaque_two_args_twin_sync_impl(ptr, rust_vec_len, data_len), +1066 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_array_opaque_enum_twin_sync_impl(ptr, rust_vec_len, data_len), +1067 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +1068 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +1069 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__create_option_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +1070 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__frb_generator_test_twin_sync_impl(ptr, rust_vec_len, data_len), +1071 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_run_twin_sync_impl(ptr, rust_vec_len, data_len), +1072 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_array_twin_sync_impl(ptr, rust_vec_len, data_len), +1073 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_run_twin_sync_impl(ptr, rust_vec_len, data_len), +1074 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__opaque_vec_twin_sync_impl(ptr, rust_vec_len, data_len), +1075 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_enum_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +1076 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_nested_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +1077 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_non_clone_twin_sync_impl(ptr, rust_vec_len, data_len), +1078 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +1079 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__run_opaque_with_delay_twin_sync_impl(ptr, rust_vec_len, data_len), +1080 => wire__crate__api__pseudo_manual__rust_opaque_twin_sync__unwrap_rust_opaque_twin_sync_impl(ptr, rust_vec_len, data_len), +1082 => wire__crate__api__pseudo_manual__simple_twin_sync__simple_adder_twin_sync_impl(ptr, rust_vec_len, data_len), +1101 => wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_dart_keyword_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1102 => wire__crate__api__pseudo_manual__structure_twin_sync__func_for_struct_with_field_rename_twin_sync_impl(ptr, rust_vec_len, data_len), +1103 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1104 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1105 => wire__crate__api__pseudo_manual__structure_twin_sync__func_struct_with_zero_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1106 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_one_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1107 => wire__crate__api__pseudo_manual__structure_twin_sync__func_tuple_struct_with_two_field_twin_sync_impl(ptr, rust_vec_len, data_len), +1110 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_2_twin_sync_impl(ptr, rust_vec_len, data_len), +1111 => wire__crate__api__pseudo_manual__tuple_twin_sync__test_tuple_twin_sync_impl(ptr, rust_vec_len, data_len), +1115 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), +1116 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_alias_model_twin_sync_impl(ptr, rust_vec_len, data_len), +1117 => wire__crate__api__pseudo_manual__type_alias_twin_sync__handle_type_nest_alias_id_twin_sync_impl(ptr, rust_vec_len, data_len), +1121 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_nested_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), +1122 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuid_twin_sync_impl(ptr, rust_vec_len, data_len), +1123 => wire__crate__api__pseudo_manual__uuid_type_twin_sync__handle_uuids_twin_sync_impl(ptr, rust_vec_len, data_len), +1138 => wire__crate__api__rust_auto_opaque__StructWithGoodAndOpaqueFieldWithoutOptionTwinNormal_get_good_impl(ptr, rust_vec_len, data_len), +1139 => wire__crate__api__rust_auto_opaque__StructWithGoodAndOpaqueFieldWithoutOptionTwinNormal_set_good_impl(ptr, rust_vec_len, data_len), +1187 => wire__crate__api__rust_opaque_sync__frb_sync_generator_test_twin_normal_impl(ptr, rust_vec_len, data_len), +1188 => wire__crate__api__rust_opaque_sync__sync_create_non_clone_twin_normal_impl(ptr, rust_vec_len, data_len), +1189 => wire__crate__api__rust_opaque_sync__sync_create_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), +1190 => wire__crate__api__rust_opaque_sync__sync_option_rust_opaque_twin_normal_impl(ptr, rust_vec_len, data_len), _ => unreachable!(), } } @@ -40142,6 +40685,26 @@ impl flutter_rust_bridge::IntoIntoDart> for Opaque } } +// 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 SimpleOpaqueExternalStructWithMethod +{ + fn into_into_dart(self) -> FrbWrapper { + self.into() + } +} + // 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 { @@ -46123,6 +46686,33 @@ impl flutter_rust_bridge::IntoIntoDart flutter_rust_bridge::for_generated::DartAbi { + [ + self.field_i64.into_into_dart().into_dart(), + self.field_u64.into_into_dart().into_dart(), + self.field_i32.into_into_dart().into_dart(), + self.field_vec_u8.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal, + > for crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal +{ + fn into_into_dart(self) -> crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs impl flutter_rust_bridge::IntoDart for crate::api::comment::StructWithCommentsTwinNormal { fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { [self.field_with_comments.into_into_dart().into_dart()].into_dart() @@ -46209,6 +46799,69 @@ impl } } // Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::structure::StructWithDartKeywordFieldTwinNormal { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.class.into_into_dart().into_dart(), + self.interface.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::structure::StructWithDartKeywordFieldTwinNormal +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::api::structure::StructWithDartKeywordFieldTwinNormal +{ + fn into_into_dart(self) -> crate::api::structure::StructWithDartKeywordFieldTwinNormal { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.class.into_into_dart().into_dart(), +self.interface.into_into_dart().into_dart() + ].into_dart() + } + } +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync {} +impl flutter_rust_bridge::IntoIntoDart for crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + fn into_into_dart(self) -> crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + self + } + } +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.class.into_into_dart().into_dart(), + self.interface.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync, + > for crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync +{ + fn into_into_dart( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync { + 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 { [ @@ -46341,6 +46994,70 @@ impl flutter_rust_bridge::IntoIntoDart flutter_rust_bridge::for_generated::DartAbi { + [self.class.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::structure::StructWithFieldRenameTwinNormal +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::api::structure::StructWithFieldRenameTwinNormal +{ + fn into_into_dart(self) -> crate::api::structure::StructWithFieldRenameTwinNormal { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.class.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync, + > for crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync +{ + fn into_into_dart( + self, + ) -> crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync + { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart + for crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync +{ + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.class.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync +{ +} +impl + flutter_rust_bridge::IntoIntoDart< + crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync, + > for crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync +{ + fn into_into_dart( + self, + ) -> crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs impl flutter_rust_bridge::IntoDart for crate::api::rust_auto_opaque::StructWithGoodAndOpaqueFieldTwinNormal { @@ -47813,6 +48530,20 @@ impl SseEncode for OpaqueTwoTwinSync { } } +impl SseEncode for SimpleOpaqueExternalStructWithMethod { + // 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 StaticGetterOnlyTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -48063,6 +48794,16 @@ impl SseEncode for chrono::DateTime { } } +impl SseEncode for MessageWithCustomSerializerTwinNormal { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode( + crate::api::custom_ser_des::serializer_my_type(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) { @@ -49092,6 +49833,21 @@ impl SseEncode } } +impl SseEncode + for RustOpaqueMoi< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + > +{ + // 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 RustOpaqueMoi< flutter_rust_bridge::for_generated::RustAutoOpaqueInner, @@ -55480,6 +56236,16 @@ impl SseEncode for crate::deliberate_name_conflict::StructInUpperLevel { } } +impl SseEncode for crate::api::casted_primitive::StructWithCastedPrimitiveTwinNormal { + // 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.field_i64, serializer); + ::sse_encode(self.field_u64, serializer); + ::sse_encode(self.field_i32, serializer); + >::sse_encode(self.field_vec_u8, serializer); + } +} + impl SseEncode for crate::api::comment::StructWithCommentsTwinNormal { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -55510,6 +56276,30 @@ impl SseEncode for crate::api::misc_no_twin_example_a::StructWithCustomNameMetho } } +impl SseEncode for crate::api::structure::StructWithDartKeywordFieldTwinNormal { + // 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.class, serializer); + ::sse_encode(self.interface, serializer); + } +} + +impl SseEncode for crate::api::pseudo_manual::structure_twin_rust_async::StructWithDartKeywordFieldTwinRustAsync { + // 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.class, serializer); +::sse_encode(self.interface, serializer);} + } + +impl SseEncode + for crate::api::pseudo_manual::structure_twin_sync::StructWithDartKeywordFieldTwinSync +{ + // 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.class, serializer); + ::sse_encode(self.interface, 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) { @@ -55564,6 +56354,29 @@ impl SseEncode for crate::api::pseudo_manual::rust_auto_opaque_twin_sync::Struct ::sse_encode(self.normal, serializer);} } +impl SseEncode for crate::api::structure::StructWithFieldRenameTwinNormal { + // 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.class, serializer); + } +} + +impl SseEncode + for crate::api::pseudo_manual::structure_twin_rust_async::StructWithFieldRenameTwinRustAsync +{ + // 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.class, serializer); + } +} + +impl SseEncode for crate::api::pseudo_manual::structure_twin_sync::StructWithFieldRenameTwinSync { + // 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.class, serializer); + } +} + impl SseEncode for crate::api::rust_auto_opaque::StructWithGoodAndOpaqueFieldTwinNormal { // 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/rust/src/frb_generated.web.rs b/frb_example/pure_dart_pde/rust/src/frb_generated.web.rs index af5097d66c..61e132ee9b 100644 --- a/frb_example/pure_dart_pde/rust/src/frb_generated.web.rs +++ b/frb_example/pure_dart_pde/rust/src/frb_generated.web.rs @@ -5,10 +5,12 @@ use super::*; use crate::api::constructor::*; +use crate::api::custom_ser_des::*; use crate::api::dart_code::*; use crate::api::dropping::*; use crate::api::dyn_trait::SimpleTraitForDynTwinNormal; use crate::api::dyn_trait::*; +use crate::api::external_impl::*; use crate::api::impl_trait::SimpleTraitTwinNormal; use crate::api::impl_trait::*; use crate::api::method::*; @@ -840,6 +842,28 @@ pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generat MoiArc::>::decrement_strong_count(ptr as _); } +#[wasm_bindgen] +pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr: *const std::ffi::c_void, +) { + MoiArc::< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >::increment_strong_count(ptr as _); +} + +#[wasm_bindgen] +pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerSimpleOpaqueExternalStructWithMethod( + ptr: *const std::ffi::c_void, +) { + MoiArc::< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner< + SimpleOpaqueExternalStructWithMethod, + >, + >::decrement_strong_count(ptr as _); +} + #[wasm_bindgen] pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerStaticGetterOnlyTwinNormal( ptr: *const std::ffi::c_void, diff --git a/frb_example/pure_dart_pde/test/api/casted_primitive_test.dart b/frb_example/pure_dart_pde/test/api/casted_primitive_test.dart new file mode 100644 index 0000000000..3bb88d6147 --- /dev/null +++ b/frb_example/pure_dart_pde/test/api/casted_primitive_test.dart @@ -0,0 +1,35 @@ +// AUTO-GENERATED FROM frb_example/pure_dart, DO NOT EDIT + +// FRB_INTERNAL_GENERATOR: {"forbiddenDuplicatorModes": ["sync", "rustAsync", "sse", "sync sse", "rustAsync sse"]} + +import 'dart:typed_data'; + +import 'package:frb_example_pure_dart_pde/src/rust/api/casted_primitive.dart'; +import 'package:frb_example_pure_dart_pde/src/rust/frb_generated.dart'; +import 'package:test/test.dart'; + +import '../test_utils.dart'; + +Future main({bool skipRustLibInit = false}) async { + if (!skipRustLibInit) await RustLib.init(); + + addTestsIdentityFunctionCall( + castedPrimitiveI64TwinNormal, [0, -1000000000, 1000000000]); + addTestsIdentityFunctionCall( + castedPrimitiveU64TwinNormal, [0, 1000000000]); + addTestsIdentityFunctionCall( + castedPrimitiveIsizeTwinNormal, [0, -1000000000, 1000000000]); + addTestsIdentityFunctionCall( + castedPrimitiveUsizeTwinNormal, [0, 1000000000]); + + test('StructWithCastedPrimitiveTwinNormal', () async { + await functionForStructWithCastedPrimitiveTwinNormal( + arg: StructWithCastedPrimitiveTwinNormal( + fieldI64: 1000000000, + fieldU64: 2000000000, + fieldI32: 123456789, + fieldVecU8: Uint8List.fromList([10, 20, 100]), + ), + ); + }); +} diff --git a/frb_example/pure_dart_pde/test/api/custom_ser_des_test.dart b/frb_example/pure_dart_pde/test/api/custom_ser_des_test.dart new file mode 100644 index 0000000000..5d801ce2be --- /dev/null +++ b/frb_example/pure_dart_pde/test/api/custom_ser_des_test.dart @@ -0,0 +1,16 @@ +// AUTO-GENERATED FROM frb_example/pure_dart, DO NOT EDIT + +// FRB_INTERNAL_GENERATOR: {"forbiddenDuplicatorModes": ["sync", "rustAsync", "sse", "sync sse", "rustAsync sse"]} + +import 'package:frb_example_pure_dart_pde/src/rust/api/custom_ser_des.dart'; +import 'package:frb_example_pure_dart_pde/src/rust/frb_generated.dart'; +import 'package:test/test.dart'; + +Future main({bool skipRustLibInit = false}) async { + if (!skipRustLibInit) await RustLib.init(); + + test('custom serializer', () async { + expect( + await functionUsingTypeWithCustomSerializer(arg: 123456789), 123456789); + }); +} diff --git a/frb_example/pure_dart_pde/test/dart_valgrind_test_entrypoint.dart b/frb_example/pure_dart_pde/test/dart_valgrind_test_entrypoint.dart index e212a1628c..cc0b130af4 100644 --- a/frb_example/pure_dart_pde/test/dart_valgrind_test_entrypoint.dart +++ b/frb_example/pure_dart_pde/test/dart_valgrind_test_entrypoint.dart @@ -11,9 +11,11 @@ import 'api/array_test.dart' as array_test; import 'api/async_misc_test.dart' as async_misc_test; import 'api/async_spawn_test.dart' as async_spawn_test; import 'api/attribute_test.dart' as attribute_test; +import 'api/casted_primitive_test.dart' as casted_primitive_test; import 'api/chrono_type_test.dart' as chrono_type_test; import 'api/comment_test.dart' as comment_test; import 'api/constructor_test.dart' as constructor_test; +import 'api/custom_ser_des_test.dart' as custom_ser_des_test; import 'api/customization_test.dart' as customization_test; import 'api/dart_code_test.dart' as dart_code_test; import 'api/dart_fn_test.dart' as dart_fn_test; @@ -205,9 +207,11 @@ Future callFileEntrypoints() async { await async_misc_test.main(skipRustLibInit: true); await async_spawn_test.main(skipRustLibInit: true); await attribute_test.main(skipRustLibInit: true); + await casted_primitive_test.main(skipRustLibInit: true); await chrono_type_test.main(skipRustLibInit: true); await comment_test.main(skipRustLibInit: true); await constructor_test.main(skipRustLibInit: true); + await custom_ser_des_test.main(skipRustLibInit: true); await customization_test.main(skipRustLibInit: true); await dart_code_test.main(skipRustLibInit: true); await dart_fn_test.main(skipRustLibInit: true); diff --git a/website/docs/guides/types/translatable/custom.md b/website/docs/guides/types/translatable/custom.md new file mode 100644 index 0000000000..05d2e17e0b --- /dev/null +++ b/website/docs/guides/types/translatable/custom.md @@ -0,0 +1,38 @@ +# Custom encoder/decoders + +We can customize how a type is encoded and decoded. + +## Example + +Suppose we have a `FancyRustType` and corresponding type `FancyDartType` +(they can be the same name, here we use different names just to make it clearer). +If we want to encode it using a `String` (can use arbitrary complex types as long as flutter_rust_bridge supports), +then we can write code like below: + +```rust +#[frb(rust2dart(dart_type = "FancyDartType", dart_code = "FancyDartType.letsParseIt({})"))] +pub fn encode_fancy_type(raw: FancyRustType) -> String { ... } + +#[frb(dart2rust(dart_type = "FancyDartType", dart_code = "{}.letsEncodeIt()"))] +pub fn decode_fancy_type(raw: String) -> FancyRustType { ... } +``` + +The function names above are arbitrarily chosen. +Then, whenever we are using `FancyType`, such as: + +```rust +pub fn f(a: FancyRustType) { ... } +``` + +It will be automatically converted to: + +```dart +void f(FancyDartType a) { ... } +``` + +And under the hood, the type will be encoded/decoded via the custom functions. + +## Remarks + +* If the Dart types need some `import`s to work, the `dart_preamble` config key in `flutter_rust_bridge.yaml` can be utilized to import things. +* If the encoding/decoding process returns a `Result`, currently you can `unwrap()` it to convert it to a panic. diff --git a/website/docs/guides/types/translatable/detailed/primitive.md b/website/docs/guides/types/translatable/detailed/primitive.md new file mode 100644 index 0000000000..51b9d76c66 --- /dev/null +++ b/website/docs/guides/types/translatable/detailed/primitive.md @@ -0,0 +1,8 @@ +# Primitives + +Types like `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `isize`, `usize`, `i128`, `u128` +will be converted to `int` or `BigInt` depending on whether they fit in the integer. + +In addition, the `#[frb(type_64bit_int)]` can be utilized to force the 64bit types to be integers. + +For other types like `f32`, `f64`, `bool`, `String`, please refer to the simple correspondence table for the mapping. diff --git a/website/docs/guides/types/translatable/detailed/struct.md b/website/docs/guides/types/translatable/detailed/struct.md index 42b3aeb247..79a4c48cd6 100644 --- a/website/docs/guides/types/translatable/detailed/struct.md +++ b/website/docs/guides/types/translatable/detailed/struct.md @@ -30,6 +30,21 @@ See below for an example. If you want the generated Dart class to be [`freezed`](https://pub.dev/packages/freezed) (which is like data-classes in other languages like Kotlin), simply put `#[frb(dart_metadata=("freezed"))]` and it will generate everything needed for you. +## Rename fields + +The `#[frb(name = "...")]` can be utilized to change the Dart name of a struct field. +For example: + +```rust +#[frb] +pub struct MyStruct { + #[frb(name = "dartFieldName")] + pub rust_field_name: Vec, +} +``` + +It will give a Dart class with field `dartFieldName`. + ## Example ### Example 1: Recursive fields diff --git a/website/docs/guides/types/translatable/simple-correspondence.md b/website/docs/guides/types/translatable/simple-correspondence.md index ab7ffb420b..0404f2785d 100644 --- a/website/docs/guides/types/translatable/simple-correspondence.md +++ b/website/docs/guides/types/translatable/simple-correspondence.md @@ -1,6 +1,7 @@ # Simple correspondence -Here is a brief glance showing what the code generator can generate (non-exhaustive). Some rows have hyper-links pointing to more detailed explanations. +Here is a brief glance showing what the code generator can generate (non-exhaustive). Some rows have hyper-links +pointing to more detailed explanations. | Rust | Dart | |------------------------------------------------------------|-----------------------------------------------------------| @@ -23,11 +24,10 @@ Here is a brief glance showing what the code generator can generate (non-exhaust | [`Result::Err`, panic](return) | `throw Exception` | | `Box` | `T` | | comments | same | -| `i8`, `u8`, .., `usize` | `int` | +| `i8`, `u8`, .., `usize`, `i128`, `u128` | [`int`, `BigInt`](detailed/primitive) | | `f32`, `f64` | `double` | | `bool` | `bool` | -| `char` | `String` | -| `String` | `String` | +| `char`, `String` | `String` | | `()` | `void` | | `type A = B` | [type alias](detailed/alias) | | [`(T, U, ..)`](detailed/tuple) | [`(T, U, ..)`](https://dart.dev/language/records) | @@ -35,4 +35,5 @@ Here is a brief glance showing what the code generator can generate (non-exhaust Types from `chrono` crate are supported as a feature, see [here](detailed/chrono). Types from `uuid` crate are supported as a feature, see [here](detailed/uuid). -Raw strings are supported for struct field names. For example, you can have `struct S { r#type: i32 }`. In dart, the `r#` prefix will be correctly removed. They are not yet supported for function arguments. +Raw strings are supported for struct field names. For example, you can have `struct S { r#type: i32 }`. In dart, +the `r#` prefix will be correctly removed. They are not yet supported for function arguments. diff --git a/website/sidebars.js b/website/sidebars.js index beaed48995..abd44407b0 100644 --- a/website/sidebars.js +++ b/website/sidebars.js @@ -73,10 +73,12 @@ const sidebars = { 'guides/types/translatable/detailed/map_set', 'guides/types/translatable/detailed/chrono', 'guides/types/translatable/detailed/uuid', + 'guides/types/translatable/detailed/primitive', ], }, 'guides/types/translatable/return', 'guides/types/translatable/stream', + 'guides/types/translatable/custom', 'guides/types/translatable/zero-copy', { type: 'category',