frb_generated.rs · ondeinference/onde

@ondeinference / onde

Code Commits Issues Pulls Cloud Agent CI/CD

main

copilot/assess-inference-engine-complexity copilot/fix-onde-npm-sdk-v1-1-2-release development feature/diffusion-vision main

rs 2,647 lines 108 KB

Raw

1	// This file is automatically generated, so please do not edit it.
2	// @generated by `flutter_rust_bridge`@ 2.12.0.
3
4	#![allow(
5	non_camel_case_types,
6	unused,
7	non_snake_case,
8	clippy::needless_return,
9	clippy::redundant_closure_call,
10	clippy::redundant_closure,
11	clippy::useless_conversion,
12	clippy::unit_arg,
13	clippy::unused_unit,
14	clippy::double_parens,
15	clippy::let_and_return,
16	clippy::too_many_arguments,
17	clippy::match_single_binding,
18	clippy::clone_on_copy,
19	clippy::let_unit_value,
20	clippy::deref_addrof,
21	clippy::explicit_auto_deref,
22	clippy::borrow_deref_ref,
23	clippy::uninlined_format_args,
24	clippy::needless_borrow
25	)]
26
27	// Section: imports
28
29	use crate::api::*;
30	use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
31	use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
32	use flutter_rust_bridge::{Handler, IntoIntoDart};
33
34	// Section: boilerplate
35
36	flutter_rust_bridge::frb_generated_boilerplate!(
37	default_stream_sink_codec = SseCodec,
38	default_rust_opaque = RustOpaqueMoi,
39	default_rust_auto_opaque = RustAutoOpaqueMoi,
40	);
41	pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.12.0";
42	pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1633970317;
43
44	// Section: executor
45
46	flutter_rust_bridge::frb_generated_default_handler!();
47
48	// Section: wire_funcs
49
50	fn wire__crate__api__OndeChatEngine_clear_history_impl(
51	port_: flutter_rust_bridge::for_generated::MessagePort,
52	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
53	rust_vec_len_: i32,
54	data_len_: i32,
55	) {
56	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
57	flutter_rust_bridge::for_generated::TaskInfo {
58	debug_name: "OndeChatEngine_clear_history",
59	port: Some(port_),
60	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
61	},
62	move \|\| {
63	let message = unsafe {
64	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
65	ptr_,
66	rust_vec_len_,
67	data_len_,
68	)
69	};
70	let mut deserializer =
71	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
72	let api_that = <RustOpaqueMoi<
73	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
74	>>::sse_decode(&mut deserializer);
75	deserializer.end();
76	move \|context\| async move {
77	transform_result_sse::<_, ()>(
78	(move \|\| async move {
79	let mut api_that_guard = None;
80	let decode_indices_ =
81	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
82	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
83	&api_that, 0, false,
84	)],
85	);
86	for i in decode_indices_ {
87	match i {
88	0 => {
89	api_that_guard =
90	Some(api_that.lockable_decode_async_ref().await)
91	}
92	_ => unreachable!(),
93	}
94	}
95	let api_that_guard = api_that_guard.unwrap();
96	let output_ok = Result::<_, ()>::Ok(
97	crate::api::OndeChatEngine::clear_history(&*api_that_guard).await,
98	)?;
99	Ok(output_ok)
100	})()
101	.await,
102	)
103	}
104	},
105	)
106	}
107	fn wire__crate__api__OndeChatEngine_clear_system_prompt_impl(
108	port_: flutter_rust_bridge::for_generated::MessagePort,
109	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
110	rust_vec_len_: i32,
111	data_len_: i32,
112	) {
113	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
114	flutter_rust_bridge::for_generated::TaskInfo {
115	debug_name: "OndeChatEngine_clear_system_prompt",
116	port: Some(port_),
117	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
118	},
119	move \|\| {
120	let message = unsafe {
121	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
122	ptr_,
123	rust_vec_len_,
124	data_len_,
125	)
126	};
127	let mut deserializer =
128	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
129	let api_that = <RustOpaqueMoi<
130	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
131	>>::sse_decode(&mut deserializer);
132	deserializer.end();
133	move \|context\| async move {
134	transform_result_sse::<_, ()>(
135	(move \|\| async move {
136	let mut api_that_guard = None;
137	let decode_indices_ =
138	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
139	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
140	&api_that, 0, false,
141	)],
142	);
143	for i in decode_indices_ {
144	match i {
145	0 => {
146	api_that_guard =
147	Some(api_that.lockable_decode_async_ref().await)
148	}
149	_ => unreachable!(),
150	}
151	}
152	let api_that_guard = api_that_guard.unwrap();
153	let output_ok = Result::<_, ()>::Ok({
154	crate::api::OndeChatEngine::clear_system_prompt(&*api_that_guard).await;
155	})?;
156	Ok(output_ok)
157	})()
158	.await,
159	)
160	}
161	},
162	)
163	}
164	fn wire__crate__api__OndeChatEngine_generate_impl(
165	port_: flutter_rust_bridge::for_generated::MessagePort,
166	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
167	rust_vec_len_: i32,
168	data_len_: i32,
169	) {
170	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
171	flutter_rust_bridge::for_generated::TaskInfo {
172	debug_name: "OndeChatEngine_generate",
173	port: Some(port_),
174	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
175	},
176	move \|\| {
177	let message = unsafe {
178	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
179	ptr_,
180	rust_vec_len_,
181	data_len_,
182	)
183	};
184	let mut deserializer =
185	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
186	let api_that = <RustOpaqueMoi<
187	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
188	>>::sse_decode(&mut deserializer);
189	let api_messages = <Vec<crate::api::ChatMessage>>::sse_decode(&mut deserializer);
190	let api_sampling = <Option<crate::api::SamplingConfig>>::sse_decode(&mut deserializer);
191	deserializer.end();
192	move \|context\| async move {
193	transform_result_sse::<_, crate::api::OndeError>(
194	(move \|\| async move {
195	let mut api_that_guard = None;
196	let decode_indices_ =
197	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
198	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
199	&api_that, 0, false,
200	)],
201	);
202	for i in decode_indices_ {
203	match i {
204	0 => {
205	api_that_guard =
206	Some(api_that.lockable_decode_async_ref().await)
207	}
208	_ => unreachable!(),
209	}
210	}
211	let api_that_guard = api_that_guard.unwrap();
212	let output_ok = crate::api::OndeChatEngine::generate(
213	&*api_that_guard,
214	api_messages,
215	api_sampling,
216	)
217	.await?;
218	Ok(output_ok)
219	})()
220	.await,
221	)
222	}
223	},
224	)
225	}
226	fn wire__crate__api__OndeChatEngine_history_impl(
227	port_: flutter_rust_bridge::for_generated::MessagePort,
228	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
229	rust_vec_len_: i32,
230	data_len_: i32,
231	) {
232	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
233	flutter_rust_bridge::for_generated::TaskInfo {
234	debug_name: "OndeChatEngine_history",
235	port: Some(port_),
236	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
237	},
238	move \|\| {
239	let message = unsafe {
240	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
241	ptr_,
242	rust_vec_len_,
243	data_len_,
244	)
245	};
246	let mut deserializer =
247	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
248	let api_that = <RustOpaqueMoi<
249	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
250	>>::sse_decode(&mut deserializer);
251	deserializer.end();
252	move \|context\| async move {
253	transform_result_sse::<_, ()>(
254	(move \|\| async move {
255	let mut api_that_guard = None;
256	let decode_indices_ =
257	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
258	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
259	&api_that, 0, false,
260	)],
261	);
262	for i in decode_indices_ {
263	match i {
264	0 => {
265	api_that_guard =
266	Some(api_that.lockable_decode_async_ref().await)
267	}
268	_ => unreachable!(),
269	}
270	}
271	let api_that_guard = api_that_guard.unwrap();
272	let output_ok = Result::<_, ()>::Ok(
273	crate::api::OndeChatEngine::history(&*api_that_guard).await,
274	)?;
275	Ok(output_ok)
276	})()
277	.await,
278	)
279	}
280	},
281	)
282	}
283	fn wire__crate__api__OndeChatEngine_info_impl(
284	port_: flutter_rust_bridge::for_generated::MessagePort,
285	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
286	rust_vec_len_: i32,
287	data_len_: i32,
288	) {
289	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
290	flutter_rust_bridge::for_generated::TaskInfo {
291	debug_name: "OndeChatEngine_info",
292	port: Some(port_),
293	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
294	},
295	move \|\| {
296	let message = unsafe {
297	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
298	ptr_,
299	rust_vec_len_,
300	data_len_,
301	)
302	};
303	let mut deserializer =
304	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
305	let api_that = <RustOpaqueMoi<
306	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
307	>>::sse_decode(&mut deserializer);
308	deserializer.end();
309	move \|context\| async move {
310	transform_result_sse::<_, ()>(
311	(move \|\| async move {
312	let mut api_that_guard = None;
313	let decode_indices_ =
314	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
315	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
316	&api_that, 0, false,
317	)],
318	);
319	for i in decode_indices_ {
320	match i {
321	0 => {
322	api_that_guard =
323	Some(api_that.lockable_decode_async_ref().await)
324	}
325	_ => unreachable!(),
326	}
327	}
328	let api_that_guard = api_that_guard.unwrap();
329	let output_ok = Result::<_, ()>::Ok(
330	crate::api::OndeChatEngine::info(&*api_that_guard).await,
331	)?;
332	Ok(output_ok)
333	})()
334	.await,
335	)
336	}
337	},
338	)
339	}
340	fn wire__crate__api__OndeChatEngine_is_loaded_impl(
341	port_: flutter_rust_bridge::for_generated::MessagePort,
342	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
343	rust_vec_len_: i32,
344	data_len_: i32,
345	) {
346	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
347	flutter_rust_bridge::for_generated::TaskInfo {
348	debug_name: "OndeChatEngine_is_loaded",
349	port: Some(port_),
350	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
351	},
352	move \|\| {
353	let message = unsafe {
354	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
355	ptr_,
356	rust_vec_len_,
357	data_len_,
358	)
359	};
360	let mut deserializer =
361	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
362	let api_that = <RustOpaqueMoi<
363	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
364	>>::sse_decode(&mut deserializer);
365	deserializer.end();
366	move \|context\| async move {
367	transform_result_sse::<_, ()>(
368	(move \|\| async move {
369	let mut api_that_guard = None;
370	let decode_indices_ =
371	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
372	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
373	&api_that, 0, false,
374	)],
375	);
376	for i in decode_indices_ {
377	match i {
378	0 => {
379	api_that_guard =
380	Some(api_that.lockable_decode_async_ref().await)
381	}
382	_ => unreachable!(),
383	}
384	}
385	let api_that_guard = api_that_guard.unwrap();
386	let output_ok = Result::<_, ()>::Ok(
387	crate::api::OndeChatEngine::is_loaded(&*api_that_guard).await,
388	)?;
389	Ok(output_ok)
390	})()
391	.await,
392	)
393	}
394	},
395	)
396	}
397	fn wire__crate__api__OndeChatEngine_load_assigned_model_impl(
398	port_: flutter_rust_bridge::for_generated::MessagePort,
399	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
400	rust_vec_len_: i32,
401	data_len_: i32,
402	) {
403	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
404	flutter_rust_bridge::for_generated::TaskInfo {
405	debug_name: "OndeChatEngine_load_assigned_model",
406	port: Some(port_),
407	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
408	},
409	move \|\| {
410	let message = unsafe {
411	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
412	ptr_,
413	rust_vec_len_,
414	data_len_,
415	)
416	};
417	let mut deserializer =
418	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
419	let api_that = <RustOpaqueMoi<
420	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
421	>>::sse_decode(&mut deserializer);
422	let api_app_id = <String>::sse_decode(&mut deserializer);
423	let api_app_secret = <String>::sse_decode(&mut deserializer);
424	let api_system_prompt = <Option<String>>::sse_decode(&mut deserializer);
425	let api_sampling = <Option<crate::api::SamplingConfig>>::sse_decode(&mut deserializer);
426	deserializer.end();
427	move \|context\| async move {
428	transform_result_sse::<_, crate::api::OndeError>(
429	(move \|\| async move {
430	let mut api_that_guard = None;
431	let decode_indices_ =
432	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
433	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
434	&api_that, 0, false,
435	)],
436	);
437	for i in decode_indices_ {
438	match i {
439	0 => {
440	api_that_guard =
441	Some(api_that.lockable_decode_async_ref().await)
442	}
443	_ => unreachable!(),
444	}
445	}
446	let api_that_guard = api_that_guard.unwrap();
447	let output_ok = crate::api::OndeChatEngine::load_assigned_model(
448	&*api_that_guard,
449	api_app_id,
450	api_app_secret,
451	api_system_prompt,
452	api_sampling,
453	)
454	.await?;
455	Ok(output_ok)
456	})()
457	.await,
458	)
459	}
460	},
461	)
462	}
463	fn wire__crate__api__OndeChatEngine_load_gguf_model_impl(
464	port_: flutter_rust_bridge::for_generated::MessagePort,
465	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
466	rust_vec_len_: i32,
467	data_len_: i32,
468	) {
469	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
470	flutter_rust_bridge::for_generated::TaskInfo {
471	debug_name: "OndeChatEngine_load_gguf_model",
472	port: Some(port_),
473	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
474	},
475	move \|\| {
476	let message = unsafe {
477	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
478	ptr_,
479	rust_vec_len_,
480	data_len_,
481	)
482	};
483	let mut deserializer =
484	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
485	let api_that = <RustOpaqueMoi<
486	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
487	>>::sse_decode(&mut deserializer);
488	let api_config = <crate::api::GgufModelConfig>::sse_decode(&mut deserializer);
489	let api_system_prompt = <Option<String>>::sse_decode(&mut deserializer);
490	let api_sampling = <Option<crate::api::SamplingConfig>>::sse_decode(&mut deserializer);
491	deserializer.end();
492	move \|context\| async move {
493	transform_result_sse::<_, crate::api::OndeError>(
494	(move \|\| async move {
495	let mut api_that_guard = None;
496	let decode_indices_ =
497	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
498	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
499	&api_that, 0, false,
500	)],
501	);
502	for i in decode_indices_ {
503	match i {
504	0 => {
505	api_that_guard =
506	Some(api_that.lockable_decode_async_ref().await)
507	}
508	_ => unreachable!(),
509	}
510	}
511	let api_that_guard = api_that_guard.unwrap();
512	let output_ok = crate::api::OndeChatEngine::load_gguf_model(
513	&*api_that_guard,
514	api_config,
515	api_system_prompt,
516	api_sampling,
517	)
518	.await?;
519	Ok(output_ok)
520	})()
521	.await,
522	)
523	}
524	},
525	)
526	}
527	fn wire__crate__api__OndeChatEngine_load_uqff_model_impl(
528	port_: flutter_rust_bridge::for_generated::MessagePort,
529	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
530	rust_vec_len_: i32,
531	data_len_: i32,
532	) {
533	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
534	flutter_rust_bridge::for_generated::TaskInfo {
535	debug_name: "OndeChatEngine_load_uqff_model",
536	port: Some(port_),
537	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
538	},
539	move \|\| {
540	let message = unsafe {
541	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
542	ptr_,
543	rust_vec_len_,
544	data_len_,
545	)
546	};
547	let mut deserializer =
548	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
549	let api_that = <RustOpaqueMoi<
550	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
551	>>::sse_decode(&mut deserializer);
552	let api_config = <crate::api::UqffModelConfig>::sse_decode(&mut deserializer);
553	let api_system_prompt = <Option<String>>::sse_decode(&mut deserializer);
554	let api_sampling = <Option<crate::api::SamplingConfig>>::sse_decode(&mut deserializer);
555	deserializer.end();
556	move \|context\| async move {
557	transform_result_sse::<_, crate::api::OndeError>(
558	(move \|\| async move {
559	let mut api_that_guard = None;
560	let decode_indices_ =
561	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
562	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
563	&api_that, 0, false,
564	)],
565	);
566	for i in decode_indices_ {
567	match i {
568	0 => {
569	api_that_guard =
570	Some(api_that.lockable_decode_async_ref().await)
571	}
572	_ => unreachable!(),
573	}
574	}
575	let api_that_guard = api_that_guard.unwrap();
576	let output_ok = crate::api::OndeChatEngine::load_uqff_model(
577	&*api_that_guard,
578	api_config,
579	api_system_prompt,
580	api_sampling,
581	)
582	.await?;
583	Ok(output_ok)
584	})()
585	.await,
586	)
587	}
588	},
589	)
590	}
591	fn wire__crate__api__OndeChatEngine_new_impl(
592	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
593	rust_vec_len_: i32,
594	data_len_: i32,
595	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
596	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
597	flutter_rust_bridge::for_generated::TaskInfo {
598	debug_name: "OndeChatEngine_new",
599	port: None,
600	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
601	},
602	move \|\| {
603	let message = unsafe {
604	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
605	ptr_,
606	rust_vec_len_,
607	data_len_,
608	)
609	};
610	let mut deserializer =
611	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
612	deserializer.end();
613	transform_result_sse::<_, ()>((move \|\| {
614	let output_ok = Result::<_, ()>::Ok(crate::api::OndeChatEngine::new())?;
615	Ok(output_ok)
616	})())
617	},
618	)
619	}
620	fn wire__crate__api__OndeChatEngine_push_history_impl(
621	port_: flutter_rust_bridge::for_generated::MessagePort,
622	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
623	rust_vec_len_: i32,
624	data_len_: i32,
625	) {
626	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
627	flutter_rust_bridge::for_generated::TaskInfo {
628	debug_name: "OndeChatEngine_push_history",
629	port: Some(port_),
630	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
631	},
632	move \|\| {
633	let message = unsafe {
634	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
635	ptr_,
636	rust_vec_len_,
637	data_len_,
638	)
639	};
640	let mut deserializer =
641	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
642	let api_that = <RustOpaqueMoi<
643	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
644	>>::sse_decode(&mut deserializer);
645	let api_message = <crate::api::ChatMessage>::sse_decode(&mut deserializer);
646	deserializer.end();
647	move \|context\| async move {
648	transform_result_sse::<_, ()>(
649	(move \|\| async move {
650	let mut api_that_guard = None;
651	let decode_indices_ =
652	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
653	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
654	&api_that, 0, false,
655	)],
656	);
657	for i in decode_indices_ {
658	match i {
659	0 => {
660	api_that_guard =
661	Some(api_that.lockable_decode_async_ref().await)
662	}
663	_ => unreachable!(),
664	}
665	}
666	let api_that_guard = api_that_guard.unwrap();
667	let output_ok = Result::<_, ()>::Ok({
668	crate::api::OndeChatEngine::push_history(&*api_that_guard, api_message)
669	.await;
670	})?;
671	Ok(output_ok)
672	})()
673	.await,
674	)
675	}
676	},
677	)
678	}
679	fn wire__crate__api__OndeChatEngine_send_message_impl(
680	port_: flutter_rust_bridge::for_generated::MessagePort,
681	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
682	rust_vec_len_: i32,
683	data_len_: i32,
684	) {
685	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
686	flutter_rust_bridge::for_generated::TaskInfo {
687	debug_name: "OndeChatEngine_send_message",
688	port: Some(port_),
689	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
690	},
691	move \|\| {
692	let message = unsafe {
693	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
694	ptr_,
695	rust_vec_len_,
696	data_len_,
697	)
698	};
699	let mut deserializer =
700	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
701	let api_that = <RustOpaqueMoi<
702	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
703	>>::sse_decode(&mut deserializer);
704	let api_message = <String>::sse_decode(&mut deserializer);
705	deserializer.end();
706	move \|context\| async move {
707	transform_result_sse::<_, crate::api::OndeError>(
708	(move \|\| async move {
709	let mut api_that_guard = None;
710	let decode_indices_ =
711	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
712	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
713	&api_that, 0, false,
714	)],
715	);
716	for i in decode_indices_ {
717	match i {
718	0 => {
719	api_that_guard =
720	Some(api_that.lockable_decode_async_ref().await)
721	}
722	_ => unreachable!(),
723	}
724	}
725	let api_that_guard = api_that_guard.unwrap();
726	let output_ok =
727	crate::api::OndeChatEngine::send_message(&*api_that_guard, api_message)
728	.await?;
729	Ok(output_ok)
730	})()
731	.await,
732	)
733	}
734	},
735	)
736	}
737	fn wire__crate__api__OndeChatEngine_set_sampling_impl(
738	port_: flutter_rust_bridge::for_generated::MessagePort,
739	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
740	rust_vec_len_: i32,
741	data_len_: i32,
742	) {
743	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
744	flutter_rust_bridge::for_generated::TaskInfo {
745	debug_name: "OndeChatEngine_set_sampling",
746	port: Some(port_),
747	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
748	},
749	move \|\| {
750	let message = unsafe {
751	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
752	ptr_,
753	rust_vec_len_,
754	data_len_,
755	)
756	};
757	let mut deserializer =
758	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
759	let api_that = <RustOpaqueMoi<
760	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
761	>>::sse_decode(&mut deserializer);
762	let api_sampling = <crate::api::SamplingConfig>::sse_decode(&mut deserializer);
763	deserializer.end();
764	move \|context\| async move {
765	transform_result_sse::<_, ()>(
766	(move \|\| async move {
767	let mut api_that_guard = None;
768	let decode_indices_ =
769	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
770	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
771	&api_that, 0, false,
772	)],
773	);
774	for i in decode_indices_ {
775	match i {
776	0 => {
777	api_that_guard =
778	Some(api_that.lockable_decode_async_ref().await)
779	}
780	_ => unreachable!(),
781	}
782	}
783	let api_that_guard = api_that_guard.unwrap();
784	let output_ok = Result::<_, ()>::Ok({
785	crate::api::OndeChatEngine::set_sampling(
786	&*api_that_guard,
787	api_sampling,
788	)
789	.await;
790	})?;
791	Ok(output_ok)
792	})()
793	.await,
794	)
795	}
796	},
797	)
798	}
799	fn wire__crate__api__OndeChatEngine_set_system_prompt_impl(
800	port_: flutter_rust_bridge::for_generated::MessagePort,
801	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
802	rust_vec_len_: i32,
803	data_len_: i32,
804	) {
805	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
806	flutter_rust_bridge::for_generated::TaskInfo {
807	debug_name: "OndeChatEngine_set_system_prompt",
808	port: Some(port_),
809	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
810	},
811	move \|\| {
812	let message = unsafe {
813	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
814	ptr_,
815	rust_vec_len_,
816	data_len_,
817	)
818	};
819	let mut deserializer =
820	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
821	let api_that = <RustOpaqueMoi<
822	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
823	>>::sse_decode(&mut deserializer);
824	let api_prompt = <String>::sse_decode(&mut deserializer);
825	deserializer.end();
826	move \|context\| async move {
827	transform_result_sse::<_, ()>(
828	(move \|\| async move {
829	let mut api_that_guard = None;
830	let decode_indices_ =
831	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
832	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
833	&api_that, 0, false,
834	)],
835	);
836	for i in decode_indices_ {
837	match i {
838	0 => {
839	api_that_guard =
840	Some(api_that.lockable_decode_async_ref().await)
841	}
842	_ => unreachable!(),
843	}
844	}
845	let api_that_guard = api_that_guard.unwrap();
846	let output_ok = Result::<_, ()>::Ok({
847	crate::api::OndeChatEngine::set_system_prompt(
848	&*api_that_guard,
849	api_prompt,
850	)
851	.await;
852	})?;
853	Ok(output_ok)
854	})()
855	.await,
856	)
857	}
858	},
859	)
860	}
861	fn wire__crate__api__OndeChatEngine_stream_message_impl(
862	port_: flutter_rust_bridge::for_generated::MessagePort,
863	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
864	rust_vec_len_: i32,
865	data_len_: i32,
866	) {
867	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
868	flutter_rust_bridge::for_generated::TaskInfo {
869	debug_name: "OndeChatEngine_stream_message",
870	port: Some(port_),
871	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
872	},
873	move \|\| {
874	let message = unsafe {
875	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
876	ptr_,
877	rust_vec_len_,
878	data_len_,
879	)
880	};
881	let mut deserializer =
882	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
883	let api_that = <RustOpaqueMoi<
884	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
885	>>::sse_decode(&mut deserializer);
886	let api_message = <String>::sse_decode(&mut deserializer);
887	let api_sink = <StreamSink<
888	crate::api::StreamChunk,
889	flutter_rust_bridge::for_generated::SseCodec,
890	>>::sse_decode(&mut deserializer);
891	deserializer.end();
892	move \|context\| async move {
893	transform_result_sse::<_, crate::api::OndeError>(
894	(move \|\| async move {
895	let mut api_that_guard = None;
896	let decode_indices_ =
897	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
898	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
899	&api_that, 0, false,
900	)],
901	);
902	for i in decode_indices_ {
903	match i {
904	0 => {
905	api_that_guard =
906	Some(api_that.lockable_decode_async_ref().await)
907	}
908	_ => unreachable!(),
909	}
910	}
911	let api_that_guard = api_that_guard.unwrap();
912	let output_ok = crate::api::OndeChatEngine::stream_message(
913	&*api_that_guard,
914	api_message,
915	api_sink,
916	)
917	.await?;
918	Ok(output_ok)
919	})()
920	.await,
921	)
922	}
923	},
924	)
925	}
926	fn wire__crate__api__OndeChatEngine_unload_model_impl(
927	port_: flutter_rust_bridge::for_generated::MessagePort,
928	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
929	rust_vec_len_: i32,
930	data_len_: i32,
931	) {
932	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
933	flutter_rust_bridge::for_generated::TaskInfo {
934	debug_name: "OndeChatEngine_unload_model",
935	port: Some(port_),
936	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
937	},
938	move \|\| {
939	let message = unsafe {
940	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
941	ptr_,
942	rust_vec_len_,
943	data_len_,
944	)
945	};
946	let mut deserializer =
947	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
948	let api_that = <RustOpaqueMoi<
949	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
950	>>::sse_decode(&mut deserializer);
951	deserializer.end();
952	move \|context\| async move {
953	transform_result_sse::<_, ()>(
954	(move \|\| async move {
955	let mut api_that_guard = None;
956	let decode_indices_ =
957	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
958	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
959	&api_that, 0, false,
960	)],
961	);
962	for i in decode_indices_ {
963	match i {
964	0 => {
965	api_that_guard =
966	Some(api_that.lockable_decode_async_ref().await)
967	}
968	_ => unreachable!(),
969	}
970	}
971	let api_that_guard = api_that_guard.unwrap();
972	let output_ok = Result::<_, ()>::Ok(
973	crate::api::OndeChatEngine::unload_model(&*api_that_guard).await,
974	)?;
975	Ok(output_ok)
976	})()
977	.await,
978	)
979	}
980	},
981	)
982	}
983	fn wire__crate__api__configure_cache_dir_impl(
984	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
985	rust_vec_len_: i32,
986	data_len_: i32,
987	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
988	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
989	flutter_rust_bridge::for_generated::TaskInfo {
990	debug_name: "configure_cache_dir",
991	port: None,
992	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
993	},
994	move \|\| {
995	let message = unsafe {
996	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
997	ptr_,
998	rust_vec_len_,
999	data_len_,
1000	)
1001	};
1002	let mut deserializer =
1003	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1004	let api_app_data_dir = <String>::sse_decode(&mut deserializer);
1005	deserializer.end();
1006	transform_result_sse::<_, crate::api::OndeError>((move \|\| {
1007	let output_ok = crate::api::configure_cache_dir(api_app_data_dir)?;
1008	Ok(output_ok)
1009	})())
1010	},
1011	)
1012	}
1013	fn wire__crate__api__default_model_config_impl(
1014	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1015	rust_vec_len_: i32,
1016	data_len_: i32,
1017	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1018	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1019	flutter_rust_bridge::for_generated::TaskInfo {
1020	debug_name: "default_model_config",
1021	port: None,
1022	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1023	},
1024	move \|\| {
1025	let message = unsafe {
1026	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1027	ptr_,
1028	rust_vec_len_,
1029	data_len_,
1030	)
1031	};
1032	let mut deserializer =
1033	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1034	deserializer.end();
1035	transform_result_sse::<_, ()>((move \|\| {
1036	let output_ok = Result::<_, ()>::Ok(crate::api::default_model_config())?;
1037	Ok(output_ok)
1038	})())
1039	},
1040	)
1041	}
1042	fn wire__crate__api__default_sampling_config_impl(
1043	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1044	rust_vec_len_: i32,
1045	data_len_: i32,
1046	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1047	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1048	flutter_rust_bridge::for_generated::TaskInfo {
1049	debug_name: "default_sampling_config",
1050	port: None,
1051	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1052	},
1053	move \|\| {
1054	let message = unsafe {
1055	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1056	ptr_,
1057	rust_vec_len_,
1058	data_len_,
1059	)
1060	};
1061	let mut deserializer =
1062	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1063	deserializer.end();
1064	transform_result_sse::<_, ()>((move \|\| {
1065	let output_ok = Result::<_, ()>::Ok(crate::api::default_sampling_config())?;
1066	Ok(output_ok)
1067	})())
1068	},
1069	)
1070	}
1071	fn wire__crate__api__deterministic_sampling_config_impl(
1072	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1073	rust_vec_len_: i32,
1074	data_len_: i32,
1075	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1076	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1077	flutter_rust_bridge::for_generated::TaskInfo {
1078	debug_name: "deterministic_sampling_config",
1079	port: None,
1080	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1081	},
1082	move \|\| {
1083	let message = unsafe {
1084	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1085	ptr_,
1086	rust_vec_len_,
1087	data_len_,
1088	)
1089	};
1090	let mut deserializer =
1091	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1092	deserializer.end();
1093	transform_result_sse::<_, ()>((move \|\| {
1094	let output_ok = Result::<_, ()>::Ok(crate::api::deterministic_sampling_config())?;
1095	Ok(output_ok)
1096	})())
1097	},
1098	)
1099	}
1100	fn wire__crate__api__mobile_sampling_config_impl(
1101	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1102	rust_vec_len_: i32,
1103	data_len_: i32,
1104	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1105	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1106	flutter_rust_bridge::for_generated::TaskInfo {
1107	debug_name: "mobile_sampling_config",
1108	port: None,
1109	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1110	},
1111	move \|\| {
1112	let message = unsafe {
1113	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1114	ptr_,
1115	rust_vec_len_,
1116	data_len_,
1117	)
1118	};
1119	let mut deserializer =
1120	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1121	deserializer.end();
1122	transform_result_sse::<_, ()>((move \|\| {
1123	let output_ok = Result::<_, ()>::Ok(crate::api::mobile_sampling_config())?;
1124	Ok(output_ok)
1125	})())
1126	},
1127	)
1128	}
1129	fn wire__crate__api__qwen25_1_5b_config_impl(
1130	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1131	rust_vec_len_: i32,
1132	data_len_: i32,
1133	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1134	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1135	flutter_rust_bridge::for_generated::TaskInfo {
1136	debug_name: "qwen25_1_5b_config",
1137	port: None,
1138	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1139	},
1140	move \|\| {
1141	let message = unsafe {
1142	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1143	ptr_,
1144	rust_vec_len_,
1145	data_len_,
1146	)
1147	};
1148	let mut deserializer =
1149	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1150	deserializer.end();
1151	transform_result_sse::<_, ()>((move \|\| {
1152	let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_1_5b_config())?;
1153	Ok(output_ok)
1154	})())
1155	},
1156	)
1157	}
1158	fn wire__crate__api__qwen25_3b_config_impl(
1159	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1160	rust_vec_len_: i32,
1161	data_len_: i32,
1162	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1163	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1164	flutter_rust_bridge::for_generated::TaskInfo {
1165	debug_name: "qwen25_3b_config",
1166	port: None,
1167	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1168	},
1169	move \|\| {
1170	let message = unsafe {
1171	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1172	ptr_,
1173	rust_vec_len_,
1174	data_len_,
1175	)
1176	};
1177	let mut deserializer =
1178	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1179	deserializer.end();
1180	transform_result_sse::<_, ()>((move \|\| {
1181	let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_3b_config())?;
1182	Ok(output_ok)
1183	})())
1184	},
1185	)
1186	}
1187	fn wire__crate__api__qwen25_coder_1_5b_config_impl(
1188	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1189	rust_vec_len_: i32,
1190	data_len_: i32,
1191	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1192	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1193	flutter_rust_bridge::for_generated::TaskInfo {
1194	debug_name: "qwen25_coder_1_5b_config",
1195	port: None,
1196	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1197	},
1198	move \|\| {
1199	let message = unsafe {
1200	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1201	ptr_,
1202	rust_vec_len_,
1203	data_len_,
1204	)
1205	};
1206	let mut deserializer =
1207	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1208	deserializer.end();
1209	transform_result_sse::<_, ()>((move \|\| {
1210	let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_coder_1_5b_config())?;
1211	Ok(output_ok)
1212	})())
1213	},
1214	)
1215	}
1216	fn wire__crate__api__qwen25_coder_3b_config_impl(
1217	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1218	rust_vec_len_: i32,
1219	data_len_: i32,
1220	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1221	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1222	flutter_rust_bridge::for_generated::TaskInfo {
1223	debug_name: "qwen25_coder_3b_config",
1224	port: None,
1225	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1226	},
1227	move \|\| {
1228	let message = unsafe {
1229	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1230	ptr_,
1231	rust_vec_len_,
1232	data_len_,
1233	)
1234	};
1235	let mut deserializer =
1236	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1237	deserializer.end();
1238	transform_result_sse::<_, ()>((move \|\| {
1239	let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_coder_3b_config())?;
1240	Ok(output_ok)
1241	})())
1242	},
1243	)
1244	}
1245	fn wire__crate__api__qwen3_0_6b_config_impl(
1246	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1247	rust_vec_len_: i32,
1248	data_len_: i32,
1249	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1250	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1251	flutter_rust_bridge::for_generated::TaskInfo {
1252	debug_name: "qwen3_0_6b_config",
1253	port: None,
1254	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1255	},
1256	move \|\| {
1257	let message = unsafe {
1258	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1259	ptr_,
1260	rust_vec_len_,
1261	data_len_,
1262	)
1263	};
1264	let mut deserializer =
1265	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1266	deserializer.end();
1267	transform_result_sse::<_, ()>((move \|\| {
1268	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_0_6b_config())?;
1269	Ok(output_ok)
1270	})())
1271	},
1272	)
1273	}
1274	fn wire__crate__api__qwen3_14b_config_impl(
1275	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1276	rust_vec_len_: i32,
1277	data_len_: i32,
1278	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1279	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1280	flutter_rust_bridge::for_generated::TaskInfo {
1281	debug_name: "qwen3_14b_config",
1282	port: None,
1283	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1284	},
1285	move \|\| {
1286	let message = unsafe {
1287	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1288	ptr_,
1289	rust_vec_len_,
1290	data_len_,
1291	)
1292	};
1293	let mut deserializer =
1294	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1295	deserializer.end();
1296	transform_result_sse::<_, ()>((move \|\| {
1297	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_14b_config())?;
1298	Ok(output_ok)
1299	})())
1300	},
1301	)
1302	}
1303	fn wire__crate__api__qwen3_1_7b_config_impl(
1304	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1305	rust_vec_len_: i32,
1306	data_len_: i32,
1307	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1308	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1309	flutter_rust_bridge::for_generated::TaskInfo {
1310	debug_name: "qwen3_1_7b_config",
1311	port: None,
1312	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1313	},
1314	move \|\| {
1315	let message = unsafe {
1316	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1317	ptr_,
1318	rust_vec_len_,
1319	data_len_,
1320	)
1321	};
1322	let mut deserializer =
1323	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1324	deserializer.end();
1325	transform_result_sse::<_, ()>((move \|\| {
1326	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_1_7b_config())?;
1327	Ok(output_ok)
1328	})())
1329	},
1330	)
1331	}
1332	fn wire__crate__api__qwen3_30b_a3b_instruct_2507_config_impl(
1333	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1334	rust_vec_len_: i32,
1335	data_len_: i32,
1336	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1337	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1338	flutter_rust_bridge::for_generated::TaskInfo {
1339	debug_name: "qwen3_30b_a3b_instruct_2507_config",
1340	port: None,
1341	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1342	},
1343	move \|\| {
1344	let message = unsafe {
1345	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1346	ptr_,
1347	rust_vec_len_,
1348	data_len_,
1349	)
1350	};
1351	let mut deserializer =
1352	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1353	deserializer.end();
1354	transform_result_sse::<_, ()>((move \|\| {
1355	let output_ok =
1356	Result::<_, ()>::Ok(crate::api::qwen3_30b_a3b_instruct_2507_config())?;
1357	Ok(output_ok)
1358	})())
1359	},
1360	)
1361	}
1362	fn wire__crate__api__qwen3_32b_config_impl(
1363	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1364	rust_vec_len_: i32,
1365	data_len_: i32,
1366	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1367	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1368	flutter_rust_bridge::for_generated::TaskInfo {
1369	debug_name: "qwen3_32b_config",
1370	port: None,
1371	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1372	},
1373	move \|\| {
1374	let message = unsafe {
1375	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1376	ptr_,
1377	rust_vec_len_,
1378	data_len_,
1379	)
1380	};
1381	let mut deserializer =
1382	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1383	deserializer.end();
1384	transform_result_sse::<_, ()>((move \|\| {
1385	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_32b_config())?;
1386	Ok(output_ok)
1387	})())
1388	},
1389	)
1390	}
1391	fn wire__crate__api__qwen3_4b_config_impl(
1392	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1393	rust_vec_len_: i32,
1394	data_len_: i32,
1395	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1396	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1397	flutter_rust_bridge::for_generated::TaskInfo {
1398	debug_name: "qwen3_4b_config",
1399	port: None,
1400	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1401	},
1402	move \|\| {
1403	let message = unsafe {
1404	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1405	ptr_,
1406	rust_vec_len_,
1407	data_len_,
1408	)
1409	};
1410	let mut deserializer =
1411	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1412	deserializer.end();
1413	transform_result_sse::<_, ()>((move \|\| {
1414	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_4b_config())?;
1415	Ok(output_ok)
1416	})())
1417	},
1418	)
1419	}
1420	fn wire__crate__api__qwen3_4b_instruct_2507_config_impl(
1421	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1422	rust_vec_len_: i32,
1423	data_len_: i32,
1424	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1425	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1426	flutter_rust_bridge::for_generated::TaskInfo {
1427	debug_name: "qwen3_4b_instruct_2507_config",
1428	port: None,
1429	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1430	},
1431	move \|\| {
1432	let message = unsafe {
1433	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1434	ptr_,
1435	rust_vec_len_,
1436	data_len_,
1437	)
1438	};
1439	let mut deserializer =
1440	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1441	deserializer.end();
1442	transform_result_sse::<_, ()>((move \|\| {
1443	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_4b_instruct_2507_config())?;
1444	Ok(output_ok)
1445	})())
1446	},
1447	)
1448	}
1449	fn wire__crate__api__qwen3_4b_thinking_2507_config_impl(
1450	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1451	rust_vec_len_: i32,
1452	data_len_: i32,
1453	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1454	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1455	flutter_rust_bridge::for_generated::TaskInfo {
1456	debug_name: "qwen3_4b_thinking_2507_config",
1457	port: None,
1458	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1459	},
1460	move \|\| {
1461	let message = unsafe {
1462	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1463	ptr_,
1464	rust_vec_len_,
1465	data_len_,
1466	)
1467	};
1468	let mut deserializer =
1469	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1470	deserializer.end();
1471	transform_result_sse::<_, ()>((move \|\| {
1472	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_4b_thinking_2507_config())?;
1473	Ok(output_ok)
1474	})())
1475	},
1476	)
1477	}
1478	fn wire__crate__api__qwen3_8b_config_impl(
1479	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1480	rust_vec_len_: i32,
1481	data_len_: i32,
1482	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1483	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1484	flutter_rust_bridge::for_generated::TaskInfo {
1485	debug_name: "qwen3_8b_config",
1486	port: None,
1487	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1488	},
1489	move \|\| {
1490	let message = unsafe {
1491	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1492	ptr_,
1493	rust_vec_len_,
1494	data_len_,
1495	)
1496	};
1497	let mut deserializer =
1498	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1499	deserializer.end();
1500	transform_result_sse::<_, ()>((move \|\| {
1501	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_8b_config())?;
1502	Ok(output_ok)
1503	})())
1504	},
1505	)
1506	}
1507	fn wire__crate__api__uqff_model_config_impl(
1508	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1509	rust_vec_len_: i32,
1510	data_len_: i32,
1511	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1512	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1513	flutter_rust_bridge::for_generated::TaskInfo {
1514	debug_name: "uqff_model_config",
1515	port: None,
1516	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1517	},
1518	move \|\| {
1519	let message = unsafe {
1520	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1521	ptr_,
1522	rust_vec_len_,
1523	data_len_,
1524	)
1525	};
1526	let mut deserializer =
1527	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1528	let api_model_id = <String>::sse_decode(&mut deserializer);
1529	let api_files = <Vec<String>>::sse_decode(&mut deserializer);
1530	let api_display_name = <String>::sse_decode(&mut deserializer);
1531	let api_approx_memory = <String>::sse_decode(&mut deserializer);
1532	let api_chat_template = <Option<String>>::sse_decode(&mut deserializer);
1533	deserializer.end();
1534	transform_result_sse::<_, ()>((move \|\| {
1535	let output_ok = Result::<_, ()>::Ok(crate::api::uqff_model_config(
1536	api_model_id,
1537	api_files,
1538	api_display_name,
1539	api_approx_memory,
1540	api_chat_template,
1541	))?;
1542	Ok(output_ok)
1543	})())
1544	},
1545	)
1546	}
1547
1548	// Section: related_funcs
1549
1550	flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
1551	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>
1552	);
1553
1554	// Section: dart2rust
1555
1556	impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
1557	// Codec=Sse (Serialization based), see doc to use other codecs
1558	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1559	let mut inner = <String>::sse_decode(deserializer);
1560	return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
1561	}
1562	}
1563
1564	impl SseDecode for OndeChatEngine {
1565	// Codec=Sse (Serialization based), see doc to use other codecs
1566	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1567	let mut inner = <RustOpaqueMoi<
1568	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
1569	>>::sse_decode(deserializer);
1570	return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
1571	}
1572	}
1573
1574	impl SseDecode
1575	for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>
1576	{
1577	// Codec=Sse (Serialization based), see doc to use other codecs
1578	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1579	let mut inner = <usize>::sse_decode(deserializer);
1580	return decode_rust_opaque_moi(inner);
1581	}
1582	}
1583
1584	impl SseDecode
1585	for StreamSink<crate::api::StreamChunk, flutter_rust_bridge::for_generated::SseCodec>
1586	{
1587	// Codec=Sse (Serialization based), see doc to use other codecs
1588	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1589	let mut inner = <String>::sse_decode(deserializer);
1590	return StreamSink::deserialize(inner);
1591	}
1592	}
1593
1594	impl SseDecode for String {
1595	// Codec=Sse (Serialization based), see doc to use other codecs
1596	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1597	let mut inner = <Vec<u8>>::sse_decode(deserializer);
1598	return String::from_utf8(inner).unwrap();
1599	}
1600	}
1601
1602	impl SseDecode for bool {
1603	// Codec=Sse (Serialization based), see doc to use other codecs
1604	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1605	deserializer.cursor.read_u8().unwrap() != 0
1606	}
1607	}
1608
1609	impl SseDecode for crate::api::ChatMessage {
1610	// Codec=Sse (Serialization based), see doc to use other codecs
1611	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1612	let mut var_role = <crate::api::ChatRole>::sse_decode(deserializer);
1613	let mut var_content = <String>::sse_decode(deserializer);
1614	return crate::api::ChatMessage {
1615	role: var_role,
1616	content: var_content,
1617	};
1618	}
1619	}
1620
1621	impl SseDecode for crate::api::ChatRole {
1622	// Codec=Sse (Serialization based), see doc to use other codecs
1623	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1624	let mut inner = <i32>::sse_decode(deserializer);
1625	return match inner {
1626	0 => crate::api::ChatRole::System,
1627	1 => crate::api::ChatRole::User,
1628	2 => crate::api::ChatRole::Assistant,
1629	_ => unreachable!("Invalid variant for ChatRole: {}", inner),
1630	};
1631	}
1632	}
1633
1634	impl SseDecode for crate::api::EngineInfo {
1635	// Codec=Sse (Serialization based), see doc to use other codecs
1636	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1637	let mut var_status = <crate::api::EngineStatus>::sse_decode(deserializer);
1638	let mut var_modelName = <Option<String>>::sse_decode(deserializer);
1639	let mut var_approxMemory = <Option<String>>::sse_decode(deserializer);
1640	let mut var_historyLength = <u64>::sse_decode(deserializer);
1641	return crate::api::EngineInfo {
1642	status: var_status,
1643	model_name: var_modelName,
1644	approx_memory: var_approxMemory,
1645	history_length: var_historyLength,
1646	};
1647	}
1648	}
1649
1650	impl SseDecode for crate::api::EngineStatus {
1651	// Codec=Sse (Serialization based), see doc to use other codecs
1652	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1653	let mut inner = <i32>::sse_decode(deserializer);
1654	return match inner {
1655	0 => crate::api::EngineStatus::Unloaded,
1656	1 => crate::api::EngineStatus::Loading,
1657	2 => crate::api::EngineStatus::Ready,
1658	3 => crate::api::EngineStatus::Generating,
1659	4 => crate::api::EngineStatus::Error,
1660	_ => unreachable!("Invalid variant for EngineStatus: {}", inner),
1661	};
1662	}
1663	}
1664
1665	impl SseDecode for f32 {
1666	// Codec=Sse (Serialization based), see doc to use other codecs
1667	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1668	deserializer.cursor.read_f32::<NativeEndian>().unwrap()
1669	}
1670	}
1671
1672	impl SseDecode for f64 {
1673	// Codec=Sse (Serialization based), see doc to use other codecs
1674	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1675	deserializer.cursor.read_f64::<NativeEndian>().unwrap()
1676	}
1677	}
1678
1679	impl SseDecode for crate::api::GgufModelConfig {
1680	// Codec=Sse (Serialization based), see doc to use other codecs
1681	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1682	let mut var_modelId = <String>::sse_decode(deserializer);
1683	let mut var_files = <Vec<String>>::sse_decode(deserializer);
1684	let mut var_tokModelId = <Option<String>>::sse_decode(deserializer);
1685	let mut var_displayName = <String>::sse_decode(deserializer);
1686	let mut var_approxMemory = <String>::sse_decode(deserializer);
1687	return crate::api::GgufModelConfig {
1688	model_id: var_modelId,
1689	files: var_files,
1690	tok_model_id: var_tokModelId,
1691	display_name: var_displayName,
1692	approx_memory: var_approxMemory,
1693	};
1694	}
1695	}
1696
1697	impl SseDecode for i32 {
1698	// Codec=Sse (Serialization based), see doc to use other codecs
1699	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1700	deserializer.cursor.read_i32::<NativeEndian>().unwrap()
1701	}
1702	}
1703
1704	impl SseDecode for crate::api::InferenceResult {
1705	// Codec=Sse (Serialization based), see doc to use other codecs
1706	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1707	let mut var_text = <String>::sse_decode(deserializer);
1708	let mut var_durationSecs = <f64>::sse_decode(deserializer);
1709	let mut var_durationDisplay = <String>::sse_decode(deserializer);
1710	let mut var_finishReason = <String>::sse_decode(deserializer);
1711	let mut var_toolCalls = <Vec<crate::api::ToolCallInfo>>::sse_decode(deserializer);
1712	return crate::api::InferenceResult {
1713	text: var_text,
1714	duration_secs: var_durationSecs,
1715	duration_display: var_durationDisplay,
1716	finish_reason: var_finishReason,
1717	tool_calls: var_toolCalls,
1718	};
1719	}
1720	}
1721
1722	impl SseDecode for Vec<String> {
1723	// Codec=Sse (Serialization based), see doc to use other codecs
1724	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1725	let mut len_ = <i32>::sse_decode(deserializer);
1726	let mut ans_ = Vec::with_capacity(len_ as usize);
1727	for idx_ in 0..len_ {
1728	ans_.push(<String>::sse_decode(deserializer));
1729	}
1730	return ans_;
1731	}
1732	}
1733
1734	impl SseDecode for Vec<crate::api::ChatMessage> {
1735	// Codec=Sse (Serialization based), see doc to use other codecs
1736	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1737	let mut len_ = <i32>::sse_decode(deserializer);
1738	let mut ans_ = Vec::with_capacity(len_ as usize);
1739	for idx_ in 0..len_ {
1740	ans_.push(<crate::api::ChatMessage>::sse_decode(deserializer));
1741	}
1742	return ans_;
1743	}
1744	}
1745
1746	impl SseDecode for Vec<u8> {
1747	// Codec=Sse (Serialization based), see doc to use other codecs
1748	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1749	let mut len_ = <i32>::sse_decode(deserializer);
1750	let mut ans_ = Vec::with_capacity(len_ as usize);
1751	for idx_ in 0..len_ {
1752	ans_.push(<u8>::sse_decode(deserializer));
1753	}
1754	return ans_;
1755	}
1756	}
1757
1758	impl SseDecode for Vec<crate::api::ToolCallInfo> {
1759	// Codec=Sse (Serialization based), see doc to use other codecs
1760	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1761	let mut len_ = <i32>::sse_decode(deserializer);
1762	let mut ans_ = Vec::with_capacity(len_ as usize);
1763	for idx_ in 0..len_ {
1764	ans_.push(<crate::api::ToolCallInfo>::sse_decode(deserializer));
1765	}
1766	return ans_;
1767	}
1768	}
1769
1770	impl SseDecode for crate::api::OndeError {
1771	// Codec=Sse (Serialization based), see doc to use other codecs
1772	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1773	let mut tag_ = <i32>::sse_decode(deserializer);
1774	match tag_ {
1775	0 => {
1776	return crate::api::OndeError::NoModelLoaded;
1777	}
1778	1 => {
1779	let mut var_modelName = <String>::sse_decode(deserializer);
1780	return crate::api::OndeError::AlreadyLoaded {
1781	model_name: var_modelName,
1782	};
1783	}
1784	2 => {
1785	let mut var_reason = <String>::sse_decode(deserializer);
1786	return crate::api::OndeError::ModelBuild { reason: var_reason };
1787	}
1788	3 => {
1789	let mut var_reason = <String>::sse_decode(deserializer);
1790	return crate::api::OndeError::Inference { reason: var_reason };
1791	}
1792	4 => {
1793	return crate::api::OndeError::Cancelled;
1794	}
1795	5 => {
1796	let mut var_reason = <String>::sse_decode(deserializer);
1797	return crate::api::OndeError::Other { reason: var_reason };
1798	}
1799	_ => {
1800	unimplemented!("");
1801	}
1802	}
1803	}
1804	}
1805
1806	impl SseDecode for Option<String> {
1807	// Codec=Sse (Serialization based), see doc to use other codecs
1808	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1809	if (<bool>::sse_decode(deserializer)) {
1810	return Some(<String>::sse_decode(deserializer));
1811	} else {
1812	return None;
1813	}
1814	}
1815	}
1816
1817	impl SseDecode for Option<f32> {
1818	// Codec=Sse (Serialization based), see doc to use other codecs
1819	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1820	if (<bool>::sse_decode(deserializer)) {
1821	return Some(<f32>::sse_decode(deserializer));
1822	} else {
1823	return None;
1824	}
1825	}
1826	}
1827
1828	impl SseDecode for Option<f64> {
1829	// Codec=Sse (Serialization based), see doc to use other codecs
1830	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1831	if (<bool>::sse_decode(deserializer)) {
1832	return Some(<f64>::sse_decode(deserializer));
1833	} else {
1834	return None;
1835	}
1836	}
1837	}
1838
1839	impl SseDecode for Option<crate::api::SamplingConfig> {
1840	// Codec=Sse (Serialization based), see doc to use other codecs
1841	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1842	if (<bool>::sse_decode(deserializer)) {
1843	return Some(<crate::api::SamplingConfig>::sse_decode(deserializer));
1844	} else {
1845	return None;
1846	}
1847	}
1848	}
1849
1850	impl SseDecode for Option<u64> {
1851	// Codec=Sse (Serialization based), see doc to use other codecs
1852	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1853	if (<bool>::sse_decode(deserializer)) {
1854	return Some(<u64>::sse_decode(deserializer));
1855	} else {
1856	return None;
1857	}
1858	}
1859	}
1860
1861	impl SseDecode for crate::api::SamplingConfig {
1862	// Codec=Sse (Serialization based), see doc to use other codecs
1863	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1864	let mut var_temperature = <Option<f64>>::sse_decode(deserializer);
1865	let mut var_topP = <Option<f64>>::sse_decode(deserializer);
1866	let mut var_topK = <Option<u64>>::sse_decode(deserializer);
1867	let mut var_minP = <Option<f64>>::sse_decode(deserializer);
1868	let mut var_maxTokens = <Option<u64>>::sse_decode(deserializer);
1869	let mut var_frequencyPenalty = <Option<f32>>::sse_decode(deserializer);
1870	let mut var_presencePenalty = <Option<f32>>::sse_decode(deserializer);
1871	return crate::api::SamplingConfig {
1872	temperature: var_temperature,
1873	top_p: var_topP,
1874	top_k: var_topK,
1875	min_p: var_minP,
1876	max_tokens: var_maxTokens,
1877	frequency_penalty: var_frequencyPenalty,
1878	presence_penalty: var_presencePenalty,
1879	};
1880	}
1881	}
1882
1883	impl SseDecode for crate::api::StreamChunk {
1884	// Codec=Sse (Serialization based), see doc to use other codecs
1885	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1886	let mut var_delta = <String>::sse_decode(deserializer);
1887	let mut var_done = <bool>::sse_decode(deserializer);
1888	let mut var_finishReason = <Option<String>>::sse_decode(deserializer);
1889	return crate::api::StreamChunk {
1890	delta: var_delta,
1891	done: var_done,
1892	finish_reason: var_finishReason,
1893	};
1894	}
1895	}
1896
1897	impl SseDecode for crate::api::ToolCallInfo {
1898	// Codec=Sse (Serialization based), see doc to use other codecs
1899	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1900	let mut var_id = <String>::sse_decode(deserializer);
1901	let mut var_functionName = <String>::sse_decode(deserializer);
1902	let mut var_arguments = <String>::sse_decode(deserializer);
1903	return crate::api::ToolCallInfo {
1904	id: var_id,
1905	function_name: var_functionName,
1906	arguments: var_arguments,
1907	};
1908	}
1909	}
1910
1911	impl SseDecode for u64 {
1912	// Codec=Sse (Serialization based), see doc to use other codecs
1913	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1914	deserializer.cursor.read_u64::<NativeEndian>().unwrap()
1915	}
1916	}
1917
1918	impl SseDecode for u8 {
1919	// Codec=Sse (Serialization based), see doc to use other codecs
1920	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1921	deserializer.cursor.read_u8().unwrap()
1922	}
1923	}
1924
1925	impl SseDecode for () {
1926	// Codec=Sse (Serialization based), see doc to use other codecs
1927	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
1928	}
1929
1930	impl SseDecode for crate::api::UqffModelConfig {
1931	// Codec=Sse (Serialization based), see doc to use other codecs
1932	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1933	let mut var_modelId = <String>::sse_decode(deserializer);
1934	let mut var_files = <Vec<String>>::sse_decode(deserializer);
1935	let mut var_displayName = <String>::sse_decode(deserializer);
1936	let mut var_approxMemory = <String>::sse_decode(deserializer);
1937	let mut var_chatTemplate = <Option<String>>::sse_decode(deserializer);
1938	return crate::api::UqffModelConfig {
1939	model_id: var_modelId,
1940	files: var_files,
1941	display_name: var_displayName,
1942	approx_memory: var_approxMemory,
1943	chat_template: var_chatTemplate,
1944	};
1945	}
1946	}
1947
1948	impl SseDecode for usize {
1949	// Codec=Sse (Serialization based), see doc to use other codecs
1950	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1951	deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
1952	}
1953	}
1954
1955	fn pde_ffi_dispatcher_primary_impl(
1956	func_id: i32,
1957	port: flutter_rust_bridge::for_generated::MessagePort,
1958	ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1959	rust_vec_len: i32,
1960	data_len: i32,
1961	) {
1962	// Codec=Pde (Serialization + dispatch), see doc to use other codecs
1963	match func_id {
1964	1 => wire__crate__api__OndeChatEngine_clear_history_impl(port, ptr, rust_vec_len, data_len),
1965	2 => wire__crate__api__OndeChatEngine_clear_system_prompt_impl(
1966	port,
1967	ptr,
1968	rust_vec_len,
1969	data_len,
1970	),
1971	3 => wire__crate__api__OndeChatEngine_generate_impl(port, ptr, rust_vec_len, data_len),
1972	4 => wire__crate__api__OndeChatEngine_history_impl(port, ptr, rust_vec_len, data_len),
1973	5 => wire__crate__api__OndeChatEngine_info_impl(port, ptr, rust_vec_len, data_len),
1974	6 => wire__crate__api__OndeChatEngine_is_loaded_impl(port, ptr, rust_vec_len, data_len),
1975	7 => wire__crate__api__OndeChatEngine_load_assigned_model_impl(
1976	port,
1977	ptr,
1978	rust_vec_len,
1979	data_len,
1980	),
1981	8 => {
1982	wire__crate__api__OndeChatEngine_load_gguf_model_impl(port, ptr, rust_vec_len, data_len)
1983	}
1984	9 => {
1985	wire__crate__api__OndeChatEngine_load_uqff_model_impl(port, ptr, rust_vec_len, data_len)
1986	}
1987	11 => wire__crate__api__OndeChatEngine_push_history_impl(port, ptr, rust_vec_len, data_len),
1988	12 => wire__crate__api__OndeChatEngine_send_message_impl(port, ptr, rust_vec_len, data_len),
1989	13 => wire__crate__api__OndeChatEngine_set_sampling_impl(port, ptr, rust_vec_len, data_len),
1990	14 => wire__crate__api__OndeChatEngine_set_system_prompt_impl(
1991	port,
1992	ptr,
1993	rust_vec_len,
1994	data_len,
1995	),
1996	15 => {
1997	wire__crate__api__OndeChatEngine_stream_message_impl(port, ptr, rust_vec_len, data_len)
1998	}
1999	16 => wire__crate__api__OndeChatEngine_unload_model_impl(port, ptr, rust_vec_len, data_len),
2000	_ => unreachable!(),
2001	}
2002	}
2003
2004	fn pde_ffi_dispatcher_sync_impl(
2005	func_id: i32,
2006	ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
2007	rust_vec_len: i32,
2008	data_len: i32,
2009	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
2010	// Codec=Pde (Serialization + dispatch), see doc to use other codecs
2011	match func_id {
2012	10 => wire__crate__api__OndeChatEngine_new_impl(ptr, rust_vec_len, data_len),
2013	17 => wire__crate__api__configure_cache_dir_impl(ptr, rust_vec_len, data_len),
2014	18 => wire__crate__api__default_model_config_impl(ptr, rust_vec_len, data_len),
2015	19 => wire__crate__api__default_sampling_config_impl(ptr, rust_vec_len, data_len),
2016	20 => wire__crate__api__deterministic_sampling_config_impl(ptr, rust_vec_len, data_len),
2017	21 => wire__crate__api__mobile_sampling_config_impl(ptr, rust_vec_len, data_len),
2018	22 => wire__crate__api__qwen25_1_5b_config_impl(ptr, rust_vec_len, data_len),
2019	23 => wire__crate__api__qwen25_3b_config_impl(ptr, rust_vec_len, data_len),
2020	24 => wire__crate__api__qwen25_coder_1_5b_config_impl(ptr, rust_vec_len, data_len),
2021	25 => wire__crate__api__qwen25_coder_3b_config_impl(ptr, rust_vec_len, data_len),
2022	26 => wire__crate__api__qwen3_0_6b_config_impl(ptr, rust_vec_len, data_len),
2023	27 => wire__crate__api__qwen3_14b_config_impl(ptr, rust_vec_len, data_len),
2024	28 => wire__crate__api__qwen3_1_7b_config_impl(ptr, rust_vec_len, data_len),
2025	29 => {
2026	wire__crate__api__qwen3_30b_a3b_instruct_2507_config_impl(ptr, rust_vec_len, data_len)
2027	}
2028	30 => wire__crate__api__qwen3_32b_config_impl(ptr, rust_vec_len, data_len),
2029	31 => wire__crate__api__qwen3_4b_config_impl(ptr, rust_vec_len, data_len),
2030	32 => wire__crate__api__qwen3_4b_instruct_2507_config_impl(ptr, rust_vec_len, data_len),
2031	33 => wire__crate__api__qwen3_4b_thinking_2507_config_impl(ptr, rust_vec_len, data_len),
2032	34 => wire__crate__api__qwen3_8b_config_impl(ptr, rust_vec_len, data_len),
2033	35 => wire__crate__api__uqff_model_config_impl(ptr, rust_vec_len, data_len),
2034	_ => unreachable!(),
2035	}
2036	}
2037
2038	// Section: rust2dart
2039
2040	// Codec=Dco (DartCObject based), see doc to use other codecs
2041	impl flutter_rust_bridge::IntoDart for FrbWrapper<OndeChatEngine> {
2042	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2043	flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0)
2044	.into_dart()
2045	}
2046	}
2047	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<OndeChatEngine> {}
2048
2049	impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<OndeChatEngine>> for OndeChatEngine {
2050	fn into_into_dart(self) -> FrbWrapper<OndeChatEngine> {
2051	self.into()
2052	}
2053	}
2054
2055	// Codec=Dco (DartCObject based), see doc to use other codecs
2056	impl flutter_rust_bridge::IntoDart for crate::api::ChatMessage {
2057	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2058	[
2059	self.role.into_into_dart().into_dart(),
2060	self.content.into_into_dart().into_dart(),
2061	]
2062	.into_dart()
2063	}
2064	}
2065	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::ChatMessage {}
2066	impl flutter_rust_bridge::IntoIntoDart<crate::api::ChatMessage> for crate::api::ChatMessage {
2067	fn into_into_dart(self) -> crate::api::ChatMessage {
2068	self
2069	}
2070	}
2071	// Codec=Dco (DartCObject based), see doc to use other codecs
2072	impl flutter_rust_bridge::IntoDart for crate::api::ChatRole {
2073	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2074	match self {
2075	Self::System => 0.into_dart(),
2076	Self::User => 1.into_dart(),
2077	Self::Assistant => 2.into_dart(),
2078	_ => unreachable!(),
2079	}
2080	}
2081	}
2082	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::ChatRole {}
2083	impl flutter_rust_bridge::IntoIntoDart<crate::api::ChatRole> for crate::api::ChatRole {
2084	fn into_into_dart(self) -> crate::api::ChatRole {
2085	self
2086	}
2087	}
2088	// Codec=Dco (DartCObject based), see doc to use other codecs
2089	impl flutter_rust_bridge::IntoDart for crate::api::EngineInfo {
2090	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2091	[
2092	self.status.into_into_dart().into_dart(),
2093	self.model_name.into_into_dart().into_dart(),
2094	self.approx_memory.into_into_dart().into_dart(),
2095	self.history_length.into_into_dart().into_dart(),
2096	]
2097	.into_dart()
2098	}
2099	}
2100	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::EngineInfo {}
2101	impl flutter_rust_bridge::IntoIntoDart<crate::api::EngineInfo> for crate::api::EngineInfo {
2102	fn into_into_dart(self) -> crate::api::EngineInfo {
2103	self
2104	}
2105	}
2106	// Codec=Dco (DartCObject based), see doc to use other codecs
2107	impl flutter_rust_bridge::IntoDart for crate::api::EngineStatus {
2108	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2109	match self {
2110	Self::Unloaded => 0.into_dart(),
2111	Self::Loading => 1.into_dart(),
2112	Self::Ready => 2.into_dart(),
2113	Self::Generating => 3.into_dart(),
2114	Self::Error => 4.into_dart(),
2115	_ => unreachable!(),
2116	}
2117	}
2118	}
2119	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::EngineStatus {}
2120	impl flutter_rust_bridge::IntoIntoDart<crate::api::EngineStatus> for crate::api::EngineStatus {
2121	fn into_into_dart(self) -> crate::api::EngineStatus {
2122	self
2123	}
2124	}
2125	// Codec=Dco (DartCObject based), see doc to use other codecs
2126	impl flutter_rust_bridge::IntoDart for crate::api::GgufModelConfig {
2127	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2128	[
2129	self.model_id.into_into_dart().into_dart(),
2130	self.files.into_into_dart().into_dart(),
2131	self.tok_model_id.into_into_dart().into_dart(),
2132	self.display_name.into_into_dart().into_dart(),
2133	self.approx_memory.into_into_dart().into_dart(),
2134	]
2135	.into_dart()
2136	}
2137	}
2138	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::GgufModelConfig {}
2139	impl flutter_rust_bridge::IntoIntoDart<crate::api::GgufModelConfig>
2140	for crate::api::GgufModelConfig
2141	{
2142	fn into_into_dart(self) -> crate::api::GgufModelConfig {
2143	self
2144	}
2145	}
2146	// Codec=Dco (DartCObject based), see doc to use other codecs
2147	impl flutter_rust_bridge::IntoDart for crate::api::InferenceResult {
2148	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2149	[
2150	self.text.into_into_dart().into_dart(),
2151	self.duration_secs.into_into_dart().into_dart(),
2152	self.duration_display.into_into_dart().into_dart(),
2153	self.finish_reason.into_into_dart().into_dart(),
2154	self.tool_calls.into_into_dart().into_dart(),
2155	]
2156	.into_dart()
2157	}
2158	}
2159	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::InferenceResult {}
2160	impl flutter_rust_bridge::IntoIntoDart<crate::api::InferenceResult>
2161	for crate::api::InferenceResult
2162	{
2163	fn into_into_dart(self) -> crate::api::InferenceResult {
2164	self
2165	}
2166	}
2167	// Codec=Dco (DartCObject based), see doc to use other codecs
2168	impl flutter_rust_bridge::IntoDart for crate::api::OndeError {
2169	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2170	match self {
2171	crate::api::OndeError::NoModelLoaded => [0.into_dart()].into_dart(),
2172	crate::api::OndeError::AlreadyLoaded { model_name } => {
2173	[1.into_dart(), model_name.into_into_dart().into_dart()].into_dart()
2174	}
2175	crate::api::OndeError::ModelBuild { reason } => {
2176	[2.into_dart(), reason.into_into_dart().into_dart()].into_dart()
2177	}
2178	crate::api::OndeError::Inference { reason } => {
2179	[3.into_dart(), reason.into_into_dart().into_dart()].into_dart()
2180	}
2181	crate::api::OndeError::Cancelled => [4.into_dart()].into_dart(),
2182	crate::api::OndeError::Other { reason } => {
2183	[5.into_dart(), reason.into_into_dart().into_dart()].into_dart()
2184	}
2185	_ => {
2186	unimplemented!("");
2187	}
2188	}
2189	}
2190	}
2191	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::OndeError {}
2192	impl flutter_rust_bridge::IntoIntoDart<crate::api::OndeError> for crate::api::OndeError {
2193	fn into_into_dart(self) -> crate::api::OndeError {
2194	self
2195	}
2196	}
2197	// Codec=Dco (DartCObject based), see doc to use other codecs
2198	impl flutter_rust_bridge::IntoDart for crate::api::SamplingConfig {
2199	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2200	[
2201	self.temperature.into_into_dart().into_dart(),
2202	self.top_p.into_into_dart().into_dart(),
2203	self.top_k.into_into_dart().into_dart(),
2204	self.min_p.into_into_dart().into_dart(),
2205	self.max_tokens.into_into_dart().into_dart(),
2206	self.frequency_penalty.into_into_dart().into_dart(),
2207	self.presence_penalty.into_into_dart().into_dart(),
2208	]
2209	.into_dart()
2210	}
2211	}
2212	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::SamplingConfig {}
2213	impl flutter_rust_bridge::IntoIntoDart<crate::api::SamplingConfig> for crate::api::SamplingConfig {
2214	fn into_into_dart(self) -> crate::api::SamplingConfig {
2215	self
2216	}
2217	}
2218	// Codec=Dco (DartCObject based), see doc to use other codecs
2219	impl flutter_rust_bridge::IntoDart for crate::api::StreamChunk {
2220	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2221	[
2222	self.delta.into_into_dart().into_dart(),
2223	self.done.into_into_dart().into_dart(),
2224	self.finish_reason.into_into_dart().into_dart(),
2225	]
2226	.into_dart()
2227	}
2228	}
2229	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::StreamChunk {}
2230	impl flutter_rust_bridge::IntoIntoDart<crate::api::StreamChunk> for crate::api::StreamChunk {
2231	fn into_into_dart(self) -> crate::api::StreamChunk {
2232	self
2233	}
2234	}
2235	// Codec=Dco (DartCObject based), see doc to use other codecs
2236	impl flutter_rust_bridge::IntoDart for crate::api::ToolCallInfo {
2237	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2238	[
2239	self.id.into_into_dart().into_dart(),
2240	self.function_name.into_into_dart().into_dart(),
2241	self.arguments.into_into_dart().into_dart(),
2242	]
2243	.into_dart()
2244	}
2245	}
2246	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::ToolCallInfo {}
2247	impl flutter_rust_bridge::IntoIntoDart<crate::api::ToolCallInfo> for crate::api::ToolCallInfo {
2248	fn into_into_dart(self) -> crate::api::ToolCallInfo {
2249	self
2250	}
2251	}
2252	// Codec=Dco (DartCObject based), see doc to use other codecs
2253	impl flutter_rust_bridge::IntoDart for crate::api::UqffModelConfig {
2254	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2255	[
2256	self.model_id.into_into_dart().into_dart(),
2257	self.files.into_into_dart().into_dart(),
2258	self.display_name.into_into_dart().into_dart(),
2259	self.approx_memory.into_into_dart().into_dart(),
2260	self.chat_template.into_into_dart().into_dart(),
2261	]
2262	.into_dart()
2263	}
2264	}
2265	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::UqffModelConfig {}
2266	impl flutter_rust_bridge::IntoIntoDart<crate::api::UqffModelConfig>
2267	for crate::api::UqffModelConfig
2268	{
2269	fn into_into_dart(self) -> crate::api::UqffModelConfig {
2270	self
2271	}
2272	}
2273
2274	impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
2275	// Codec=Sse (Serialization based), see doc to use other codecs
2276	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2277	<String>::sse_encode(format!("{:?}", self), serializer);
2278	}
2279	}
2280
2281	impl SseEncode for OndeChatEngine {
2282	// Codec=Sse (Serialization based), see doc to use other codecs
2283	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2284	<RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
2285	}
2286	}
2287
2288	impl SseEncode
2289	for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>
2290	{
2291	// Codec=Sse (Serialization based), see doc to use other codecs
2292	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2293	let (ptr, size) = self.sse_encode_raw();
2294	<usize>::sse_encode(ptr, serializer);
2295	<i32>::sse_encode(size, serializer);
2296	}
2297	}
2298
2299	impl SseEncode
2300	for StreamSink<crate::api::StreamChunk, flutter_rust_bridge::for_generated::SseCodec>
2301	{
2302	// Codec=Sse (Serialization based), see doc to use other codecs
2303	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2304	unimplemented!("")
2305	}
2306	}
2307
2308	impl SseEncode for String {
2309	// Codec=Sse (Serialization based), see doc to use other codecs
2310	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2311	<Vec<u8>>::sse_encode(self.into_bytes(), serializer);
2312	}
2313	}
2314
2315	impl SseEncode for bool {
2316	// Codec=Sse (Serialization based), see doc to use other codecs
2317	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2318	serializer.cursor.write_u8(self as _).unwrap();
2319	}
2320	}
2321
2322	impl SseEncode for crate::api::ChatMessage {
2323	// Codec=Sse (Serialization based), see doc to use other codecs
2324	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2325	<crate::api::ChatRole>::sse_encode(self.role, serializer);
2326	<String>::sse_encode(self.content, serializer);
2327	}
2328	}
2329
2330	impl SseEncode for crate::api::ChatRole {
2331	// Codec=Sse (Serialization based), see doc to use other codecs
2332	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2333	<i32>::sse_encode(
2334	match self {
2335	crate::api::ChatRole::System => 0,
2336	crate::api::ChatRole::User => 1,
2337	crate::api::ChatRole::Assistant => 2,
2338	_ => {
2339	unimplemented!("");
2340	}
2341	},
2342	serializer,
2343	);
2344	}
2345	}
2346
2347	impl SseEncode for crate::api::EngineInfo {
2348	// Codec=Sse (Serialization based), see doc to use other codecs
2349	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2350	<crate::api::EngineStatus>::sse_encode(self.status, serializer);
2351	<Option<String>>::sse_encode(self.model_name, serializer);
2352	<Option<String>>::sse_encode(self.approx_memory, serializer);
2353	<u64>::sse_encode(self.history_length, serializer);
2354	}
2355	}
2356
2357	impl SseEncode for crate::api::EngineStatus {
2358	// Codec=Sse (Serialization based), see doc to use other codecs
2359	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2360	<i32>::sse_encode(
2361	match self {
2362	crate::api::EngineStatus::Unloaded => 0,
2363	crate::api::EngineStatus::Loading => 1,
2364	crate::api::EngineStatus::Ready => 2,
2365	crate::api::EngineStatus::Generating => 3,
2366	crate::api::EngineStatus::Error => 4,
2367	_ => {
2368	unimplemented!("");
2369	}
2370	},
2371	serializer,
2372	);
2373	}
2374	}
2375
2376	impl SseEncode for f32 {
2377	// Codec=Sse (Serialization based), see doc to use other codecs
2378	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2379	serializer.cursor.write_f32::<NativeEndian>(self).unwrap();
2380	}
2381	}
2382
2383	impl SseEncode for f64 {
2384	// Codec=Sse (Serialization based), see doc to use other codecs
2385	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2386	serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
2387	}
2388	}
2389
2390	impl SseEncode for crate::api::GgufModelConfig {
2391	// Codec=Sse (Serialization based), see doc to use other codecs
2392	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2393	<String>::sse_encode(self.model_id, serializer);
2394	<Vec<String>>::sse_encode(self.files, serializer);
2395	<Option<String>>::sse_encode(self.tok_model_id, serializer);
2396	<String>::sse_encode(self.display_name, serializer);
2397	<String>::sse_encode(self.approx_memory, serializer);
2398	}
2399	}
2400
2401	impl SseEncode for i32 {
2402	// Codec=Sse (Serialization based), see doc to use other codecs
2403	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2404	serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
2405	}
2406	}
2407
2408	impl SseEncode for crate::api::InferenceResult {
2409	// Codec=Sse (Serialization based), see doc to use other codecs
2410	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2411	<String>::sse_encode(self.text, serializer);
2412	<f64>::sse_encode(self.duration_secs, serializer);
2413	<String>::sse_encode(self.duration_display, serializer);
2414	<String>::sse_encode(self.finish_reason, serializer);
2415	<Vec<crate::api::ToolCallInfo>>::sse_encode(self.tool_calls, serializer);
2416	}
2417	}
2418
2419	impl SseEncode for Vec<String> {
2420	// Codec=Sse (Serialization based), see doc to use other codecs
2421	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2422	<i32>::sse_encode(self.len() as _, serializer);
2423	for item in self {
2424	<String>::sse_encode(item, serializer);
2425	}
2426	}
2427	}
2428
2429	impl SseEncode for Vec<crate::api::ChatMessage> {
2430	// Codec=Sse (Serialization based), see doc to use other codecs
2431	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2432	<i32>::sse_encode(self.len() as _, serializer);
2433	for item in self {
2434	<crate::api::ChatMessage>::sse_encode(item, serializer);
2435	}
2436	}
2437	}
2438
2439	impl SseEncode for Vec<u8> {
2440	// Codec=Sse (Serialization based), see doc to use other codecs
2441	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2442	<i32>::sse_encode(self.len() as _, serializer);
2443	for item in self {
2444	<u8>::sse_encode(item, serializer);
2445	}
2446	}
2447	}
2448
2449	impl SseEncode for Vec<crate::api::ToolCallInfo> {
2450	// Codec=Sse (Serialization based), see doc to use other codecs
2451	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2452	<i32>::sse_encode(self.len() as _, serializer);
2453	for item in self {
2454	<crate::api::ToolCallInfo>::sse_encode(item, serializer);
2455	}
2456	}
2457	}
2458
2459	impl SseEncode for crate::api::OndeError {
2460	// Codec=Sse (Serialization based), see doc to use other codecs
2461	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2462	match self {
2463	crate::api::OndeError::NoModelLoaded => {
2464	<i32>::sse_encode(0, serializer);
2465	}
2466	crate::api::OndeError::AlreadyLoaded { model_name } => {
2467	<i32>::sse_encode(1, serializer);
2468	<String>::sse_encode(model_name, serializer);
2469	}
2470	crate::api::OndeError::ModelBuild { reason } => {
2471	<i32>::sse_encode(2, serializer);
2472	<String>::sse_encode(reason, serializer);
2473	}
2474	crate::api::OndeError::Inference { reason } => {
2475	<i32>::sse_encode(3, serializer);
2476	<String>::sse_encode(reason, serializer);
2477	}
2478	crate::api::OndeError::Cancelled => {
2479	<i32>::sse_encode(4, serializer);
2480	}
2481	crate::api::OndeError::Other { reason } => {
2482	<i32>::sse_encode(5, serializer);
2483	<String>::sse_encode(reason, serializer);
2484	}
2485	_ => {
2486	unimplemented!("");
2487	}
2488	}
2489	}
2490	}
2491
2492	impl SseEncode for Option<String> {
2493	// Codec=Sse (Serialization based), see doc to use other codecs
2494	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2495	<bool>::sse_encode(self.is_some(), serializer);
2496	if let Some(value) = self {
2497	<String>::sse_encode(value, serializer);
2498	}
2499	}
2500	}
2501
2502	impl SseEncode for Option<f32> {
2503	// Codec=Sse (Serialization based), see doc to use other codecs
2504	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2505	<bool>::sse_encode(self.is_some(), serializer);
2506	if let Some(value) = self {
2507	<f32>::sse_encode(value, serializer);
2508	}
2509	}
2510	}
2511
2512	impl SseEncode for Option<f64> {
2513	// Codec=Sse (Serialization based), see doc to use other codecs
2514	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2515	<bool>::sse_encode(self.is_some(), serializer);
2516	if let Some(value) = self {
2517	<f64>::sse_encode(value, serializer);
2518	}
2519	}
2520	}
2521
2522	impl SseEncode for Option<crate::api::SamplingConfig> {
2523	// Codec=Sse (Serialization based), see doc to use other codecs
2524	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2525	<bool>::sse_encode(self.is_some(), serializer);
2526	if let Some(value) = self {
2527	<crate::api::SamplingConfig>::sse_encode(value, serializer);
2528	}
2529	}
2530	}
2531
2532	impl SseEncode for Option<u64> {
2533	// Codec=Sse (Serialization based), see doc to use other codecs
2534	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2535	<bool>::sse_encode(self.is_some(), serializer);
2536	if let Some(value) = self {
2537	<u64>::sse_encode(value, serializer);
2538	}
2539	}
2540	}
2541
2542	impl SseEncode for crate::api::SamplingConfig {
2543	// Codec=Sse (Serialization based), see doc to use other codecs
2544	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2545	<Option<f64>>::sse_encode(self.temperature, serializer);
2546	<Option<f64>>::sse_encode(self.top_p, serializer);
2547	<Option<u64>>::sse_encode(self.top_k, serializer);
2548	<Option<f64>>::sse_encode(self.min_p, serializer);
2549	<Option<u64>>::sse_encode(self.max_tokens, serializer);
2550	<Option<f32>>::sse_encode(self.frequency_penalty, serializer);
2551	<Option<f32>>::sse_encode(self.presence_penalty, serializer);
2552	}
2553	}
2554
2555	impl SseEncode for crate::api::StreamChunk {
2556	// Codec=Sse (Serialization based), see doc to use other codecs
2557	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2558	<String>::sse_encode(self.delta, serializer);
2559	<bool>::sse_encode(self.done, serializer);
2560	<Option<String>>::sse_encode(self.finish_reason, serializer);
2561	}
2562	}
2563
2564	impl SseEncode for crate::api::ToolCallInfo {
2565	// Codec=Sse (Serialization based), see doc to use other codecs
2566	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2567	<String>::sse_encode(self.id, serializer);
2568	<String>::sse_encode(self.function_name, serializer);
2569	<String>::sse_encode(self.arguments, serializer);
2570	}
2571	}
2572
2573	impl SseEncode for u64 {
2574	// Codec=Sse (Serialization based), see doc to use other codecs
2575	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2576	serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
2577	}
2578	}
2579
2580	impl SseEncode for u8 {
2581	// Codec=Sse (Serialization based), see doc to use other codecs
2582	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2583	serializer.cursor.write_u8(self).unwrap();
2584	}
2585	}
2586
2587	impl SseEncode for () {
2588	// Codec=Sse (Serialization based), see doc to use other codecs
2589	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
2590	}
2591
2592	impl SseEncode for crate::api::UqffModelConfig {
2593	// Codec=Sse (Serialization based), see doc to use other codecs
2594	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2595	<String>::sse_encode(self.model_id, serializer);
2596	<Vec<String>>::sse_encode(self.files, serializer);
2597	<String>::sse_encode(self.display_name, serializer);
2598	<String>::sse_encode(self.approx_memory, serializer);
2599	<Option<String>>::sse_encode(self.chat_template, serializer);
2600	}
2601	}
2602
2603	impl SseEncode for usize {
2604	// Codec=Sse (Serialization based), see doc to use other codecs
2605	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2606	serializer
2607	.cursor
2608	.write_u64::<NativeEndian>(self as _)
2609	.unwrap();
2610	}
2611	}
2612
2613	#[cfg(not(target_family = "wasm"))]
2614	mod io {
2615	// This file is automatically generated, so please do not edit it.
2616	// @generated by `flutter_rust_bridge`@ 2.12.0.
2617
2618	// Section: imports
2619
2620	use super::*;
2621	use crate::api::*;
2622	use flutter_rust_bridge::for_generated::byteorder::{
2623	NativeEndian, ReadBytesExt, WriteBytesExt,
2624	};
2625	use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
2626	use flutter_rust_bridge::{Handler, IntoIntoDart};
2627
2628	// Section: boilerplate
2629
2630	flutter_rust_bridge::frb_generated_boilerplate_io!();
2631
2632	#[unsafe(no_mangle)]
2633	pub extern "C" fn frbgen_onde_inference_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOndeChatEngine(
2634	ptr: *const std::ffi::c_void,
2635	) {
2636	MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>::increment_strong_count(ptr as _);
2637	}
2638
2639	#[unsafe(no_mangle)]
2640	pub extern "C" fn frbgen_onde_inference_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOndeChatEngine(
2641	ptr: *const std::ffi::c_void,
2642	) {
2643	MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>::decrement_strong_count(ptr as _);
2644	}
2645	}
2646	#[cfg(not(target_family = "wasm"))]
2647	pub use io::*;