frb_generated.rs · ondeinference/onde

@ondeinference / onde

Code Commits Issues Pulls Cloud Agent CI/CD

feature/diffusion-vision

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

rs 2,489 lines 101 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 = -1719313298;
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_new_impl(
528	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
529	rust_vec_len_: i32,
530	data_len_: i32,
531	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
532	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
533	flutter_rust_bridge::for_generated::TaskInfo {
534	debug_name: "OndeChatEngine_new",
535	port: None,
536	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
537	},
538	move \|\| {
539	let message = unsafe {
540	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
541	ptr_,
542	rust_vec_len_,
543	data_len_,
544	)
545	};
546	let mut deserializer =
547	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
548	deserializer.end();
549	transform_result_sse::<_, ()>((move \|\| {
550	let output_ok = Result::<_, ()>::Ok(crate::api::OndeChatEngine::new())?;
551	Ok(output_ok)
552	})())
553	},
554	)
555	}
556	fn wire__crate__api__OndeChatEngine_push_history_impl(
557	port_: flutter_rust_bridge::for_generated::MessagePort,
558	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
559	rust_vec_len_: i32,
560	data_len_: i32,
561	) {
562	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
563	flutter_rust_bridge::for_generated::TaskInfo {
564	debug_name: "OndeChatEngine_push_history",
565	port: Some(port_),
566	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
567	},
568	move \|\| {
569	let message = unsafe {
570	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
571	ptr_,
572	rust_vec_len_,
573	data_len_,
574	)
575	};
576	let mut deserializer =
577	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
578	let api_that = <RustOpaqueMoi<
579	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
580	>>::sse_decode(&mut deserializer);
581	let api_message = <crate::api::ChatMessage>::sse_decode(&mut deserializer);
582	deserializer.end();
583	move \|context\| async move {
584	transform_result_sse::<_, ()>(
585	(move \|\| async move {
586	let mut api_that_guard = None;
587	let decode_indices_ =
588	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
589	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
590	&api_that, 0, false,
591	)],
592	);
593	for i in decode_indices_ {
594	match i {
595	0 => {
596	api_that_guard =
597	Some(api_that.lockable_decode_async_ref().await)
598	}
599	_ => unreachable!(),
600	}
601	}
602	let api_that_guard = api_that_guard.unwrap();
603	let output_ok = Result::<_, ()>::Ok({
604	crate::api::OndeChatEngine::push_history(&*api_that_guard, api_message)
605	.await;
606	})?;
607	Ok(output_ok)
608	})()
609	.await,
610	)
611	}
612	},
613	)
614	}
615	fn wire__crate__api__OndeChatEngine_send_message_impl(
616	port_: flutter_rust_bridge::for_generated::MessagePort,
617	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
618	rust_vec_len_: i32,
619	data_len_: i32,
620	) {
621	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
622	flutter_rust_bridge::for_generated::TaskInfo {
623	debug_name: "OndeChatEngine_send_message",
624	port: Some(port_),
625	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
626	},
627	move \|\| {
628	let message = unsafe {
629	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
630	ptr_,
631	rust_vec_len_,
632	data_len_,
633	)
634	};
635	let mut deserializer =
636	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
637	let api_that = <RustOpaqueMoi<
638	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
639	>>::sse_decode(&mut deserializer);
640	let api_message = <String>::sse_decode(&mut deserializer);
641	deserializer.end();
642	move \|context\| async move {
643	transform_result_sse::<_, crate::api::OndeError>(
644	(move \|\| async move {
645	let mut api_that_guard = None;
646	let decode_indices_ =
647	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
648	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
649	&api_that, 0, false,
650	)],
651	);
652	for i in decode_indices_ {
653	match i {
654	0 => {
655	api_that_guard =
656	Some(api_that.lockable_decode_async_ref().await)
657	}
658	_ => unreachable!(),
659	}
660	}
661	let api_that_guard = api_that_guard.unwrap();
662	let output_ok =
663	crate::api::OndeChatEngine::send_message(&*api_that_guard, api_message)
664	.await?;
665	Ok(output_ok)
666	})()
667	.await,
668	)
669	}
670	},
671	)
672	}
673	fn wire__crate__api__OndeChatEngine_set_sampling_impl(
674	port_: flutter_rust_bridge::for_generated::MessagePort,
675	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
676	rust_vec_len_: i32,
677	data_len_: i32,
678	) {
679	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
680	flutter_rust_bridge::for_generated::TaskInfo {
681	debug_name: "OndeChatEngine_set_sampling",
682	port: Some(port_),
683	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
684	},
685	move \|\| {
686	let message = unsafe {
687	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
688	ptr_,
689	rust_vec_len_,
690	data_len_,
691	)
692	};
693	let mut deserializer =
694	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
695	let api_that = <RustOpaqueMoi<
696	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
697	>>::sse_decode(&mut deserializer);
698	let api_sampling = <crate::api::SamplingConfig>::sse_decode(&mut deserializer);
699	deserializer.end();
700	move \|context\| async move {
701	transform_result_sse::<_, ()>(
702	(move \|\| async move {
703	let mut api_that_guard = None;
704	let decode_indices_ =
705	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
706	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
707	&api_that, 0, false,
708	)],
709	);
710	for i in decode_indices_ {
711	match i {
712	0 => {
713	api_that_guard =
714	Some(api_that.lockable_decode_async_ref().await)
715	}
716	_ => unreachable!(),
717	}
718	}
719	let api_that_guard = api_that_guard.unwrap();
720	let output_ok = Result::<_, ()>::Ok({
721	crate::api::OndeChatEngine::set_sampling(
722	&*api_that_guard,
723	api_sampling,
724	)
725	.await;
726	})?;
727	Ok(output_ok)
728	})()
729	.await,
730	)
731	}
732	},
733	)
734	}
735	fn wire__crate__api__OndeChatEngine_set_system_prompt_impl(
736	port_: flutter_rust_bridge::for_generated::MessagePort,
737	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
738	rust_vec_len_: i32,
739	data_len_: i32,
740	) {
741	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
742	flutter_rust_bridge::for_generated::TaskInfo {
743	debug_name: "OndeChatEngine_set_system_prompt",
744	port: Some(port_),
745	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
746	},
747	move \|\| {
748	let message = unsafe {
749	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
750	ptr_,
751	rust_vec_len_,
752	data_len_,
753	)
754	};
755	let mut deserializer =
756	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
757	let api_that = <RustOpaqueMoi<
758	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
759	>>::sse_decode(&mut deserializer);
760	let api_prompt = <String>::sse_decode(&mut deserializer);
761	deserializer.end();
762	move \|context\| async move {
763	transform_result_sse::<_, ()>(
764	(move \|\| async move {
765	let mut api_that_guard = None;
766	let decode_indices_ =
767	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
768	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
769	&api_that, 0, false,
770	)],
771	);
772	for i in decode_indices_ {
773	match i {
774	0 => {
775	api_that_guard =
776	Some(api_that.lockable_decode_async_ref().await)
777	}
778	_ => unreachable!(),
779	}
780	}
781	let api_that_guard = api_that_guard.unwrap();
782	let output_ok = Result::<_, ()>::Ok({
783	crate::api::OndeChatEngine::set_system_prompt(
784	&*api_that_guard,
785	api_prompt,
786	)
787	.await;
788	})?;
789	Ok(output_ok)
790	})()
791	.await,
792	)
793	}
794	},
795	)
796	}
797	fn wire__crate__api__OndeChatEngine_stream_message_impl(
798	port_: flutter_rust_bridge::for_generated::MessagePort,
799	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
800	rust_vec_len_: i32,
801	data_len_: i32,
802	) {
803	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
804	flutter_rust_bridge::for_generated::TaskInfo {
805	debug_name: "OndeChatEngine_stream_message",
806	port: Some(port_),
807	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
808	},
809	move \|\| {
810	let message = unsafe {
811	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
812	ptr_,
813	rust_vec_len_,
814	data_len_,
815	)
816	};
817	let mut deserializer =
818	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
819	let api_that = <RustOpaqueMoi<
820	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
821	>>::sse_decode(&mut deserializer);
822	let api_message = <String>::sse_decode(&mut deserializer);
823	let api_sink = <StreamSink<
824	crate::api::StreamChunk,
825	flutter_rust_bridge::for_generated::SseCodec,
826	>>::sse_decode(&mut deserializer);
827	deserializer.end();
828	move \|context\| async move {
829	transform_result_sse::<_, crate::api::OndeError>(
830	(move \|\| async move {
831	let mut api_that_guard = None;
832	let decode_indices_ =
833	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
834	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
835	&api_that, 0, false,
836	)],
837	);
838	for i in decode_indices_ {
839	match i {
840	0 => {
841	api_that_guard =
842	Some(api_that.lockable_decode_async_ref().await)
843	}
844	_ => unreachable!(),
845	}
846	}
847	let api_that_guard = api_that_guard.unwrap();
848	let output_ok = crate::api::OndeChatEngine::stream_message(
849	&*api_that_guard,
850	api_message,
851	api_sink,
852	)
853	.await?;
854	Ok(output_ok)
855	})()
856	.await,
857	)
858	}
859	},
860	)
861	}
862	fn wire__crate__api__OndeChatEngine_unload_model_impl(
863	port_: flutter_rust_bridge::for_generated::MessagePort,
864	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
865	rust_vec_len_: i32,
866	data_len_: i32,
867	) {
868	FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
869	flutter_rust_bridge::for_generated::TaskInfo {
870	debug_name: "OndeChatEngine_unload_model",
871	port: Some(port_),
872	mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
873	},
874	move \|\| {
875	let message = unsafe {
876	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
877	ptr_,
878	rust_vec_len_,
879	data_len_,
880	)
881	};
882	let mut deserializer =
883	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
884	let api_that = <RustOpaqueMoi<
885	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
886	>>::sse_decode(&mut deserializer);
887	deserializer.end();
888	move \|context\| async move {
889	transform_result_sse::<_, ()>(
890	(move \|\| async move {
891	let mut api_that_guard = None;
892	let decode_indices_ =
893	flutter_rust_bridge::for_generated::lockable_compute_decode_order(
894	vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
895	&api_that, 0, false,
896	)],
897	);
898	for i in decode_indices_ {
899	match i {
900	0 => {
901	api_that_guard =
902	Some(api_that.lockable_decode_async_ref().await)
903	}
904	_ => unreachable!(),
905	}
906	}
907	let api_that_guard = api_that_guard.unwrap();
908	let output_ok = Result::<_, ()>::Ok(
909	crate::api::OndeChatEngine::unload_model(&*api_that_guard).await,
910	)?;
911	Ok(output_ok)
912	})()
913	.await,
914	)
915	}
916	},
917	)
918	}
919	fn wire__crate__api__configure_cache_dir_impl(
920	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
921	rust_vec_len_: i32,
922	data_len_: i32,
923	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
924	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
925	flutter_rust_bridge::for_generated::TaskInfo {
926	debug_name: "configure_cache_dir",
927	port: None,
928	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
929	},
930	move \|\| {
931	let message = unsafe {
932	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
933	ptr_,
934	rust_vec_len_,
935	data_len_,
936	)
937	};
938	let mut deserializer =
939	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
940	let api_app_data_dir = <String>::sse_decode(&mut deserializer);
941	deserializer.end();
942	transform_result_sse::<_, crate::api::OndeError>((move \|\| {
943	let output_ok = crate::api::configure_cache_dir(api_app_data_dir)?;
944	Ok(output_ok)
945	})())
946	},
947	)
948	}
949	fn wire__crate__api__default_model_config_impl(
950	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
951	rust_vec_len_: i32,
952	data_len_: i32,
953	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
954	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
955	flutter_rust_bridge::for_generated::TaskInfo {
956	debug_name: "default_model_config",
957	port: None,
958	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
959	},
960	move \|\| {
961	let message = unsafe {
962	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
963	ptr_,
964	rust_vec_len_,
965	data_len_,
966	)
967	};
968	let mut deserializer =
969	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
970	deserializer.end();
971	transform_result_sse::<_, ()>((move \|\| {
972	let output_ok = Result::<_, ()>::Ok(crate::api::default_model_config())?;
973	Ok(output_ok)
974	})())
975	},
976	)
977	}
978	fn wire__crate__api__default_sampling_config_impl(
979	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
980	rust_vec_len_: i32,
981	data_len_: i32,
982	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
983	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
984	flutter_rust_bridge::for_generated::TaskInfo {
985	debug_name: "default_sampling_config",
986	port: None,
987	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
988	},
989	move \|\| {
990	let message = unsafe {
991	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
992	ptr_,
993	rust_vec_len_,
994	data_len_,
995	)
996	};
997	let mut deserializer =
998	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
999	deserializer.end();
1000	transform_result_sse::<_, ()>((move \|\| {
1001	let output_ok = Result::<_, ()>::Ok(crate::api::default_sampling_config())?;
1002	Ok(output_ok)
1003	})())
1004	},
1005	)
1006	}
1007	fn wire__crate__api__deterministic_sampling_config_impl(
1008	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1009	rust_vec_len_: i32,
1010	data_len_: i32,
1011	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1012	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1013	flutter_rust_bridge::for_generated::TaskInfo {
1014	debug_name: "deterministic_sampling_config",
1015	port: None,
1016	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1017	},
1018	move \|\| {
1019	let message = unsafe {
1020	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1021	ptr_,
1022	rust_vec_len_,
1023	data_len_,
1024	)
1025	};
1026	let mut deserializer =
1027	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1028	deserializer.end();
1029	transform_result_sse::<_, ()>((move \|\| {
1030	let output_ok = Result::<_, ()>::Ok(crate::api::deterministic_sampling_config())?;
1031	Ok(output_ok)
1032	})())
1033	},
1034	)
1035	}
1036	fn wire__crate__api__mobile_sampling_config_impl(
1037	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1038	rust_vec_len_: i32,
1039	data_len_: i32,
1040	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1041	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1042	flutter_rust_bridge::for_generated::TaskInfo {
1043	debug_name: "mobile_sampling_config",
1044	port: None,
1045	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1046	},
1047	move \|\| {
1048	let message = unsafe {
1049	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1050	ptr_,
1051	rust_vec_len_,
1052	data_len_,
1053	)
1054	};
1055	let mut deserializer =
1056	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1057	deserializer.end();
1058	transform_result_sse::<_, ()>((move \|\| {
1059	let output_ok = Result::<_, ()>::Ok(crate::api::mobile_sampling_config())?;
1060	Ok(output_ok)
1061	})())
1062	},
1063	)
1064	}
1065	fn wire__crate__api__qwen25_1_5b_config_impl(
1066	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1067	rust_vec_len_: i32,
1068	data_len_: i32,
1069	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1070	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1071	flutter_rust_bridge::for_generated::TaskInfo {
1072	debug_name: "qwen25_1_5b_config",
1073	port: None,
1074	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1075	},
1076	move \|\| {
1077	let message = unsafe {
1078	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1079	ptr_,
1080	rust_vec_len_,
1081	data_len_,
1082	)
1083	};
1084	let mut deserializer =
1085	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1086	deserializer.end();
1087	transform_result_sse::<_, ()>((move \|\| {
1088	let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_1_5b_config())?;
1089	Ok(output_ok)
1090	})())
1091	},
1092	)
1093	}
1094	fn wire__crate__api__qwen25_3b_config_impl(
1095	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1096	rust_vec_len_: i32,
1097	data_len_: i32,
1098	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1099	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1100	flutter_rust_bridge::for_generated::TaskInfo {
1101	debug_name: "qwen25_3b_config",
1102	port: None,
1103	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1104	},
1105	move \|\| {
1106	let message = unsafe {
1107	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1108	ptr_,
1109	rust_vec_len_,
1110	data_len_,
1111	)
1112	};
1113	let mut deserializer =
1114	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1115	deserializer.end();
1116	transform_result_sse::<_, ()>((move \|\| {
1117	let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_3b_config())?;
1118	Ok(output_ok)
1119	})())
1120	},
1121	)
1122	}
1123	fn wire__crate__api__qwen25_coder_1_5b_config_impl(
1124	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1125	rust_vec_len_: i32,
1126	data_len_: i32,
1127	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1128	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1129	flutter_rust_bridge::for_generated::TaskInfo {
1130	debug_name: "qwen25_coder_1_5b_config",
1131	port: None,
1132	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1133	},
1134	move \|\| {
1135	let message = unsafe {
1136	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1137	ptr_,
1138	rust_vec_len_,
1139	data_len_,
1140	)
1141	};
1142	let mut deserializer =
1143	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1144	deserializer.end();
1145	transform_result_sse::<_, ()>((move \|\| {
1146	let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_coder_1_5b_config())?;
1147	Ok(output_ok)
1148	})())
1149	},
1150	)
1151	}
1152	fn wire__crate__api__qwen25_coder_3b_config_impl(
1153	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1154	rust_vec_len_: i32,
1155	data_len_: i32,
1156	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1157	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1158	flutter_rust_bridge::for_generated::TaskInfo {
1159	debug_name: "qwen25_coder_3b_config",
1160	port: None,
1161	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1162	},
1163	move \|\| {
1164	let message = unsafe {
1165	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1166	ptr_,
1167	rust_vec_len_,
1168	data_len_,
1169	)
1170	};
1171	let mut deserializer =
1172	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1173	deserializer.end();
1174	transform_result_sse::<_, ()>((move \|\| {
1175	let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_coder_3b_config())?;
1176	Ok(output_ok)
1177	})())
1178	},
1179	)
1180	}
1181	fn wire__crate__api__qwen3_0_6b_config_impl(
1182	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1183	rust_vec_len_: i32,
1184	data_len_: i32,
1185	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1186	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1187	flutter_rust_bridge::for_generated::TaskInfo {
1188	debug_name: "qwen3_0_6b_config",
1189	port: None,
1190	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1191	},
1192	move \|\| {
1193	let message = unsafe {
1194	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1195	ptr_,
1196	rust_vec_len_,
1197	data_len_,
1198	)
1199	};
1200	let mut deserializer =
1201	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1202	deserializer.end();
1203	transform_result_sse::<_, ()>((move \|\| {
1204	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_0_6b_config())?;
1205	Ok(output_ok)
1206	})())
1207	},
1208	)
1209	}
1210	fn wire__crate__api__qwen3_14b_config_impl(
1211	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1212	rust_vec_len_: i32,
1213	data_len_: i32,
1214	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1215	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1216	flutter_rust_bridge::for_generated::TaskInfo {
1217	debug_name: "qwen3_14b_config",
1218	port: None,
1219	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1220	},
1221	move \|\| {
1222	let message = unsafe {
1223	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1224	ptr_,
1225	rust_vec_len_,
1226	data_len_,
1227	)
1228	};
1229	let mut deserializer =
1230	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1231	deserializer.end();
1232	transform_result_sse::<_, ()>((move \|\| {
1233	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_14b_config())?;
1234	Ok(output_ok)
1235	})())
1236	},
1237	)
1238	}
1239	fn wire__crate__api__qwen3_1_7b_config_impl(
1240	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1241	rust_vec_len_: i32,
1242	data_len_: i32,
1243	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1244	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1245	flutter_rust_bridge::for_generated::TaskInfo {
1246	debug_name: "qwen3_1_7b_config",
1247	port: None,
1248	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1249	},
1250	move \|\| {
1251	let message = unsafe {
1252	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1253	ptr_,
1254	rust_vec_len_,
1255	data_len_,
1256	)
1257	};
1258	let mut deserializer =
1259	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1260	deserializer.end();
1261	transform_result_sse::<_, ()>((move \|\| {
1262	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_1_7b_config())?;
1263	Ok(output_ok)
1264	})())
1265	},
1266	)
1267	}
1268	fn wire__crate__api__qwen3_30b_a3b_instruct_2507_config_impl(
1269	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1270	rust_vec_len_: i32,
1271	data_len_: i32,
1272	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1273	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1274	flutter_rust_bridge::for_generated::TaskInfo {
1275	debug_name: "qwen3_30b_a3b_instruct_2507_config",
1276	port: None,
1277	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1278	},
1279	move \|\| {
1280	let message = unsafe {
1281	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1282	ptr_,
1283	rust_vec_len_,
1284	data_len_,
1285	)
1286	};
1287	let mut deserializer =
1288	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1289	deserializer.end();
1290	transform_result_sse::<_, ()>((move \|\| {
1291	let output_ok =
1292	Result::<_, ()>::Ok(crate::api::qwen3_30b_a3b_instruct_2507_config())?;
1293	Ok(output_ok)
1294	})())
1295	},
1296	)
1297	}
1298	fn wire__crate__api__qwen3_32b_config_impl(
1299	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1300	rust_vec_len_: i32,
1301	data_len_: i32,
1302	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1303	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1304	flutter_rust_bridge::for_generated::TaskInfo {
1305	debug_name: "qwen3_32b_config",
1306	port: None,
1307	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1308	},
1309	move \|\| {
1310	let message = unsafe {
1311	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1312	ptr_,
1313	rust_vec_len_,
1314	data_len_,
1315	)
1316	};
1317	let mut deserializer =
1318	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1319	deserializer.end();
1320	transform_result_sse::<_, ()>((move \|\| {
1321	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_32b_config())?;
1322	Ok(output_ok)
1323	})())
1324	},
1325	)
1326	}
1327	fn wire__crate__api__qwen3_4b_config_impl(
1328	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1329	rust_vec_len_: i32,
1330	data_len_: i32,
1331	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1332	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1333	flutter_rust_bridge::for_generated::TaskInfo {
1334	debug_name: "qwen3_4b_config",
1335	port: None,
1336	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1337	},
1338	move \|\| {
1339	let message = unsafe {
1340	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1341	ptr_,
1342	rust_vec_len_,
1343	data_len_,
1344	)
1345	};
1346	let mut deserializer =
1347	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1348	deserializer.end();
1349	transform_result_sse::<_, ()>((move \|\| {
1350	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_4b_config())?;
1351	Ok(output_ok)
1352	})())
1353	},
1354	)
1355	}
1356	fn wire__crate__api__qwen3_4b_instruct_2507_config_impl(
1357	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1358	rust_vec_len_: i32,
1359	data_len_: i32,
1360	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1361	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1362	flutter_rust_bridge::for_generated::TaskInfo {
1363	debug_name: "qwen3_4b_instruct_2507_config",
1364	port: None,
1365	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1366	},
1367	move \|\| {
1368	let message = unsafe {
1369	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1370	ptr_,
1371	rust_vec_len_,
1372	data_len_,
1373	)
1374	};
1375	let mut deserializer =
1376	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1377	deserializer.end();
1378	transform_result_sse::<_, ()>((move \|\| {
1379	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_4b_instruct_2507_config())?;
1380	Ok(output_ok)
1381	})())
1382	},
1383	)
1384	}
1385	fn wire__crate__api__qwen3_4b_thinking_2507_config_impl(
1386	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1387	rust_vec_len_: i32,
1388	data_len_: i32,
1389	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1390	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1391	flutter_rust_bridge::for_generated::TaskInfo {
1392	debug_name: "qwen3_4b_thinking_2507_config",
1393	port: None,
1394	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1395	},
1396	move \|\| {
1397	let message = unsafe {
1398	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1399	ptr_,
1400	rust_vec_len_,
1401	data_len_,
1402	)
1403	};
1404	let mut deserializer =
1405	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1406	deserializer.end();
1407	transform_result_sse::<_, ()>((move \|\| {
1408	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_4b_thinking_2507_config())?;
1409	Ok(output_ok)
1410	})())
1411	},
1412	)
1413	}
1414	fn wire__crate__api__qwen3_8b_config_impl(
1415	ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1416	rust_vec_len_: i32,
1417	data_len_: i32,
1418	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1419	FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1420	flutter_rust_bridge::for_generated::TaskInfo {
1421	debug_name: "qwen3_8b_config",
1422	port: None,
1423	mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1424	},
1425	move \|\| {
1426	let message = unsafe {
1427	flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1428	ptr_,
1429	rust_vec_len_,
1430	data_len_,
1431	)
1432	};
1433	let mut deserializer =
1434	flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1435	deserializer.end();
1436	transform_result_sse::<_, ()>((move \|\| {
1437	let output_ok = Result::<_, ()>::Ok(crate::api::qwen3_8b_config())?;
1438	Ok(output_ok)
1439	})())
1440	},
1441	)
1442	}
1443
1444	// Section: related_funcs
1445
1446	flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
1447	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>
1448	);
1449
1450	// Section: dart2rust
1451
1452	impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
1453	// Codec=Sse (Serialization based), see doc to use other codecs
1454	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1455	let mut inner = <String>::sse_decode(deserializer);
1456	return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
1457	}
1458	}
1459
1460	impl SseDecode for OndeChatEngine {
1461	// Codec=Sse (Serialization based), see doc to use other codecs
1462	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1463	let mut inner = <RustOpaqueMoi<
1464	flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
1465	>>::sse_decode(deserializer);
1466	return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
1467	}
1468	}
1469
1470	impl SseDecode
1471	for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>
1472	{
1473	// Codec=Sse (Serialization based), see doc to use other codecs
1474	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1475	let mut inner = <usize>::sse_decode(deserializer);
1476	return decode_rust_opaque_moi(inner);
1477	}
1478	}
1479
1480	impl SseDecode
1481	for StreamSink<crate::api::StreamChunk, flutter_rust_bridge::for_generated::SseCodec>
1482	{
1483	// Codec=Sse (Serialization based), see doc to use other codecs
1484	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1485	let mut inner = <String>::sse_decode(deserializer);
1486	return StreamSink::deserialize(inner);
1487	}
1488	}
1489
1490	impl SseDecode for String {
1491	// Codec=Sse (Serialization based), see doc to use other codecs
1492	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1493	let mut inner = <Vec<u8>>::sse_decode(deserializer);
1494	return String::from_utf8(inner).unwrap();
1495	}
1496	}
1497
1498	impl SseDecode for bool {
1499	// Codec=Sse (Serialization based), see doc to use other codecs
1500	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1501	deserializer.cursor.read_u8().unwrap() != 0
1502	}
1503	}
1504
1505	impl SseDecode for crate::api::ChatMessage {
1506	// Codec=Sse (Serialization based), see doc to use other codecs
1507	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1508	let mut var_role = <crate::api::ChatRole>::sse_decode(deserializer);
1509	let mut var_content = <String>::sse_decode(deserializer);
1510	return crate::api::ChatMessage {
1511	role: var_role,
1512	content: var_content,
1513	};
1514	}
1515	}
1516
1517	impl SseDecode for crate::api::ChatRole {
1518	// Codec=Sse (Serialization based), see doc to use other codecs
1519	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1520	let mut inner = <i32>::sse_decode(deserializer);
1521	return match inner {
1522	0 => crate::api::ChatRole::System,
1523	1 => crate::api::ChatRole::User,
1524	2 => crate::api::ChatRole::Assistant,
1525	_ => unreachable!("Invalid variant for ChatRole: {}", inner),
1526	};
1527	}
1528	}
1529
1530	impl SseDecode for crate::api::EngineInfo {
1531	// Codec=Sse (Serialization based), see doc to use other codecs
1532	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1533	let mut var_status = <crate::api::EngineStatus>::sse_decode(deserializer);
1534	let mut var_modelName = <Option<String>>::sse_decode(deserializer);
1535	let mut var_approxMemory = <Option<String>>::sse_decode(deserializer);
1536	let mut var_historyLength = <u64>::sse_decode(deserializer);
1537	return crate::api::EngineInfo {
1538	status: var_status,
1539	model_name: var_modelName,
1540	approx_memory: var_approxMemory,
1541	history_length: var_historyLength,
1542	};
1543	}
1544	}
1545
1546	impl SseDecode for crate::api::EngineStatus {
1547	// Codec=Sse (Serialization based), see doc to use other codecs
1548	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1549	let mut inner = <i32>::sse_decode(deserializer);
1550	return match inner {
1551	0 => crate::api::EngineStatus::Unloaded,
1552	1 => crate::api::EngineStatus::Loading,
1553	2 => crate::api::EngineStatus::Ready,
1554	3 => crate::api::EngineStatus::Generating,
1555	4 => crate::api::EngineStatus::Error,
1556	_ => unreachable!("Invalid variant for EngineStatus: {}", inner),
1557	};
1558	}
1559	}
1560
1561	impl SseDecode for f32 {
1562	// Codec=Sse (Serialization based), see doc to use other codecs
1563	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1564	deserializer.cursor.read_f32::<NativeEndian>().unwrap()
1565	}
1566	}
1567
1568	impl SseDecode for f64 {
1569	// Codec=Sse (Serialization based), see doc to use other codecs
1570	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1571	deserializer.cursor.read_f64::<NativeEndian>().unwrap()
1572	}
1573	}
1574
1575	impl SseDecode for crate::api::GgufModelConfig {
1576	// Codec=Sse (Serialization based), see doc to use other codecs
1577	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1578	let mut var_modelId = <String>::sse_decode(deserializer);
1579	let mut var_files = <Vec<String>>::sse_decode(deserializer);
1580	let mut var_tokModelId = <Option<String>>::sse_decode(deserializer);
1581	let mut var_displayName = <String>::sse_decode(deserializer);
1582	let mut var_approxMemory = <String>::sse_decode(deserializer);
1583	return crate::api::GgufModelConfig {
1584	model_id: var_modelId,
1585	files: var_files,
1586	tok_model_id: var_tokModelId,
1587	display_name: var_displayName,
1588	approx_memory: var_approxMemory,
1589	};
1590	}
1591	}
1592
1593	impl SseDecode for i32 {
1594	// Codec=Sse (Serialization based), see doc to use other codecs
1595	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1596	deserializer.cursor.read_i32::<NativeEndian>().unwrap()
1597	}
1598	}
1599
1600	impl SseDecode for crate::api::InferenceResult {
1601	// Codec=Sse (Serialization based), see doc to use other codecs
1602	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1603	let mut var_text = <String>::sse_decode(deserializer);
1604	let mut var_durationSecs = <f64>::sse_decode(deserializer);
1605	let mut var_durationDisplay = <String>::sse_decode(deserializer);
1606	let mut var_finishReason = <String>::sse_decode(deserializer);
1607	let mut var_toolCalls = <Vec<crate::api::ToolCallInfo>>::sse_decode(deserializer);
1608	return crate::api::InferenceResult {
1609	text: var_text,
1610	duration_secs: var_durationSecs,
1611	duration_display: var_durationDisplay,
1612	finish_reason: var_finishReason,
1613	tool_calls: var_toolCalls,
1614	};
1615	}
1616	}
1617
1618	impl SseDecode for Vec<String> {
1619	// Codec=Sse (Serialization based), see doc to use other codecs
1620	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1621	let mut len_ = <i32>::sse_decode(deserializer);
1622	let mut ans_ = Vec::with_capacity(len_ as usize);
1623	for idx_ in 0..len_ {
1624	ans_.push(<String>::sse_decode(deserializer));
1625	}
1626	return ans_;
1627	}
1628	}
1629
1630	impl SseDecode for Vec<crate::api::ChatMessage> {
1631	// Codec=Sse (Serialization based), see doc to use other codecs
1632	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1633	let mut len_ = <i32>::sse_decode(deserializer);
1634	let mut ans_ = Vec::with_capacity(len_ as usize);
1635	for idx_ in 0..len_ {
1636	ans_.push(<crate::api::ChatMessage>::sse_decode(deserializer));
1637	}
1638	return ans_;
1639	}
1640	}
1641
1642	impl SseDecode for Vec<u8> {
1643	// Codec=Sse (Serialization based), see doc to use other codecs
1644	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1645	let mut len_ = <i32>::sse_decode(deserializer);
1646	let mut ans_ = Vec::with_capacity(len_ as usize);
1647	for idx_ in 0..len_ {
1648	ans_.push(<u8>::sse_decode(deserializer));
1649	}
1650	return ans_;
1651	}
1652	}
1653
1654	impl SseDecode for Vec<crate::api::ToolCallInfo> {
1655	// Codec=Sse (Serialization based), see doc to use other codecs
1656	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1657	let mut len_ = <i32>::sse_decode(deserializer);
1658	let mut ans_ = Vec::with_capacity(len_ as usize);
1659	for idx_ in 0..len_ {
1660	ans_.push(<crate::api::ToolCallInfo>::sse_decode(deserializer));
1661	}
1662	return ans_;
1663	}
1664	}
1665
1666	impl SseDecode for crate::api::OndeError {
1667	// Codec=Sse (Serialization based), see doc to use other codecs
1668	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1669	let mut tag_ = <i32>::sse_decode(deserializer);
1670	match tag_ {
1671	0 => {
1672	return crate::api::OndeError::NoModelLoaded;
1673	}
1674	1 => {
1675	let mut var_modelName = <String>::sse_decode(deserializer);
1676	return crate::api::OndeError::AlreadyLoaded {
1677	model_name: var_modelName,
1678	};
1679	}
1680	2 => {
1681	let mut var_reason = <String>::sse_decode(deserializer);
1682	return crate::api::OndeError::ModelBuild { reason: var_reason };
1683	}
1684	3 => {
1685	let mut var_reason = <String>::sse_decode(deserializer);
1686	return crate::api::OndeError::Inference { reason: var_reason };
1687	}
1688	4 => {
1689	return crate::api::OndeError::Cancelled;
1690	}
1691	5 => {
1692	let mut var_reason = <String>::sse_decode(deserializer);
1693	return crate::api::OndeError::Other { reason: var_reason };
1694	}
1695	_ => {
1696	unimplemented!("");
1697	}
1698	}
1699	}
1700	}
1701
1702	impl SseDecode for Option<String> {
1703	// Codec=Sse (Serialization based), see doc to use other codecs
1704	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1705	if (<bool>::sse_decode(deserializer)) {
1706	return Some(<String>::sse_decode(deserializer));
1707	} else {
1708	return None;
1709	}
1710	}
1711	}
1712
1713	impl SseDecode for Option<f32> {
1714	// Codec=Sse (Serialization based), see doc to use other codecs
1715	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1716	if (<bool>::sse_decode(deserializer)) {
1717	return Some(<f32>::sse_decode(deserializer));
1718	} else {
1719	return None;
1720	}
1721	}
1722	}
1723
1724	impl SseDecode for Option<f64> {
1725	// Codec=Sse (Serialization based), see doc to use other codecs
1726	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1727	if (<bool>::sse_decode(deserializer)) {
1728	return Some(<f64>::sse_decode(deserializer));
1729	} else {
1730	return None;
1731	}
1732	}
1733	}
1734
1735	impl SseDecode for Option<crate::api::SamplingConfig> {
1736	// Codec=Sse (Serialization based), see doc to use other codecs
1737	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1738	if (<bool>::sse_decode(deserializer)) {
1739	return Some(<crate::api::SamplingConfig>::sse_decode(deserializer));
1740	} else {
1741	return None;
1742	}
1743	}
1744	}
1745
1746	impl SseDecode for Option<u64> {
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	if (<bool>::sse_decode(deserializer)) {
1750	return Some(<u64>::sse_decode(deserializer));
1751	} else {
1752	return None;
1753	}
1754	}
1755	}
1756
1757	impl SseDecode for crate::api::SamplingConfig {
1758	// Codec=Sse (Serialization based), see doc to use other codecs
1759	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1760	let mut var_temperature = <Option<f64>>::sse_decode(deserializer);
1761	let mut var_topP = <Option<f64>>::sse_decode(deserializer);
1762	let mut var_topK = <Option<u64>>::sse_decode(deserializer);
1763	let mut var_minP = <Option<f64>>::sse_decode(deserializer);
1764	let mut var_maxTokens = <Option<u64>>::sse_decode(deserializer);
1765	let mut var_frequencyPenalty = <Option<f32>>::sse_decode(deserializer);
1766	let mut var_presencePenalty = <Option<f32>>::sse_decode(deserializer);
1767	return crate::api::SamplingConfig {
1768	temperature: var_temperature,
1769	top_p: var_topP,
1770	top_k: var_topK,
1771	min_p: var_minP,
1772	max_tokens: var_maxTokens,
1773	frequency_penalty: var_frequencyPenalty,
1774	presence_penalty: var_presencePenalty,
1775	};
1776	}
1777	}
1778
1779	impl SseDecode for crate::api::StreamChunk {
1780	// Codec=Sse (Serialization based), see doc to use other codecs
1781	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1782	let mut var_delta = <String>::sse_decode(deserializer);
1783	let mut var_done = <bool>::sse_decode(deserializer);
1784	let mut var_finishReason = <Option<String>>::sse_decode(deserializer);
1785	return crate::api::StreamChunk {
1786	delta: var_delta,
1787	done: var_done,
1788	finish_reason: var_finishReason,
1789	};
1790	}
1791	}
1792
1793	impl SseDecode for crate::api::ToolCallInfo {
1794	// Codec=Sse (Serialization based), see doc to use other codecs
1795	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1796	let mut var_id = <String>::sse_decode(deserializer);
1797	let mut var_functionName = <String>::sse_decode(deserializer);
1798	let mut var_arguments = <String>::sse_decode(deserializer);
1799	return crate::api::ToolCallInfo {
1800	id: var_id,
1801	function_name: var_functionName,
1802	arguments: var_arguments,
1803	};
1804	}
1805	}
1806
1807	impl SseDecode for u64 {
1808	// Codec=Sse (Serialization based), see doc to use other codecs
1809	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1810	deserializer.cursor.read_u64::<NativeEndian>().unwrap()
1811	}
1812	}
1813
1814	impl SseDecode for u8 {
1815	// Codec=Sse (Serialization based), see doc to use other codecs
1816	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1817	deserializer.cursor.read_u8().unwrap()
1818	}
1819	}
1820
1821	impl SseDecode for () {
1822	// Codec=Sse (Serialization based), see doc to use other codecs
1823	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
1824	}
1825
1826	impl SseDecode for usize {
1827	// Codec=Sse (Serialization based), see doc to use other codecs
1828	fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1829	deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
1830	}
1831	}
1832
1833	fn pde_ffi_dispatcher_primary_impl(
1834	func_id: i32,
1835	port: flutter_rust_bridge::for_generated::MessagePort,
1836	ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1837	rust_vec_len: i32,
1838	data_len: i32,
1839	) {
1840	// Codec=Pde (Serialization + dispatch), see doc to use other codecs
1841	match func_id {
1842	1 => wire__crate__api__OndeChatEngine_clear_history_impl(port, ptr, rust_vec_len, data_len),
1843	2 => wire__crate__api__OndeChatEngine_clear_system_prompt_impl(
1844	port,
1845	ptr,
1846	rust_vec_len,
1847	data_len,
1848	),
1849	3 => wire__crate__api__OndeChatEngine_generate_impl(port, ptr, rust_vec_len, data_len),
1850	4 => wire__crate__api__OndeChatEngine_history_impl(port, ptr, rust_vec_len, data_len),
1851	5 => wire__crate__api__OndeChatEngine_info_impl(port, ptr, rust_vec_len, data_len),
1852	6 => wire__crate__api__OndeChatEngine_is_loaded_impl(port, ptr, rust_vec_len, data_len),
1853	7 => wire__crate__api__OndeChatEngine_load_assigned_model_impl(
1854	port,
1855	ptr,
1856	rust_vec_len,
1857	data_len,
1858	),
1859	8 => {
1860	wire__crate__api__OndeChatEngine_load_gguf_model_impl(port, ptr, rust_vec_len, data_len)
1861	}
1862	10 => wire__crate__api__OndeChatEngine_push_history_impl(port, ptr, rust_vec_len, data_len),
1863	11 => wire__crate__api__OndeChatEngine_send_message_impl(port, ptr, rust_vec_len, data_len),
1864	12 => wire__crate__api__OndeChatEngine_set_sampling_impl(port, ptr, rust_vec_len, data_len),
1865	13 => wire__crate__api__OndeChatEngine_set_system_prompt_impl(
1866	port,
1867	ptr,
1868	rust_vec_len,
1869	data_len,
1870	),
1871	14 => {
1872	wire__crate__api__OndeChatEngine_stream_message_impl(port, ptr, rust_vec_len, data_len)
1873	}
1874	15 => wire__crate__api__OndeChatEngine_unload_model_impl(port, ptr, rust_vec_len, data_len),
1875	_ => unreachable!(),
1876	}
1877	}
1878
1879	fn pde_ffi_dispatcher_sync_impl(
1880	func_id: i32,
1881	ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1882	rust_vec_len: i32,
1883	data_len: i32,
1884	) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1885	// Codec=Pde (Serialization + dispatch), see doc to use other codecs
1886	match func_id {
1887	9 => wire__crate__api__OndeChatEngine_new_impl(ptr, rust_vec_len, data_len),
1888	16 => wire__crate__api__configure_cache_dir_impl(ptr, rust_vec_len, data_len),
1889	17 => wire__crate__api__default_model_config_impl(ptr, rust_vec_len, data_len),
1890	18 => wire__crate__api__default_sampling_config_impl(ptr, rust_vec_len, data_len),
1891	19 => wire__crate__api__deterministic_sampling_config_impl(ptr, rust_vec_len, data_len),
1892	20 => wire__crate__api__mobile_sampling_config_impl(ptr, rust_vec_len, data_len),
1893	21 => wire__crate__api__qwen25_1_5b_config_impl(ptr, rust_vec_len, data_len),
1894	22 => wire__crate__api__qwen25_3b_config_impl(ptr, rust_vec_len, data_len),
1895	23 => wire__crate__api__qwen25_coder_1_5b_config_impl(ptr, rust_vec_len, data_len),
1896	24 => wire__crate__api__qwen25_coder_3b_config_impl(ptr, rust_vec_len, data_len),
1897	25 => wire__crate__api__qwen3_0_6b_config_impl(ptr, rust_vec_len, data_len),
1898	26 => wire__crate__api__qwen3_14b_config_impl(ptr, rust_vec_len, data_len),
1899	27 => wire__crate__api__qwen3_1_7b_config_impl(ptr, rust_vec_len, data_len),
1900	28 => {
1901	wire__crate__api__qwen3_30b_a3b_instruct_2507_config_impl(ptr, rust_vec_len, data_len)
1902	}
1903	29 => wire__crate__api__qwen3_32b_config_impl(ptr, rust_vec_len, data_len),
1904	30 => wire__crate__api__qwen3_4b_config_impl(ptr, rust_vec_len, data_len),
1905	31 => wire__crate__api__qwen3_4b_instruct_2507_config_impl(ptr, rust_vec_len, data_len),
1906	32 => wire__crate__api__qwen3_4b_thinking_2507_config_impl(ptr, rust_vec_len, data_len),
1907	33 => wire__crate__api__qwen3_8b_config_impl(ptr, rust_vec_len, data_len),
1908	_ => unreachable!(),
1909	}
1910	}
1911
1912	// Section: rust2dart
1913
1914	// Codec=Dco (DartCObject based), see doc to use other codecs
1915	impl flutter_rust_bridge::IntoDart for FrbWrapper<OndeChatEngine> {
1916	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1917	flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0)
1918	.into_dart()
1919	}
1920	}
1921	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<OndeChatEngine> {}
1922
1923	impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<OndeChatEngine>> for OndeChatEngine {
1924	fn into_into_dart(self) -> FrbWrapper<OndeChatEngine> {
1925	self.into()
1926	}
1927	}
1928
1929	// Codec=Dco (DartCObject based), see doc to use other codecs
1930	impl flutter_rust_bridge::IntoDart for crate::api::ChatMessage {
1931	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1932	[
1933	self.role.into_into_dart().into_dart(),
1934	self.content.into_into_dart().into_dart(),
1935	]
1936	.into_dart()
1937	}
1938	}
1939	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::ChatMessage {}
1940	impl flutter_rust_bridge::IntoIntoDart<crate::api::ChatMessage> for crate::api::ChatMessage {
1941	fn into_into_dart(self) -> crate::api::ChatMessage {
1942	self
1943	}
1944	}
1945	// Codec=Dco (DartCObject based), see doc to use other codecs
1946	impl flutter_rust_bridge::IntoDart for crate::api::ChatRole {
1947	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1948	match self {
1949	Self::System => 0.into_dart(),
1950	Self::User => 1.into_dart(),
1951	Self::Assistant => 2.into_dart(),
1952	_ => unreachable!(),
1953	}
1954	}
1955	}
1956	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::ChatRole {}
1957	impl flutter_rust_bridge::IntoIntoDart<crate::api::ChatRole> for crate::api::ChatRole {
1958	fn into_into_dart(self) -> crate::api::ChatRole {
1959	self
1960	}
1961	}
1962	// Codec=Dco (DartCObject based), see doc to use other codecs
1963	impl flutter_rust_bridge::IntoDart for crate::api::EngineInfo {
1964	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1965	[
1966	self.status.into_into_dart().into_dart(),
1967	self.model_name.into_into_dart().into_dart(),
1968	self.approx_memory.into_into_dart().into_dart(),
1969	self.history_length.into_into_dart().into_dart(),
1970	]
1971	.into_dart()
1972	}
1973	}
1974	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::EngineInfo {}
1975	impl flutter_rust_bridge::IntoIntoDart<crate::api::EngineInfo> for crate::api::EngineInfo {
1976	fn into_into_dart(self) -> crate::api::EngineInfo {
1977	self
1978	}
1979	}
1980	// Codec=Dco (DartCObject based), see doc to use other codecs
1981	impl flutter_rust_bridge::IntoDart for crate::api::EngineStatus {
1982	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1983	match self {
1984	Self::Unloaded => 0.into_dart(),
1985	Self::Loading => 1.into_dart(),
1986	Self::Ready => 2.into_dart(),
1987	Self::Generating => 3.into_dart(),
1988	Self::Error => 4.into_dart(),
1989	_ => unreachable!(),
1990	}
1991	}
1992	}
1993	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::EngineStatus {}
1994	impl flutter_rust_bridge::IntoIntoDart<crate::api::EngineStatus> for crate::api::EngineStatus {
1995	fn into_into_dart(self) -> crate::api::EngineStatus {
1996	self
1997	}
1998	}
1999	// Codec=Dco (DartCObject based), see doc to use other codecs
2000	impl flutter_rust_bridge::IntoDart for crate::api::GgufModelConfig {
2001	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2002	[
2003	self.model_id.into_into_dart().into_dart(),
2004	self.files.into_into_dart().into_dart(),
2005	self.tok_model_id.into_into_dart().into_dart(),
2006	self.display_name.into_into_dart().into_dart(),
2007	self.approx_memory.into_into_dart().into_dart(),
2008	]
2009	.into_dart()
2010	}
2011	}
2012	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::GgufModelConfig {}
2013	impl flutter_rust_bridge::IntoIntoDart<crate::api::GgufModelConfig>
2014	for crate::api::GgufModelConfig
2015	{
2016	fn into_into_dart(self) -> crate::api::GgufModelConfig {
2017	self
2018	}
2019	}
2020	// Codec=Dco (DartCObject based), see doc to use other codecs
2021	impl flutter_rust_bridge::IntoDart for crate::api::InferenceResult {
2022	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2023	[
2024	self.text.into_into_dart().into_dart(),
2025	self.duration_secs.into_into_dart().into_dart(),
2026	self.duration_display.into_into_dart().into_dart(),
2027	self.finish_reason.into_into_dart().into_dart(),
2028	self.tool_calls.into_into_dart().into_dart(),
2029	]
2030	.into_dart()
2031	}
2032	}
2033	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::InferenceResult {}
2034	impl flutter_rust_bridge::IntoIntoDart<crate::api::InferenceResult>
2035	for crate::api::InferenceResult
2036	{
2037	fn into_into_dart(self) -> crate::api::InferenceResult {
2038	self
2039	}
2040	}
2041	// Codec=Dco (DartCObject based), see doc to use other codecs
2042	impl flutter_rust_bridge::IntoDart for crate::api::OndeError {
2043	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2044	match self {
2045	crate::api::OndeError::NoModelLoaded => [0.into_dart()].into_dart(),
2046	crate::api::OndeError::AlreadyLoaded { model_name } => {
2047	[1.into_dart(), model_name.into_into_dart().into_dart()].into_dart()
2048	}
2049	crate::api::OndeError::ModelBuild { reason } => {
2050	[2.into_dart(), reason.into_into_dart().into_dart()].into_dart()
2051	}
2052	crate::api::OndeError::Inference { reason } => {
2053	[3.into_dart(), reason.into_into_dart().into_dart()].into_dart()
2054	}
2055	crate::api::OndeError::Cancelled => [4.into_dart()].into_dart(),
2056	crate::api::OndeError::Other { reason } => {
2057	[5.into_dart(), reason.into_into_dart().into_dart()].into_dart()
2058	}
2059	_ => {
2060	unimplemented!("");
2061	}
2062	}
2063	}
2064	}
2065	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::OndeError {}
2066	impl flutter_rust_bridge::IntoIntoDart<crate::api::OndeError> for crate::api::OndeError {
2067	fn into_into_dart(self) -> crate::api::OndeError {
2068	self
2069	}
2070	}
2071	// Codec=Dco (DartCObject based), see doc to use other codecs
2072	impl flutter_rust_bridge::IntoDart for crate::api::SamplingConfig {
2073	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2074	[
2075	self.temperature.into_into_dart().into_dart(),
2076	self.top_p.into_into_dart().into_dart(),
2077	self.top_k.into_into_dart().into_dart(),
2078	self.min_p.into_into_dart().into_dart(),
2079	self.max_tokens.into_into_dart().into_dart(),
2080	self.frequency_penalty.into_into_dart().into_dart(),
2081	self.presence_penalty.into_into_dart().into_dart(),
2082	]
2083	.into_dart()
2084	}
2085	}
2086	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::SamplingConfig {}
2087	impl flutter_rust_bridge::IntoIntoDart<crate::api::SamplingConfig> for crate::api::SamplingConfig {
2088	fn into_into_dart(self) -> crate::api::SamplingConfig {
2089	self
2090	}
2091	}
2092	// Codec=Dco (DartCObject based), see doc to use other codecs
2093	impl flutter_rust_bridge::IntoDart for crate::api::StreamChunk {
2094	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2095	[
2096	self.delta.into_into_dart().into_dart(),
2097	self.done.into_into_dart().into_dart(),
2098	self.finish_reason.into_into_dart().into_dart(),
2099	]
2100	.into_dart()
2101	}
2102	}
2103	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::StreamChunk {}
2104	impl flutter_rust_bridge::IntoIntoDart<crate::api::StreamChunk> for crate::api::StreamChunk {
2105	fn into_into_dart(self) -> crate::api::StreamChunk {
2106	self
2107	}
2108	}
2109	// Codec=Dco (DartCObject based), see doc to use other codecs
2110	impl flutter_rust_bridge::IntoDart for crate::api::ToolCallInfo {
2111	fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
2112	[
2113	self.id.into_into_dart().into_dart(),
2114	self.function_name.into_into_dart().into_dart(),
2115	self.arguments.into_into_dart().into_dart(),
2116	]
2117	.into_dart()
2118	}
2119	}
2120	impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::ToolCallInfo {}
2121	impl flutter_rust_bridge::IntoIntoDart<crate::api::ToolCallInfo> for crate::api::ToolCallInfo {
2122	fn into_into_dart(self) -> crate::api::ToolCallInfo {
2123	self
2124	}
2125	}
2126
2127	impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
2128	// Codec=Sse (Serialization based), see doc to use other codecs
2129	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2130	<String>::sse_encode(format!("{:?}", self), serializer);
2131	}
2132	}
2133
2134	impl SseEncode for OndeChatEngine {
2135	// Codec=Sse (Serialization based), see doc to use other codecs
2136	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2137	<RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
2138	}
2139	}
2140
2141	impl SseEncode
2142	for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>
2143	{
2144	// Codec=Sse (Serialization based), see doc to use other codecs
2145	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2146	let (ptr, size) = self.sse_encode_raw();
2147	<usize>::sse_encode(ptr, serializer);
2148	<i32>::sse_encode(size, serializer);
2149	}
2150	}
2151
2152	impl SseEncode
2153	for StreamSink<crate::api::StreamChunk, flutter_rust_bridge::for_generated::SseCodec>
2154	{
2155	// Codec=Sse (Serialization based), see doc to use other codecs
2156	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2157	unimplemented!("")
2158	}
2159	}
2160
2161	impl SseEncode for String {
2162	// Codec=Sse (Serialization based), see doc to use other codecs
2163	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2164	<Vec<u8>>::sse_encode(self.into_bytes(), serializer);
2165	}
2166	}
2167
2168	impl SseEncode for bool {
2169	// Codec=Sse (Serialization based), see doc to use other codecs
2170	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2171	serializer.cursor.write_u8(self as _).unwrap();
2172	}
2173	}
2174
2175	impl SseEncode for crate::api::ChatMessage {
2176	// Codec=Sse (Serialization based), see doc to use other codecs
2177	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2178	<crate::api::ChatRole>::sse_encode(self.role, serializer);
2179	<String>::sse_encode(self.content, serializer);
2180	}
2181	}
2182
2183	impl SseEncode for crate::api::ChatRole {
2184	// Codec=Sse (Serialization based), see doc to use other codecs
2185	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2186	<i32>::sse_encode(
2187	match self {
2188	crate::api::ChatRole::System => 0,
2189	crate::api::ChatRole::User => 1,
2190	crate::api::ChatRole::Assistant => 2,
2191	_ => {
2192	unimplemented!("");
2193	}
2194	},
2195	serializer,
2196	);
2197	}
2198	}
2199
2200	impl SseEncode for crate::api::EngineInfo {
2201	// Codec=Sse (Serialization based), see doc to use other codecs
2202	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2203	<crate::api::EngineStatus>::sse_encode(self.status, serializer);
2204	<Option<String>>::sse_encode(self.model_name, serializer);
2205	<Option<String>>::sse_encode(self.approx_memory, serializer);
2206	<u64>::sse_encode(self.history_length, serializer);
2207	}
2208	}
2209
2210	impl SseEncode for crate::api::EngineStatus {
2211	// Codec=Sse (Serialization based), see doc to use other codecs
2212	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2213	<i32>::sse_encode(
2214	match self {
2215	crate::api::EngineStatus::Unloaded => 0,
2216	crate::api::EngineStatus::Loading => 1,
2217	crate::api::EngineStatus::Ready => 2,
2218	crate::api::EngineStatus::Generating => 3,
2219	crate::api::EngineStatus::Error => 4,
2220	_ => {
2221	unimplemented!("");
2222	}
2223	},
2224	serializer,
2225	);
2226	}
2227	}
2228
2229	impl SseEncode for f32 {
2230	// Codec=Sse (Serialization based), see doc to use other codecs
2231	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2232	serializer.cursor.write_f32::<NativeEndian>(self).unwrap();
2233	}
2234	}
2235
2236	impl SseEncode for f64 {
2237	// Codec=Sse (Serialization based), see doc to use other codecs
2238	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2239	serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
2240	}
2241	}
2242
2243	impl SseEncode for crate::api::GgufModelConfig {
2244	// Codec=Sse (Serialization based), see doc to use other codecs
2245	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2246	<String>::sse_encode(self.model_id, serializer);
2247	<Vec<String>>::sse_encode(self.files, serializer);
2248	<Option<String>>::sse_encode(self.tok_model_id, serializer);
2249	<String>::sse_encode(self.display_name, serializer);
2250	<String>::sse_encode(self.approx_memory, serializer);
2251	}
2252	}
2253
2254	impl SseEncode for i32 {
2255	// Codec=Sse (Serialization based), see doc to use other codecs
2256	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2257	serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
2258	}
2259	}
2260
2261	impl SseEncode for crate::api::InferenceResult {
2262	// Codec=Sse (Serialization based), see doc to use other codecs
2263	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2264	<String>::sse_encode(self.text, serializer);
2265	<f64>::sse_encode(self.duration_secs, serializer);
2266	<String>::sse_encode(self.duration_display, serializer);
2267	<String>::sse_encode(self.finish_reason, serializer);
2268	<Vec<crate::api::ToolCallInfo>>::sse_encode(self.tool_calls, serializer);
2269	}
2270	}
2271
2272	impl SseEncode for Vec<String> {
2273	// Codec=Sse (Serialization based), see doc to use other codecs
2274	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2275	<i32>::sse_encode(self.len() as _, serializer);
2276	for item in self {
2277	<String>::sse_encode(item, serializer);
2278	}
2279	}
2280	}
2281
2282	impl SseEncode for Vec<crate::api::ChatMessage> {
2283	// Codec=Sse (Serialization based), see doc to use other codecs
2284	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2285	<i32>::sse_encode(self.len() as _, serializer);
2286	for item in self {
2287	<crate::api::ChatMessage>::sse_encode(item, serializer);
2288	}
2289	}
2290	}
2291
2292	impl SseEncode for Vec<u8> {
2293	// Codec=Sse (Serialization based), see doc to use other codecs
2294	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2295	<i32>::sse_encode(self.len() as _, serializer);
2296	for item in self {
2297	<u8>::sse_encode(item, serializer);
2298	}
2299	}
2300	}
2301
2302	impl SseEncode for Vec<crate::api::ToolCallInfo> {
2303	// Codec=Sse (Serialization based), see doc to use other codecs
2304	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2305	<i32>::sse_encode(self.len() as _, serializer);
2306	for item in self {
2307	<crate::api::ToolCallInfo>::sse_encode(item, serializer);
2308	}
2309	}
2310	}
2311
2312	impl SseEncode for crate::api::OndeError {
2313	// Codec=Sse (Serialization based), see doc to use other codecs
2314	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2315	match self {
2316	crate::api::OndeError::NoModelLoaded => {
2317	<i32>::sse_encode(0, serializer);
2318	}
2319	crate::api::OndeError::AlreadyLoaded { model_name } => {
2320	<i32>::sse_encode(1, serializer);
2321	<String>::sse_encode(model_name, serializer);
2322	}
2323	crate::api::OndeError::ModelBuild { reason } => {
2324	<i32>::sse_encode(2, serializer);
2325	<String>::sse_encode(reason, serializer);
2326	}
2327	crate::api::OndeError::Inference { reason } => {
2328	<i32>::sse_encode(3, serializer);
2329	<String>::sse_encode(reason, serializer);
2330	}
2331	crate::api::OndeError::Cancelled => {
2332	<i32>::sse_encode(4, serializer);
2333	}
2334	crate::api::OndeError::Other { reason } => {
2335	<i32>::sse_encode(5, serializer);
2336	<String>::sse_encode(reason, serializer);
2337	}
2338	_ => {
2339	unimplemented!("");
2340	}
2341	}
2342	}
2343	}
2344
2345	impl SseEncode for Option<String> {
2346	// Codec=Sse (Serialization based), see doc to use other codecs
2347	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2348	<bool>::sse_encode(self.is_some(), serializer);
2349	if let Some(value) = self {
2350	<String>::sse_encode(value, serializer);
2351	}
2352	}
2353	}
2354
2355	impl SseEncode for Option<f32> {
2356	// Codec=Sse (Serialization based), see doc to use other codecs
2357	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2358	<bool>::sse_encode(self.is_some(), serializer);
2359	if let Some(value) = self {
2360	<f32>::sse_encode(value, serializer);
2361	}
2362	}
2363	}
2364
2365	impl SseEncode for Option<f64> {
2366	// Codec=Sse (Serialization based), see doc to use other codecs
2367	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2368	<bool>::sse_encode(self.is_some(), serializer);
2369	if let Some(value) = self {
2370	<f64>::sse_encode(value, serializer);
2371	}
2372	}
2373	}
2374
2375	impl SseEncode for Option<crate::api::SamplingConfig> {
2376	// Codec=Sse (Serialization based), see doc to use other codecs
2377	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2378	<bool>::sse_encode(self.is_some(), serializer);
2379	if let Some(value) = self {
2380	<crate::api::SamplingConfig>::sse_encode(value, serializer);
2381	}
2382	}
2383	}
2384
2385	impl SseEncode for Option<u64> {
2386	// Codec=Sse (Serialization based), see doc to use other codecs
2387	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2388	<bool>::sse_encode(self.is_some(), serializer);
2389	if let Some(value) = self {
2390	<u64>::sse_encode(value, serializer);
2391	}
2392	}
2393	}
2394
2395	impl SseEncode for crate::api::SamplingConfig {
2396	// Codec=Sse (Serialization based), see doc to use other codecs
2397	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2398	<Option<f64>>::sse_encode(self.temperature, serializer);
2399	<Option<f64>>::sse_encode(self.top_p, serializer);
2400	<Option<u64>>::sse_encode(self.top_k, serializer);
2401	<Option<f64>>::sse_encode(self.min_p, serializer);
2402	<Option<u64>>::sse_encode(self.max_tokens, serializer);
2403	<Option<f32>>::sse_encode(self.frequency_penalty, serializer);
2404	<Option<f32>>::sse_encode(self.presence_penalty, serializer);
2405	}
2406	}
2407
2408	impl SseEncode for crate::api::StreamChunk {
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.delta, serializer);
2412	<bool>::sse_encode(self.done, serializer);
2413	<Option<String>>::sse_encode(self.finish_reason, serializer);
2414	}
2415	}
2416
2417	impl SseEncode for crate::api::ToolCallInfo {
2418	// Codec=Sse (Serialization based), see doc to use other codecs
2419	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2420	<String>::sse_encode(self.id, serializer);
2421	<String>::sse_encode(self.function_name, serializer);
2422	<String>::sse_encode(self.arguments, serializer);
2423	}
2424	}
2425
2426	impl SseEncode for u64 {
2427	// Codec=Sse (Serialization based), see doc to use other codecs
2428	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2429	serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
2430	}
2431	}
2432
2433	impl SseEncode for u8 {
2434	// Codec=Sse (Serialization based), see doc to use other codecs
2435	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2436	serializer.cursor.write_u8(self).unwrap();
2437	}
2438	}
2439
2440	impl SseEncode for () {
2441	// Codec=Sse (Serialization based), see doc to use other codecs
2442	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
2443	}
2444
2445	impl SseEncode for usize {
2446	// Codec=Sse (Serialization based), see doc to use other codecs
2447	fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2448	serializer
2449	.cursor
2450	.write_u64::<NativeEndian>(self as _)
2451	.unwrap();
2452	}
2453	}
2454
2455	#[cfg(not(target_family = "wasm"))]
2456	mod io {
2457	// This file is automatically generated, so please do not edit it.
2458	// @generated by `flutter_rust_bridge`@ 2.12.0.
2459
2460	// Section: imports
2461
2462	use super::*;
2463	use crate::api::*;
2464	use flutter_rust_bridge::for_generated::byteorder::{
2465	NativeEndian, ReadBytesExt, WriteBytesExt,
2466	};
2467	use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
2468	use flutter_rust_bridge::{Handler, IntoIntoDart};
2469
2470	// Section: boilerplate
2471
2472	flutter_rust_bridge::frb_generated_boilerplate_io!();
2473
2474	#[unsafe(no_mangle)]
2475	pub extern "C" fn frbgen_onde_inference_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOndeChatEngine(
2476	ptr: *const std::ffi::c_void,
2477	) {
2478	MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>::increment_strong_count(ptr as _);
2479	}
2480
2481	#[unsafe(no_mangle)]
2482	pub extern "C" fn frbgen_onde_inference_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOndeChatEngine(
2483	ptr: *const std::ffi::c_void,
2484	) {
2485	MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>::decrement_strong_count(ptr as _);
2486	}
2487	}
2488	#[cfg(not(target_family = "wasm"))]
2489	pub use io::*;