1#![forbid(unsafe_code)]
2#![allow(non_camel_case_types, non_snake_case, unused_imports, clippy::all)]
3pub mod daml_prim_DA_Exception_ArithmeticError {
39 pub mod DA_Exception_ArithmeticError {
40 use canton_daml as rt;
41 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
42 #[serde(crate = "rt::serde")]
43 pub struct ArithmeticError {
44 #[serde(rename = "message")]
45 pub message: ::std::string::String,
46 }
47 impl rt::ToValue for ArithmeticError {
48 fn to_value(&self) -> rt::Value {
49 rt::record(::std::vec![(
50 "message",
51 rt::ToValue::to_value(&self.message)
52 ),])
53 }
54 }
55 impl rt::FromValue for ArithmeticError {
56 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
57 ::core::result::Result::Ok(Self {
58 message: rt::FromValue::from_value(rt::required_field(
59 value, 0usize, "message",
60 )?)
61 .map_err(|e| e.at("message"))?,
62 })
63 }
64 }
65 }
66}
67pub mod daml_prim_DA_Exception_AssertionFailed {
68 pub mod DA_Exception_AssertionFailed {
69 use canton_daml as rt;
70 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
71 #[serde(crate = "rt::serde")]
72 pub struct AssertionFailed {
73 #[serde(rename = "message")]
74 pub message: ::std::string::String,
75 }
76 impl rt::ToValue for AssertionFailed {
77 fn to_value(&self) -> rt::Value {
78 rt::record(::std::vec![(
79 "message",
80 rt::ToValue::to_value(&self.message)
81 ),])
82 }
83 }
84 impl rt::FromValue for AssertionFailed {
85 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
86 ::core::result::Result::Ok(Self {
87 message: rt::FromValue::from_value(rt::required_field(
88 value, 0usize, "message",
89 )?)
90 .map_err(|e| e.at("message"))?,
91 })
92 }
93 }
94 }
95}
96pub mod daml_prim_DA_Exception_GeneralError {
97 pub mod DA_Exception_GeneralError {
98 use canton_daml as rt;
99 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
100 #[serde(crate = "rt::serde")]
101 pub struct GeneralError {
102 #[serde(rename = "message")]
103 pub message: ::std::string::String,
104 }
105 impl rt::ToValue for GeneralError {
106 fn to_value(&self) -> rt::Value {
107 rt::record(::std::vec![(
108 "message",
109 rt::ToValue::to_value(&self.message)
110 ),])
111 }
112 }
113 impl rt::FromValue for GeneralError {
114 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
115 ::core::result::Result::Ok(Self {
116 message: rt::FromValue::from_value(rt::required_field(
117 value, 0usize, "message",
118 )?)
119 .map_err(|e| e.at("message"))?,
120 })
121 }
122 }
123 }
124}
125pub mod daml_prim_DA_Exception_PreconditionFailed {
126 pub mod DA_Exception_PreconditionFailed {
127 use canton_daml as rt;
128 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
129 #[serde(crate = "rt::serde")]
130 pub struct PreconditionFailed {
131 #[serde(rename = "message")]
132 pub message: ::std::string::String,
133 }
134 impl rt::ToValue for PreconditionFailed {
135 fn to_value(&self) -> rt::Value {
136 rt::record(::std::vec![(
137 "message",
138 rt::ToValue::to_value(&self.message)
139 ),])
140 }
141 }
142 impl rt::FromValue for PreconditionFailed {
143 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
144 ::core::result::Result::Ok(Self {
145 message: rt::FromValue::from_value(rt::required_field(
146 value, 0usize, "message",
147 )?)
148 .map_err(|e| e.at("message"))?,
149 })
150 }
151 }
152 }
153}
154pub mod daml_prim_DA_Types {
155 pub mod DA_Types {
156 use canton_daml as rt;
157 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
158 #[serde(crate = "rt::serde", tag = "tag", content = "value")]
159 pub enum Either<A, B> {
160 #[serde(rename = "Left")]
161 Left(A),
162 #[serde(rename = "Right")]
163 Right(B),
164 }
165 impl<A, B> rt::ToValue for Either<A, B>
166 where
167 A: rt::ToValue,
168 B: rt::ToValue,
169 {
170 fn to_value(&self) -> rt::Value {
171 match self {
172 Either::Left(inner) => rt::variant_value("Left", rt::ToValue::to_value(inner)),
173 Either::Right(inner) => {
174 rt::variant_value("Right", rt::ToValue::to_value(inner))
175 }
176 }
177 }
178 }
179 impl<A, B> rt::FromValue for Either<A, B>
180 where
181 A: rt::FromValue,
182 B: rt::FromValue,
183 {
184 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
185 let (constructor, payload) = rt::variant_parts(value)?;
186 match constructor {
187 "Left" => ::core::result::Result::Ok(Either::Left(
188 rt::FromValue::from_value(payload).map_err(|e| e.at("Left"))?,
189 )),
190 "Right" => ::core::result::Result::Ok(Either::Right(
191 rt::FromValue::from_value(payload).map_err(|e| e.at("Right"))?,
192 )),
193 other => {
194 ::core::result::Result::Err(rt::unexpected_constructor("Either", other))
195 }
196 }
197 }
198 }
199 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
200 #[serde(crate = "rt::serde")]
201 pub struct Tuple2<T1, T2> {
202 #[serde(rename = "_1")]
203 pub _1: T1,
204 #[serde(rename = "_2")]
205 pub _2: T2,
206 }
207 impl<T1, T2> rt::ToValue for Tuple2<T1, T2>
208 where
209 T1: rt::ToValue,
210 T2: rt::ToValue,
211 {
212 fn to_value(&self) -> rt::Value {
213 rt::record(::std::vec![
214 ("_1", rt::ToValue::to_value(&self._1)),
215 ("_2", rt::ToValue::to_value(&self._2)),
216 ])
217 }
218 }
219 impl<T1, T2> rt::FromValue for Tuple2<T1, T2>
220 where
221 T1: rt::FromValue,
222 T2: rt::FromValue,
223 {
224 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
225 ::core::result::Result::Ok(Self {
226 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
227 .map_err(|e| e.at("_1"))?,
228 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
229 .map_err(|e| e.at("_2"))?,
230 })
231 }
232 }
233 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
234 #[serde(crate = "rt::serde")]
235 pub struct Tuple3<T1, T2, T3> {
236 #[serde(rename = "_1")]
237 pub _1: T1,
238 #[serde(rename = "_2")]
239 pub _2: T2,
240 #[serde(rename = "_3")]
241 pub _3: T3,
242 }
243 impl<T1, T2, T3> rt::ToValue for Tuple3<T1, T2, T3>
244 where
245 T1: rt::ToValue,
246 T2: rt::ToValue,
247 T3: rt::ToValue,
248 {
249 fn to_value(&self) -> rt::Value {
250 rt::record(::std::vec![
251 ("_1", rt::ToValue::to_value(&self._1)),
252 ("_2", rt::ToValue::to_value(&self._2)),
253 ("_3", rt::ToValue::to_value(&self._3)),
254 ])
255 }
256 }
257 impl<T1, T2, T3> rt::FromValue for Tuple3<T1, T2, T3>
258 where
259 T1: rt::FromValue,
260 T2: rt::FromValue,
261 T3: rt::FromValue,
262 {
263 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
264 ::core::result::Result::Ok(Self {
265 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
266 .map_err(|e| e.at("_1"))?,
267 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
268 .map_err(|e| e.at("_2"))?,
269 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
270 .map_err(|e| e.at("_3"))?,
271 })
272 }
273 }
274 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
275 #[serde(crate = "rt::serde")]
276 pub struct Tuple4<T1, T2, T3, T4> {
277 #[serde(rename = "_1")]
278 pub _1: T1,
279 #[serde(rename = "_2")]
280 pub _2: T2,
281 #[serde(rename = "_3")]
282 pub _3: T3,
283 #[serde(rename = "_4")]
284 pub _4: T4,
285 }
286 impl<T1, T2, T3, T4> rt::ToValue for Tuple4<T1, T2, T3, T4>
287 where
288 T1: rt::ToValue,
289 T2: rt::ToValue,
290 T3: rt::ToValue,
291 T4: rt::ToValue,
292 {
293 fn to_value(&self) -> rt::Value {
294 rt::record(::std::vec![
295 ("_1", rt::ToValue::to_value(&self._1)),
296 ("_2", rt::ToValue::to_value(&self._2)),
297 ("_3", rt::ToValue::to_value(&self._3)),
298 ("_4", rt::ToValue::to_value(&self._4)),
299 ])
300 }
301 }
302 impl<T1, T2, T3, T4> rt::FromValue for Tuple4<T1, T2, T3, T4>
303 where
304 T1: rt::FromValue,
305 T2: rt::FromValue,
306 T3: rt::FromValue,
307 T4: rt::FromValue,
308 {
309 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
310 ::core::result::Result::Ok(Self {
311 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
312 .map_err(|e| e.at("_1"))?,
313 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
314 .map_err(|e| e.at("_2"))?,
315 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
316 .map_err(|e| e.at("_3"))?,
317 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
318 .map_err(|e| e.at("_4"))?,
319 })
320 }
321 }
322 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
323 #[serde(crate = "rt::serde")]
324 pub struct Tuple5<T1, T2, T3, T4, T5> {
325 #[serde(rename = "_1")]
326 pub _1: T1,
327 #[serde(rename = "_2")]
328 pub _2: T2,
329 #[serde(rename = "_3")]
330 pub _3: T3,
331 #[serde(rename = "_4")]
332 pub _4: T4,
333 #[serde(rename = "_5")]
334 pub _5: T5,
335 }
336 impl<T1, T2, T3, T4, T5> rt::ToValue for Tuple5<T1, T2, T3, T4, T5>
337 where
338 T1: rt::ToValue,
339 T2: rt::ToValue,
340 T3: rt::ToValue,
341 T4: rt::ToValue,
342 T5: rt::ToValue,
343 {
344 fn to_value(&self) -> rt::Value {
345 rt::record(::std::vec![
346 ("_1", rt::ToValue::to_value(&self._1)),
347 ("_2", rt::ToValue::to_value(&self._2)),
348 ("_3", rt::ToValue::to_value(&self._3)),
349 ("_4", rt::ToValue::to_value(&self._4)),
350 ("_5", rt::ToValue::to_value(&self._5)),
351 ])
352 }
353 }
354 impl<T1, T2, T3, T4, T5> rt::FromValue for Tuple5<T1, T2, T3, T4, T5>
355 where
356 T1: rt::FromValue,
357 T2: rt::FromValue,
358 T3: rt::FromValue,
359 T4: rt::FromValue,
360 T5: rt::FromValue,
361 {
362 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
363 ::core::result::Result::Ok(Self {
364 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
365 .map_err(|e| e.at("_1"))?,
366 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
367 .map_err(|e| e.at("_2"))?,
368 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
369 .map_err(|e| e.at("_3"))?,
370 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
371 .map_err(|e| e.at("_4"))?,
372 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
373 .map_err(|e| e.at("_5"))?,
374 })
375 }
376 }
377 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
378 #[serde(crate = "rt::serde")]
379 pub struct Tuple6<T1, T2, T3, T4, T5, T6> {
380 #[serde(rename = "_1")]
381 pub _1: T1,
382 #[serde(rename = "_2")]
383 pub _2: T2,
384 #[serde(rename = "_3")]
385 pub _3: T3,
386 #[serde(rename = "_4")]
387 pub _4: T4,
388 #[serde(rename = "_5")]
389 pub _5: T5,
390 #[serde(rename = "_6")]
391 pub _6: T6,
392 }
393 impl<T1, T2, T3, T4, T5, T6> rt::ToValue for Tuple6<T1, T2, T3, T4, T5, T6>
394 where
395 T1: rt::ToValue,
396 T2: rt::ToValue,
397 T3: rt::ToValue,
398 T4: rt::ToValue,
399 T5: rt::ToValue,
400 T6: rt::ToValue,
401 {
402 fn to_value(&self) -> rt::Value {
403 rt::record(::std::vec![
404 ("_1", rt::ToValue::to_value(&self._1)),
405 ("_2", rt::ToValue::to_value(&self._2)),
406 ("_3", rt::ToValue::to_value(&self._3)),
407 ("_4", rt::ToValue::to_value(&self._4)),
408 ("_5", rt::ToValue::to_value(&self._5)),
409 ("_6", rt::ToValue::to_value(&self._6)),
410 ])
411 }
412 }
413 impl<T1, T2, T3, T4, T5, T6> rt::FromValue for Tuple6<T1, T2, T3, T4, T5, T6>
414 where
415 T1: rt::FromValue,
416 T2: rt::FromValue,
417 T3: rt::FromValue,
418 T4: rt::FromValue,
419 T5: rt::FromValue,
420 T6: rt::FromValue,
421 {
422 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
423 ::core::result::Result::Ok(Self {
424 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
425 .map_err(|e| e.at("_1"))?,
426 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
427 .map_err(|e| e.at("_2"))?,
428 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
429 .map_err(|e| e.at("_3"))?,
430 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
431 .map_err(|e| e.at("_4"))?,
432 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
433 .map_err(|e| e.at("_5"))?,
434 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
435 .map_err(|e| e.at("_6"))?,
436 })
437 }
438 }
439 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
440 #[serde(crate = "rt::serde")]
441 pub struct Tuple7<T1, T2, T3, T4, T5, T6, T7> {
442 #[serde(rename = "_1")]
443 pub _1: T1,
444 #[serde(rename = "_2")]
445 pub _2: T2,
446 #[serde(rename = "_3")]
447 pub _3: T3,
448 #[serde(rename = "_4")]
449 pub _4: T4,
450 #[serde(rename = "_5")]
451 pub _5: T5,
452 #[serde(rename = "_6")]
453 pub _6: T6,
454 #[serde(rename = "_7")]
455 pub _7: T7,
456 }
457 impl<T1, T2, T3, T4, T5, T6, T7> rt::ToValue for Tuple7<T1, T2, T3, T4, T5, T6, T7>
458 where
459 T1: rt::ToValue,
460 T2: rt::ToValue,
461 T3: rt::ToValue,
462 T4: rt::ToValue,
463 T5: rt::ToValue,
464 T6: rt::ToValue,
465 T7: rt::ToValue,
466 {
467 fn to_value(&self) -> rt::Value {
468 rt::record(::std::vec![
469 ("_1", rt::ToValue::to_value(&self._1)),
470 ("_2", rt::ToValue::to_value(&self._2)),
471 ("_3", rt::ToValue::to_value(&self._3)),
472 ("_4", rt::ToValue::to_value(&self._4)),
473 ("_5", rt::ToValue::to_value(&self._5)),
474 ("_6", rt::ToValue::to_value(&self._6)),
475 ("_7", rt::ToValue::to_value(&self._7)),
476 ])
477 }
478 }
479 impl<T1, T2, T3, T4, T5, T6, T7> rt::FromValue for Tuple7<T1, T2, T3, T4, T5, T6, T7>
480 where
481 T1: rt::FromValue,
482 T2: rt::FromValue,
483 T3: rt::FromValue,
484 T4: rt::FromValue,
485 T5: rt::FromValue,
486 T6: rt::FromValue,
487 T7: rt::FromValue,
488 {
489 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
490 ::core::result::Result::Ok(Self {
491 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
492 .map_err(|e| e.at("_1"))?,
493 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
494 .map_err(|e| e.at("_2"))?,
495 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
496 .map_err(|e| e.at("_3"))?,
497 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
498 .map_err(|e| e.at("_4"))?,
499 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
500 .map_err(|e| e.at("_5"))?,
501 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
502 .map_err(|e| e.at("_6"))?,
503 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
504 .map_err(|e| e.at("_7"))?,
505 })
506 }
507 }
508 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
509 #[serde(crate = "rt::serde")]
510 pub struct Tuple8<T1, T2, T3, T4, T5, T6, T7, T8> {
511 #[serde(rename = "_1")]
512 pub _1: T1,
513 #[serde(rename = "_2")]
514 pub _2: T2,
515 #[serde(rename = "_3")]
516 pub _3: T3,
517 #[serde(rename = "_4")]
518 pub _4: T4,
519 #[serde(rename = "_5")]
520 pub _5: T5,
521 #[serde(rename = "_6")]
522 pub _6: T6,
523 #[serde(rename = "_7")]
524 pub _7: T7,
525 #[serde(rename = "_8")]
526 pub _8: T8,
527 }
528 impl<T1, T2, T3, T4, T5, T6, T7, T8> rt::ToValue for Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>
529 where
530 T1: rt::ToValue,
531 T2: rt::ToValue,
532 T3: rt::ToValue,
533 T4: rt::ToValue,
534 T5: rt::ToValue,
535 T6: rt::ToValue,
536 T7: rt::ToValue,
537 T8: rt::ToValue,
538 {
539 fn to_value(&self) -> rt::Value {
540 rt::record(::std::vec![
541 ("_1", rt::ToValue::to_value(&self._1)),
542 ("_2", rt::ToValue::to_value(&self._2)),
543 ("_3", rt::ToValue::to_value(&self._3)),
544 ("_4", rt::ToValue::to_value(&self._4)),
545 ("_5", rt::ToValue::to_value(&self._5)),
546 ("_6", rt::ToValue::to_value(&self._6)),
547 ("_7", rt::ToValue::to_value(&self._7)),
548 ("_8", rt::ToValue::to_value(&self._8)),
549 ])
550 }
551 }
552 impl<T1, T2, T3, T4, T5, T6, T7, T8> rt::FromValue for Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>
553 where
554 T1: rt::FromValue,
555 T2: rt::FromValue,
556 T3: rt::FromValue,
557 T4: rt::FromValue,
558 T5: rt::FromValue,
559 T6: rt::FromValue,
560 T7: rt::FromValue,
561 T8: rt::FromValue,
562 {
563 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
564 ::core::result::Result::Ok(Self {
565 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
566 .map_err(|e| e.at("_1"))?,
567 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
568 .map_err(|e| e.at("_2"))?,
569 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
570 .map_err(|e| e.at("_3"))?,
571 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
572 .map_err(|e| e.at("_4"))?,
573 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
574 .map_err(|e| e.at("_5"))?,
575 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
576 .map_err(|e| e.at("_6"))?,
577 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
578 .map_err(|e| e.at("_7"))?,
579 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
580 .map_err(|e| e.at("_8"))?,
581 })
582 }
583 }
584 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
585 #[serde(crate = "rt::serde")]
586 pub struct Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9> {
587 #[serde(rename = "_1")]
588 pub _1: T1,
589 #[serde(rename = "_2")]
590 pub _2: T2,
591 #[serde(rename = "_3")]
592 pub _3: T3,
593 #[serde(rename = "_4")]
594 pub _4: T4,
595 #[serde(rename = "_5")]
596 pub _5: T5,
597 #[serde(rename = "_6")]
598 pub _6: T6,
599 #[serde(rename = "_7")]
600 pub _7: T7,
601 #[serde(rename = "_8")]
602 pub _8: T8,
603 #[serde(rename = "_9")]
604 pub _9: T9,
605 }
606 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> rt::ToValue for Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
607 where
608 T1: rt::ToValue,
609 T2: rt::ToValue,
610 T3: rt::ToValue,
611 T4: rt::ToValue,
612 T5: rt::ToValue,
613 T6: rt::ToValue,
614 T7: rt::ToValue,
615 T8: rt::ToValue,
616 T9: rt::ToValue,
617 {
618 fn to_value(&self) -> rt::Value {
619 rt::record(::std::vec![
620 ("_1", rt::ToValue::to_value(&self._1)),
621 ("_2", rt::ToValue::to_value(&self._2)),
622 ("_3", rt::ToValue::to_value(&self._3)),
623 ("_4", rt::ToValue::to_value(&self._4)),
624 ("_5", rt::ToValue::to_value(&self._5)),
625 ("_6", rt::ToValue::to_value(&self._6)),
626 ("_7", rt::ToValue::to_value(&self._7)),
627 ("_8", rt::ToValue::to_value(&self._8)),
628 ("_9", rt::ToValue::to_value(&self._9)),
629 ])
630 }
631 }
632 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> rt::FromValue
633 for Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
634 where
635 T1: rt::FromValue,
636 T2: rt::FromValue,
637 T3: rt::FromValue,
638 T4: rt::FromValue,
639 T5: rt::FromValue,
640 T6: rt::FromValue,
641 T7: rt::FromValue,
642 T8: rt::FromValue,
643 T9: rt::FromValue,
644 {
645 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
646 ::core::result::Result::Ok(Self {
647 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
648 .map_err(|e| e.at("_1"))?,
649 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
650 .map_err(|e| e.at("_2"))?,
651 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
652 .map_err(|e| e.at("_3"))?,
653 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
654 .map_err(|e| e.at("_4"))?,
655 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
656 .map_err(|e| e.at("_5"))?,
657 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
658 .map_err(|e| e.at("_6"))?,
659 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
660 .map_err(|e| e.at("_7"))?,
661 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
662 .map_err(|e| e.at("_8"))?,
663 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
664 .map_err(|e| e.at("_9"))?,
665 })
666 }
667 }
668 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
669 #[serde(crate = "rt::serde")]
670 pub struct Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> {
671 #[serde(rename = "_1")]
672 pub _1: T1,
673 #[serde(rename = "_2")]
674 pub _2: T2,
675 #[serde(rename = "_3")]
676 pub _3: T3,
677 #[serde(rename = "_4")]
678 pub _4: T4,
679 #[serde(rename = "_5")]
680 pub _5: T5,
681 #[serde(rename = "_6")]
682 pub _6: T6,
683 #[serde(rename = "_7")]
684 pub _7: T7,
685 #[serde(rename = "_8")]
686 pub _8: T8,
687 #[serde(rename = "_9")]
688 pub _9: T9,
689 #[serde(rename = "_10")]
690 pub _10: T10,
691 }
692 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> rt::ToValue
693 for Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
694 where
695 T1: rt::ToValue,
696 T2: rt::ToValue,
697 T3: rt::ToValue,
698 T4: rt::ToValue,
699 T5: rt::ToValue,
700 T6: rt::ToValue,
701 T7: rt::ToValue,
702 T8: rt::ToValue,
703 T9: rt::ToValue,
704 T10: rt::ToValue,
705 {
706 fn to_value(&self) -> rt::Value {
707 rt::record(::std::vec![
708 ("_1", rt::ToValue::to_value(&self._1)),
709 ("_2", rt::ToValue::to_value(&self._2)),
710 ("_3", rt::ToValue::to_value(&self._3)),
711 ("_4", rt::ToValue::to_value(&self._4)),
712 ("_5", rt::ToValue::to_value(&self._5)),
713 ("_6", rt::ToValue::to_value(&self._6)),
714 ("_7", rt::ToValue::to_value(&self._7)),
715 ("_8", rt::ToValue::to_value(&self._8)),
716 ("_9", rt::ToValue::to_value(&self._9)),
717 ("_10", rt::ToValue::to_value(&self._10)),
718 ])
719 }
720 }
721 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> rt::FromValue
722 for Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
723 where
724 T1: rt::FromValue,
725 T2: rt::FromValue,
726 T3: rt::FromValue,
727 T4: rt::FromValue,
728 T5: rt::FromValue,
729 T6: rt::FromValue,
730 T7: rt::FromValue,
731 T8: rt::FromValue,
732 T9: rt::FromValue,
733 T10: rt::FromValue,
734 {
735 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
736 ::core::result::Result::Ok(Self {
737 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
738 .map_err(|e| e.at("_1"))?,
739 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
740 .map_err(|e| e.at("_2"))?,
741 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
742 .map_err(|e| e.at("_3"))?,
743 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
744 .map_err(|e| e.at("_4"))?,
745 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
746 .map_err(|e| e.at("_5"))?,
747 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
748 .map_err(|e| e.at("_6"))?,
749 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
750 .map_err(|e| e.at("_7"))?,
751 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
752 .map_err(|e| e.at("_8"))?,
753 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
754 .map_err(|e| e.at("_9"))?,
755 _10: rt::FromValue::from_value(rt::required_field(value, 9usize, "_10")?)
756 .map_err(|e| e.at("_10"))?,
757 })
758 }
759 }
760 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
761 #[serde(crate = "rt::serde")]
762 pub struct Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> {
763 #[serde(rename = "_1")]
764 pub _1: T1,
765 #[serde(rename = "_2")]
766 pub _2: T2,
767 #[serde(rename = "_3")]
768 pub _3: T3,
769 #[serde(rename = "_4")]
770 pub _4: T4,
771 #[serde(rename = "_5")]
772 pub _5: T5,
773 #[serde(rename = "_6")]
774 pub _6: T6,
775 #[serde(rename = "_7")]
776 pub _7: T7,
777 #[serde(rename = "_8")]
778 pub _8: T8,
779 #[serde(rename = "_9")]
780 pub _9: T9,
781 #[serde(rename = "_10")]
782 pub _10: T10,
783 #[serde(rename = "_11")]
784 pub _11: T11,
785 }
786 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> rt::ToValue
787 for Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
788 where
789 T1: rt::ToValue,
790 T2: rt::ToValue,
791 T3: rt::ToValue,
792 T4: rt::ToValue,
793 T5: rt::ToValue,
794 T6: rt::ToValue,
795 T7: rt::ToValue,
796 T8: rt::ToValue,
797 T9: rt::ToValue,
798 T10: rt::ToValue,
799 T11: rt::ToValue,
800 {
801 fn to_value(&self) -> rt::Value {
802 rt::record(::std::vec![
803 ("_1", rt::ToValue::to_value(&self._1)),
804 ("_2", rt::ToValue::to_value(&self._2)),
805 ("_3", rt::ToValue::to_value(&self._3)),
806 ("_4", rt::ToValue::to_value(&self._4)),
807 ("_5", rt::ToValue::to_value(&self._5)),
808 ("_6", rt::ToValue::to_value(&self._6)),
809 ("_7", rt::ToValue::to_value(&self._7)),
810 ("_8", rt::ToValue::to_value(&self._8)),
811 ("_9", rt::ToValue::to_value(&self._9)),
812 ("_10", rt::ToValue::to_value(&self._10)),
813 ("_11", rt::ToValue::to_value(&self._11)),
814 ])
815 }
816 }
817 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> rt::FromValue
818 for Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
819 where
820 T1: rt::FromValue,
821 T2: rt::FromValue,
822 T3: rt::FromValue,
823 T4: rt::FromValue,
824 T5: rt::FromValue,
825 T6: rt::FromValue,
826 T7: rt::FromValue,
827 T8: rt::FromValue,
828 T9: rt::FromValue,
829 T10: rt::FromValue,
830 T11: rt::FromValue,
831 {
832 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
833 ::core::result::Result::Ok(Self {
834 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
835 .map_err(|e| e.at("_1"))?,
836 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
837 .map_err(|e| e.at("_2"))?,
838 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
839 .map_err(|e| e.at("_3"))?,
840 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
841 .map_err(|e| e.at("_4"))?,
842 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
843 .map_err(|e| e.at("_5"))?,
844 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
845 .map_err(|e| e.at("_6"))?,
846 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
847 .map_err(|e| e.at("_7"))?,
848 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
849 .map_err(|e| e.at("_8"))?,
850 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
851 .map_err(|e| e.at("_9"))?,
852 _10: rt::FromValue::from_value(rt::required_field(value, 9usize, "_10")?)
853 .map_err(|e| e.at("_10"))?,
854 _11: rt::FromValue::from_value(rt::required_field(value, 10usize, "_11")?)
855 .map_err(|e| e.at("_11"))?,
856 })
857 }
858 }
859 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
860 #[serde(crate = "rt::serde")]
861 pub struct Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> {
862 #[serde(rename = "_1")]
863 pub _1: T1,
864 #[serde(rename = "_2")]
865 pub _2: T2,
866 #[serde(rename = "_3")]
867 pub _3: T3,
868 #[serde(rename = "_4")]
869 pub _4: T4,
870 #[serde(rename = "_5")]
871 pub _5: T5,
872 #[serde(rename = "_6")]
873 pub _6: T6,
874 #[serde(rename = "_7")]
875 pub _7: T7,
876 #[serde(rename = "_8")]
877 pub _8: T8,
878 #[serde(rename = "_9")]
879 pub _9: T9,
880 #[serde(rename = "_10")]
881 pub _10: T10,
882 #[serde(rename = "_11")]
883 pub _11: T11,
884 #[serde(rename = "_12")]
885 pub _12: T12,
886 }
887 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> rt::ToValue
888 for Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
889 where
890 T1: rt::ToValue,
891 T2: rt::ToValue,
892 T3: rt::ToValue,
893 T4: rt::ToValue,
894 T5: rt::ToValue,
895 T6: rt::ToValue,
896 T7: rt::ToValue,
897 T8: rt::ToValue,
898 T9: rt::ToValue,
899 T10: rt::ToValue,
900 T11: rt::ToValue,
901 T12: rt::ToValue,
902 {
903 fn to_value(&self) -> rt::Value {
904 rt::record(::std::vec![
905 ("_1", rt::ToValue::to_value(&self._1)),
906 ("_2", rt::ToValue::to_value(&self._2)),
907 ("_3", rt::ToValue::to_value(&self._3)),
908 ("_4", rt::ToValue::to_value(&self._4)),
909 ("_5", rt::ToValue::to_value(&self._5)),
910 ("_6", rt::ToValue::to_value(&self._6)),
911 ("_7", rt::ToValue::to_value(&self._7)),
912 ("_8", rt::ToValue::to_value(&self._8)),
913 ("_9", rt::ToValue::to_value(&self._9)),
914 ("_10", rt::ToValue::to_value(&self._10)),
915 ("_11", rt::ToValue::to_value(&self._11)),
916 ("_12", rt::ToValue::to_value(&self._12)),
917 ])
918 }
919 }
920 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> rt::FromValue
921 for Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
922 where
923 T1: rt::FromValue,
924 T2: rt::FromValue,
925 T3: rt::FromValue,
926 T4: rt::FromValue,
927 T5: rt::FromValue,
928 T6: rt::FromValue,
929 T7: rt::FromValue,
930 T8: rt::FromValue,
931 T9: rt::FromValue,
932 T10: rt::FromValue,
933 T11: rt::FromValue,
934 T12: rt::FromValue,
935 {
936 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
937 ::core::result::Result::Ok(Self {
938 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
939 .map_err(|e| e.at("_1"))?,
940 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
941 .map_err(|e| e.at("_2"))?,
942 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
943 .map_err(|e| e.at("_3"))?,
944 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
945 .map_err(|e| e.at("_4"))?,
946 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
947 .map_err(|e| e.at("_5"))?,
948 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
949 .map_err(|e| e.at("_6"))?,
950 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
951 .map_err(|e| e.at("_7"))?,
952 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
953 .map_err(|e| e.at("_8"))?,
954 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
955 .map_err(|e| e.at("_9"))?,
956 _10: rt::FromValue::from_value(rt::required_field(value, 9usize, "_10")?)
957 .map_err(|e| e.at("_10"))?,
958 _11: rt::FromValue::from_value(rt::required_field(value, 10usize, "_11")?)
959 .map_err(|e| e.at("_11"))?,
960 _12: rt::FromValue::from_value(rt::required_field(value, 11usize, "_12")?)
961 .map_err(|e| e.at("_12"))?,
962 })
963 }
964 }
965 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
966 #[serde(crate = "rt::serde")]
967 pub struct Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> {
968 #[serde(rename = "_1")]
969 pub _1: T1,
970 #[serde(rename = "_2")]
971 pub _2: T2,
972 #[serde(rename = "_3")]
973 pub _3: T3,
974 #[serde(rename = "_4")]
975 pub _4: T4,
976 #[serde(rename = "_5")]
977 pub _5: T5,
978 #[serde(rename = "_6")]
979 pub _6: T6,
980 #[serde(rename = "_7")]
981 pub _7: T7,
982 #[serde(rename = "_8")]
983 pub _8: T8,
984 #[serde(rename = "_9")]
985 pub _9: T9,
986 #[serde(rename = "_10")]
987 pub _10: T10,
988 #[serde(rename = "_11")]
989 pub _11: T11,
990 #[serde(rename = "_12")]
991 pub _12: T12,
992 #[serde(rename = "_13")]
993 pub _13: T13,
994 }
995 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> rt::ToValue
996 for Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
997 where
998 T1: rt::ToValue,
999 T2: rt::ToValue,
1000 T3: rt::ToValue,
1001 T4: rt::ToValue,
1002 T5: rt::ToValue,
1003 T6: rt::ToValue,
1004 T7: rt::ToValue,
1005 T8: rt::ToValue,
1006 T9: rt::ToValue,
1007 T10: rt::ToValue,
1008 T11: rt::ToValue,
1009 T12: rt::ToValue,
1010 T13: rt::ToValue,
1011 {
1012 fn to_value(&self) -> rt::Value {
1013 rt::record(::std::vec![
1014 ("_1", rt::ToValue::to_value(&self._1)),
1015 ("_2", rt::ToValue::to_value(&self._2)),
1016 ("_3", rt::ToValue::to_value(&self._3)),
1017 ("_4", rt::ToValue::to_value(&self._4)),
1018 ("_5", rt::ToValue::to_value(&self._5)),
1019 ("_6", rt::ToValue::to_value(&self._6)),
1020 ("_7", rt::ToValue::to_value(&self._7)),
1021 ("_8", rt::ToValue::to_value(&self._8)),
1022 ("_9", rt::ToValue::to_value(&self._9)),
1023 ("_10", rt::ToValue::to_value(&self._10)),
1024 ("_11", rt::ToValue::to_value(&self._11)),
1025 ("_12", rt::ToValue::to_value(&self._12)),
1026 ("_13", rt::ToValue::to_value(&self._13)),
1027 ])
1028 }
1029 }
1030 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> rt::FromValue
1031 for Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
1032 where
1033 T1: rt::FromValue,
1034 T2: rt::FromValue,
1035 T3: rt::FromValue,
1036 T4: rt::FromValue,
1037 T5: rt::FromValue,
1038 T6: rt::FromValue,
1039 T7: rt::FromValue,
1040 T8: rt::FromValue,
1041 T9: rt::FromValue,
1042 T10: rt::FromValue,
1043 T11: rt::FromValue,
1044 T12: rt::FromValue,
1045 T13: rt::FromValue,
1046 {
1047 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
1048 ::core::result::Result::Ok(Self {
1049 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
1050 .map_err(|e| e.at("_1"))?,
1051 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
1052 .map_err(|e| e.at("_2"))?,
1053 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
1054 .map_err(|e| e.at("_3"))?,
1055 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
1056 .map_err(|e| e.at("_4"))?,
1057 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
1058 .map_err(|e| e.at("_5"))?,
1059 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
1060 .map_err(|e| e.at("_6"))?,
1061 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
1062 .map_err(|e| e.at("_7"))?,
1063 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
1064 .map_err(|e| e.at("_8"))?,
1065 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
1066 .map_err(|e| e.at("_9"))?,
1067 _10: rt::FromValue::from_value(rt::required_field(value, 9usize, "_10")?)
1068 .map_err(|e| e.at("_10"))?,
1069 _11: rt::FromValue::from_value(rt::required_field(value, 10usize, "_11")?)
1070 .map_err(|e| e.at("_11"))?,
1071 _12: rt::FromValue::from_value(rt::required_field(value, 11usize, "_12")?)
1072 .map_err(|e| e.at("_12"))?,
1073 _13: rt::FromValue::from_value(rt::required_field(value, 12usize, "_13")?)
1074 .map_err(|e| e.at("_13"))?,
1075 })
1076 }
1077 }
1078 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
1079 #[serde(crate = "rt::serde")]
1080 pub struct Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> {
1081 #[serde(rename = "_1")]
1082 pub _1: T1,
1083 #[serde(rename = "_2")]
1084 pub _2: T2,
1085 #[serde(rename = "_3")]
1086 pub _3: T3,
1087 #[serde(rename = "_4")]
1088 pub _4: T4,
1089 #[serde(rename = "_5")]
1090 pub _5: T5,
1091 #[serde(rename = "_6")]
1092 pub _6: T6,
1093 #[serde(rename = "_7")]
1094 pub _7: T7,
1095 #[serde(rename = "_8")]
1096 pub _8: T8,
1097 #[serde(rename = "_9")]
1098 pub _9: T9,
1099 #[serde(rename = "_10")]
1100 pub _10: T10,
1101 #[serde(rename = "_11")]
1102 pub _11: T11,
1103 #[serde(rename = "_12")]
1104 pub _12: T12,
1105 #[serde(rename = "_13")]
1106 pub _13: T13,
1107 #[serde(rename = "_14")]
1108 pub _14: T14,
1109 }
1110 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> rt::ToValue
1111 for Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
1112 where
1113 T1: rt::ToValue,
1114 T2: rt::ToValue,
1115 T3: rt::ToValue,
1116 T4: rt::ToValue,
1117 T5: rt::ToValue,
1118 T6: rt::ToValue,
1119 T7: rt::ToValue,
1120 T8: rt::ToValue,
1121 T9: rt::ToValue,
1122 T10: rt::ToValue,
1123 T11: rt::ToValue,
1124 T12: rt::ToValue,
1125 T13: rt::ToValue,
1126 T14: rt::ToValue,
1127 {
1128 fn to_value(&self) -> rt::Value {
1129 rt::record(::std::vec![
1130 ("_1", rt::ToValue::to_value(&self._1)),
1131 ("_2", rt::ToValue::to_value(&self._2)),
1132 ("_3", rt::ToValue::to_value(&self._3)),
1133 ("_4", rt::ToValue::to_value(&self._4)),
1134 ("_5", rt::ToValue::to_value(&self._5)),
1135 ("_6", rt::ToValue::to_value(&self._6)),
1136 ("_7", rt::ToValue::to_value(&self._7)),
1137 ("_8", rt::ToValue::to_value(&self._8)),
1138 ("_9", rt::ToValue::to_value(&self._9)),
1139 ("_10", rt::ToValue::to_value(&self._10)),
1140 ("_11", rt::ToValue::to_value(&self._11)),
1141 ("_12", rt::ToValue::to_value(&self._12)),
1142 ("_13", rt::ToValue::to_value(&self._13)),
1143 ("_14", rt::ToValue::to_value(&self._14)),
1144 ])
1145 }
1146 }
1147 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> rt::FromValue
1148 for Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
1149 where
1150 T1: rt::FromValue,
1151 T2: rt::FromValue,
1152 T3: rt::FromValue,
1153 T4: rt::FromValue,
1154 T5: rt::FromValue,
1155 T6: rt::FromValue,
1156 T7: rt::FromValue,
1157 T8: rt::FromValue,
1158 T9: rt::FromValue,
1159 T10: rt::FromValue,
1160 T11: rt::FromValue,
1161 T12: rt::FromValue,
1162 T13: rt::FromValue,
1163 T14: rt::FromValue,
1164 {
1165 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
1166 ::core::result::Result::Ok(Self {
1167 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
1168 .map_err(|e| e.at("_1"))?,
1169 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
1170 .map_err(|e| e.at("_2"))?,
1171 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
1172 .map_err(|e| e.at("_3"))?,
1173 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
1174 .map_err(|e| e.at("_4"))?,
1175 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
1176 .map_err(|e| e.at("_5"))?,
1177 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
1178 .map_err(|e| e.at("_6"))?,
1179 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
1180 .map_err(|e| e.at("_7"))?,
1181 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
1182 .map_err(|e| e.at("_8"))?,
1183 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
1184 .map_err(|e| e.at("_9"))?,
1185 _10: rt::FromValue::from_value(rt::required_field(value, 9usize, "_10")?)
1186 .map_err(|e| e.at("_10"))?,
1187 _11: rt::FromValue::from_value(rt::required_field(value, 10usize, "_11")?)
1188 .map_err(|e| e.at("_11"))?,
1189 _12: rt::FromValue::from_value(rt::required_field(value, 11usize, "_12")?)
1190 .map_err(|e| e.at("_12"))?,
1191 _13: rt::FromValue::from_value(rt::required_field(value, 12usize, "_13")?)
1192 .map_err(|e| e.at("_13"))?,
1193 _14: rt::FromValue::from_value(rt::required_field(value, 13usize, "_14")?)
1194 .map_err(|e| e.at("_14"))?,
1195 })
1196 }
1197 }
1198 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
1199 #[serde(crate = "rt::serde")]
1200 pub struct Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> {
1201 #[serde(rename = "_1")]
1202 pub _1: T1,
1203 #[serde(rename = "_2")]
1204 pub _2: T2,
1205 #[serde(rename = "_3")]
1206 pub _3: T3,
1207 #[serde(rename = "_4")]
1208 pub _4: T4,
1209 #[serde(rename = "_5")]
1210 pub _5: T5,
1211 #[serde(rename = "_6")]
1212 pub _6: T6,
1213 #[serde(rename = "_7")]
1214 pub _7: T7,
1215 #[serde(rename = "_8")]
1216 pub _8: T8,
1217 #[serde(rename = "_9")]
1218 pub _9: T9,
1219 #[serde(rename = "_10")]
1220 pub _10: T10,
1221 #[serde(rename = "_11")]
1222 pub _11: T11,
1223 #[serde(rename = "_12")]
1224 pub _12: T12,
1225 #[serde(rename = "_13")]
1226 pub _13: T13,
1227 #[serde(rename = "_14")]
1228 pub _14: T14,
1229 #[serde(rename = "_15")]
1230 pub _15: T15,
1231 }
1232 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> rt::ToValue
1233 for Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
1234 where
1235 T1: rt::ToValue,
1236 T2: rt::ToValue,
1237 T3: rt::ToValue,
1238 T4: rt::ToValue,
1239 T5: rt::ToValue,
1240 T6: rt::ToValue,
1241 T7: rt::ToValue,
1242 T8: rt::ToValue,
1243 T9: rt::ToValue,
1244 T10: rt::ToValue,
1245 T11: rt::ToValue,
1246 T12: rt::ToValue,
1247 T13: rt::ToValue,
1248 T14: rt::ToValue,
1249 T15: rt::ToValue,
1250 {
1251 fn to_value(&self) -> rt::Value {
1252 rt::record(::std::vec![
1253 ("_1", rt::ToValue::to_value(&self._1)),
1254 ("_2", rt::ToValue::to_value(&self._2)),
1255 ("_3", rt::ToValue::to_value(&self._3)),
1256 ("_4", rt::ToValue::to_value(&self._4)),
1257 ("_5", rt::ToValue::to_value(&self._5)),
1258 ("_6", rt::ToValue::to_value(&self._6)),
1259 ("_7", rt::ToValue::to_value(&self._7)),
1260 ("_8", rt::ToValue::to_value(&self._8)),
1261 ("_9", rt::ToValue::to_value(&self._9)),
1262 ("_10", rt::ToValue::to_value(&self._10)),
1263 ("_11", rt::ToValue::to_value(&self._11)),
1264 ("_12", rt::ToValue::to_value(&self._12)),
1265 ("_13", rt::ToValue::to_value(&self._13)),
1266 ("_14", rt::ToValue::to_value(&self._14)),
1267 ("_15", rt::ToValue::to_value(&self._15)),
1268 ])
1269 }
1270 }
1271 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> rt::FromValue
1272 for Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
1273 where
1274 T1: rt::FromValue,
1275 T2: rt::FromValue,
1276 T3: rt::FromValue,
1277 T4: rt::FromValue,
1278 T5: rt::FromValue,
1279 T6: rt::FromValue,
1280 T7: rt::FromValue,
1281 T8: rt::FromValue,
1282 T9: rt::FromValue,
1283 T10: rt::FromValue,
1284 T11: rt::FromValue,
1285 T12: rt::FromValue,
1286 T13: rt::FromValue,
1287 T14: rt::FromValue,
1288 T15: rt::FromValue,
1289 {
1290 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
1291 ::core::result::Result::Ok(Self {
1292 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
1293 .map_err(|e| e.at("_1"))?,
1294 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
1295 .map_err(|e| e.at("_2"))?,
1296 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
1297 .map_err(|e| e.at("_3"))?,
1298 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
1299 .map_err(|e| e.at("_4"))?,
1300 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
1301 .map_err(|e| e.at("_5"))?,
1302 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
1303 .map_err(|e| e.at("_6"))?,
1304 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
1305 .map_err(|e| e.at("_7"))?,
1306 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
1307 .map_err(|e| e.at("_8"))?,
1308 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
1309 .map_err(|e| e.at("_9"))?,
1310 _10: rt::FromValue::from_value(rt::required_field(value, 9usize, "_10")?)
1311 .map_err(|e| e.at("_10"))?,
1312 _11: rt::FromValue::from_value(rt::required_field(value, 10usize, "_11")?)
1313 .map_err(|e| e.at("_11"))?,
1314 _12: rt::FromValue::from_value(rt::required_field(value, 11usize, "_12")?)
1315 .map_err(|e| e.at("_12"))?,
1316 _13: rt::FromValue::from_value(rt::required_field(value, 12usize, "_13")?)
1317 .map_err(|e| e.at("_13"))?,
1318 _14: rt::FromValue::from_value(rt::required_field(value, 13usize, "_14")?)
1319 .map_err(|e| e.at("_14"))?,
1320 _15: rt::FromValue::from_value(rt::required_field(value, 14usize, "_15")?)
1321 .map_err(|e| e.at("_15"))?,
1322 })
1323 }
1324 }
1325 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
1326 #[serde(crate = "rt::serde")]
1327 pub struct Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> {
1328 #[serde(rename = "_1")]
1329 pub _1: T1,
1330 #[serde(rename = "_2")]
1331 pub _2: T2,
1332 #[serde(rename = "_3")]
1333 pub _3: T3,
1334 #[serde(rename = "_4")]
1335 pub _4: T4,
1336 #[serde(rename = "_5")]
1337 pub _5: T5,
1338 #[serde(rename = "_6")]
1339 pub _6: T6,
1340 #[serde(rename = "_7")]
1341 pub _7: T7,
1342 #[serde(rename = "_8")]
1343 pub _8: T8,
1344 #[serde(rename = "_9")]
1345 pub _9: T9,
1346 #[serde(rename = "_10")]
1347 pub _10: T10,
1348 #[serde(rename = "_11")]
1349 pub _11: T11,
1350 #[serde(rename = "_12")]
1351 pub _12: T12,
1352 #[serde(rename = "_13")]
1353 pub _13: T13,
1354 #[serde(rename = "_14")]
1355 pub _14: T14,
1356 #[serde(rename = "_15")]
1357 pub _15: T15,
1358 #[serde(rename = "_16")]
1359 pub _16: T16,
1360 }
1361 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> rt::ToValue
1362 for Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
1363 where
1364 T1: rt::ToValue,
1365 T2: rt::ToValue,
1366 T3: rt::ToValue,
1367 T4: rt::ToValue,
1368 T5: rt::ToValue,
1369 T6: rt::ToValue,
1370 T7: rt::ToValue,
1371 T8: rt::ToValue,
1372 T9: rt::ToValue,
1373 T10: rt::ToValue,
1374 T11: rt::ToValue,
1375 T12: rt::ToValue,
1376 T13: rt::ToValue,
1377 T14: rt::ToValue,
1378 T15: rt::ToValue,
1379 T16: rt::ToValue,
1380 {
1381 fn to_value(&self) -> rt::Value {
1382 rt::record(::std::vec![
1383 ("_1", rt::ToValue::to_value(&self._1)),
1384 ("_2", rt::ToValue::to_value(&self._2)),
1385 ("_3", rt::ToValue::to_value(&self._3)),
1386 ("_4", rt::ToValue::to_value(&self._4)),
1387 ("_5", rt::ToValue::to_value(&self._5)),
1388 ("_6", rt::ToValue::to_value(&self._6)),
1389 ("_7", rt::ToValue::to_value(&self._7)),
1390 ("_8", rt::ToValue::to_value(&self._8)),
1391 ("_9", rt::ToValue::to_value(&self._9)),
1392 ("_10", rt::ToValue::to_value(&self._10)),
1393 ("_11", rt::ToValue::to_value(&self._11)),
1394 ("_12", rt::ToValue::to_value(&self._12)),
1395 ("_13", rt::ToValue::to_value(&self._13)),
1396 ("_14", rt::ToValue::to_value(&self._14)),
1397 ("_15", rt::ToValue::to_value(&self._15)),
1398 ("_16", rt::ToValue::to_value(&self._16)),
1399 ])
1400 }
1401 }
1402 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> rt::FromValue
1403 for Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
1404 where
1405 T1: rt::FromValue,
1406 T2: rt::FromValue,
1407 T3: rt::FromValue,
1408 T4: rt::FromValue,
1409 T5: rt::FromValue,
1410 T6: rt::FromValue,
1411 T7: rt::FromValue,
1412 T8: rt::FromValue,
1413 T9: rt::FromValue,
1414 T10: rt::FromValue,
1415 T11: rt::FromValue,
1416 T12: rt::FromValue,
1417 T13: rt::FromValue,
1418 T14: rt::FromValue,
1419 T15: rt::FromValue,
1420 T16: rt::FromValue,
1421 {
1422 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
1423 ::core::result::Result::Ok(Self {
1424 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
1425 .map_err(|e| e.at("_1"))?,
1426 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
1427 .map_err(|e| e.at("_2"))?,
1428 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
1429 .map_err(|e| e.at("_3"))?,
1430 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
1431 .map_err(|e| e.at("_4"))?,
1432 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
1433 .map_err(|e| e.at("_5"))?,
1434 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
1435 .map_err(|e| e.at("_6"))?,
1436 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
1437 .map_err(|e| e.at("_7"))?,
1438 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
1439 .map_err(|e| e.at("_8"))?,
1440 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
1441 .map_err(|e| e.at("_9"))?,
1442 _10: rt::FromValue::from_value(rt::required_field(value, 9usize, "_10")?)
1443 .map_err(|e| e.at("_10"))?,
1444 _11: rt::FromValue::from_value(rt::required_field(value, 10usize, "_11")?)
1445 .map_err(|e| e.at("_11"))?,
1446 _12: rt::FromValue::from_value(rt::required_field(value, 11usize, "_12")?)
1447 .map_err(|e| e.at("_12"))?,
1448 _13: rt::FromValue::from_value(rt::required_field(value, 12usize, "_13")?)
1449 .map_err(|e| e.at("_13"))?,
1450 _14: rt::FromValue::from_value(rt::required_field(value, 13usize, "_14")?)
1451 .map_err(|e| e.at("_14"))?,
1452 _15: rt::FromValue::from_value(rt::required_field(value, 14usize, "_15")?)
1453 .map_err(|e| e.at("_15"))?,
1454 _16: rt::FromValue::from_value(rt::required_field(value, 15usize, "_16")?)
1455 .map_err(|e| e.at("_16"))?,
1456 })
1457 }
1458 }
1459 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
1460 #[serde(crate = "rt::serde")]
1461 pub struct Tuple17<
1462 T1,
1463 T2,
1464 T3,
1465 T4,
1466 T5,
1467 T6,
1468 T7,
1469 T8,
1470 T9,
1471 T10,
1472 T11,
1473 T12,
1474 T13,
1475 T14,
1476 T15,
1477 T16,
1478 T17,
1479 > {
1480 #[serde(rename = "_1")]
1481 pub _1: T1,
1482 #[serde(rename = "_2")]
1483 pub _2: T2,
1484 #[serde(rename = "_3")]
1485 pub _3: T3,
1486 #[serde(rename = "_4")]
1487 pub _4: T4,
1488 #[serde(rename = "_5")]
1489 pub _5: T5,
1490 #[serde(rename = "_6")]
1491 pub _6: T6,
1492 #[serde(rename = "_7")]
1493 pub _7: T7,
1494 #[serde(rename = "_8")]
1495 pub _8: T8,
1496 #[serde(rename = "_9")]
1497 pub _9: T9,
1498 #[serde(rename = "_10")]
1499 pub _10: T10,
1500 #[serde(rename = "_11")]
1501 pub _11: T11,
1502 #[serde(rename = "_12")]
1503 pub _12: T12,
1504 #[serde(rename = "_13")]
1505 pub _13: T13,
1506 #[serde(rename = "_14")]
1507 pub _14: T14,
1508 #[serde(rename = "_15")]
1509 pub _15: T15,
1510 #[serde(rename = "_16")]
1511 pub _16: T16,
1512 #[serde(rename = "_17")]
1513 pub _17: T17,
1514 }
1515 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> rt::ToValue
1516 for Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
1517 where
1518 T1: rt::ToValue,
1519 T2: rt::ToValue,
1520 T3: rt::ToValue,
1521 T4: rt::ToValue,
1522 T5: rt::ToValue,
1523 T6: rt::ToValue,
1524 T7: rt::ToValue,
1525 T8: rt::ToValue,
1526 T9: rt::ToValue,
1527 T10: rt::ToValue,
1528 T11: rt::ToValue,
1529 T12: rt::ToValue,
1530 T13: rt::ToValue,
1531 T14: rt::ToValue,
1532 T15: rt::ToValue,
1533 T16: rt::ToValue,
1534 T17: rt::ToValue,
1535 {
1536 fn to_value(&self) -> rt::Value {
1537 rt::record(::std::vec![
1538 ("_1", rt::ToValue::to_value(&self._1)),
1539 ("_2", rt::ToValue::to_value(&self._2)),
1540 ("_3", rt::ToValue::to_value(&self._3)),
1541 ("_4", rt::ToValue::to_value(&self._4)),
1542 ("_5", rt::ToValue::to_value(&self._5)),
1543 ("_6", rt::ToValue::to_value(&self._6)),
1544 ("_7", rt::ToValue::to_value(&self._7)),
1545 ("_8", rt::ToValue::to_value(&self._8)),
1546 ("_9", rt::ToValue::to_value(&self._9)),
1547 ("_10", rt::ToValue::to_value(&self._10)),
1548 ("_11", rt::ToValue::to_value(&self._11)),
1549 ("_12", rt::ToValue::to_value(&self._12)),
1550 ("_13", rt::ToValue::to_value(&self._13)),
1551 ("_14", rt::ToValue::to_value(&self._14)),
1552 ("_15", rt::ToValue::to_value(&self._15)),
1553 ("_16", rt::ToValue::to_value(&self._16)),
1554 ("_17", rt::ToValue::to_value(&self._17)),
1555 ])
1556 }
1557 }
1558 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
1559 rt::FromValue
1560 for Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
1561 where
1562 T1: rt::FromValue,
1563 T2: rt::FromValue,
1564 T3: rt::FromValue,
1565 T4: rt::FromValue,
1566 T5: rt::FromValue,
1567 T6: rt::FromValue,
1568 T7: rt::FromValue,
1569 T8: rt::FromValue,
1570 T9: rt::FromValue,
1571 T10: rt::FromValue,
1572 T11: rt::FromValue,
1573 T12: rt::FromValue,
1574 T13: rt::FromValue,
1575 T14: rt::FromValue,
1576 T15: rt::FromValue,
1577 T16: rt::FromValue,
1578 T17: rt::FromValue,
1579 {
1580 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
1581 ::core::result::Result::Ok(Self {
1582 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
1583 .map_err(|e| e.at("_1"))?,
1584 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
1585 .map_err(|e| e.at("_2"))?,
1586 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
1587 .map_err(|e| e.at("_3"))?,
1588 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
1589 .map_err(|e| e.at("_4"))?,
1590 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
1591 .map_err(|e| e.at("_5"))?,
1592 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
1593 .map_err(|e| e.at("_6"))?,
1594 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
1595 .map_err(|e| e.at("_7"))?,
1596 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
1597 .map_err(|e| e.at("_8"))?,
1598 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
1599 .map_err(|e| e.at("_9"))?,
1600 _10: rt::FromValue::from_value(rt::required_field(value, 9usize, "_10")?)
1601 .map_err(|e| e.at("_10"))?,
1602 _11: rt::FromValue::from_value(rt::required_field(value, 10usize, "_11")?)
1603 .map_err(|e| e.at("_11"))?,
1604 _12: rt::FromValue::from_value(rt::required_field(value, 11usize, "_12")?)
1605 .map_err(|e| e.at("_12"))?,
1606 _13: rt::FromValue::from_value(rt::required_field(value, 12usize, "_13")?)
1607 .map_err(|e| e.at("_13"))?,
1608 _14: rt::FromValue::from_value(rt::required_field(value, 13usize, "_14")?)
1609 .map_err(|e| e.at("_14"))?,
1610 _15: rt::FromValue::from_value(rt::required_field(value, 14usize, "_15")?)
1611 .map_err(|e| e.at("_15"))?,
1612 _16: rt::FromValue::from_value(rt::required_field(value, 15usize, "_16")?)
1613 .map_err(|e| e.at("_16"))?,
1614 _17: rt::FromValue::from_value(rt::required_field(value, 16usize, "_17")?)
1615 .map_err(|e| e.at("_17"))?,
1616 })
1617 }
1618 }
1619 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
1620 #[serde(crate = "rt::serde")]
1621 pub struct Tuple18<
1622 T1,
1623 T2,
1624 T3,
1625 T4,
1626 T5,
1627 T6,
1628 T7,
1629 T8,
1630 T9,
1631 T10,
1632 T11,
1633 T12,
1634 T13,
1635 T14,
1636 T15,
1637 T16,
1638 T17,
1639 T18,
1640 > {
1641 #[serde(rename = "_1")]
1642 pub _1: T1,
1643 #[serde(rename = "_2")]
1644 pub _2: T2,
1645 #[serde(rename = "_3")]
1646 pub _3: T3,
1647 #[serde(rename = "_4")]
1648 pub _4: T4,
1649 #[serde(rename = "_5")]
1650 pub _5: T5,
1651 #[serde(rename = "_6")]
1652 pub _6: T6,
1653 #[serde(rename = "_7")]
1654 pub _7: T7,
1655 #[serde(rename = "_8")]
1656 pub _8: T8,
1657 #[serde(rename = "_9")]
1658 pub _9: T9,
1659 #[serde(rename = "_10")]
1660 pub _10: T10,
1661 #[serde(rename = "_11")]
1662 pub _11: T11,
1663 #[serde(rename = "_12")]
1664 pub _12: T12,
1665 #[serde(rename = "_13")]
1666 pub _13: T13,
1667 #[serde(rename = "_14")]
1668 pub _14: T14,
1669 #[serde(rename = "_15")]
1670 pub _15: T15,
1671 #[serde(rename = "_16")]
1672 pub _16: T16,
1673 #[serde(rename = "_17")]
1674 pub _17: T17,
1675 #[serde(rename = "_18")]
1676 pub _18: T18,
1677 }
1678 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
1679 rt::ToValue
1680 for Tuple18<
1681 T1,
1682 T2,
1683 T3,
1684 T4,
1685 T5,
1686 T6,
1687 T7,
1688 T8,
1689 T9,
1690 T10,
1691 T11,
1692 T12,
1693 T13,
1694 T14,
1695 T15,
1696 T16,
1697 T17,
1698 T18,
1699 >
1700 where
1701 T1: rt::ToValue,
1702 T2: rt::ToValue,
1703 T3: rt::ToValue,
1704 T4: rt::ToValue,
1705 T5: rt::ToValue,
1706 T6: rt::ToValue,
1707 T7: rt::ToValue,
1708 T8: rt::ToValue,
1709 T9: rt::ToValue,
1710 T10: rt::ToValue,
1711 T11: rt::ToValue,
1712 T12: rt::ToValue,
1713 T13: rt::ToValue,
1714 T14: rt::ToValue,
1715 T15: rt::ToValue,
1716 T16: rt::ToValue,
1717 T17: rt::ToValue,
1718 T18: rt::ToValue,
1719 {
1720 fn to_value(&self) -> rt::Value {
1721 rt::record(::std::vec![
1722 ("_1", rt::ToValue::to_value(&self._1)),
1723 ("_2", rt::ToValue::to_value(&self._2)),
1724 ("_3", rt::ToValue::to_value(&self._3)),
1725 ("_4", rt::ToValue::to_value(&self._4)),
1726 ("_5", rt::ToValue::to_value(&self._5)),
1727 ("_6", rt::ToValue::to_value(&self._6)),
1728 ("_7", rt::ToValue::to_value(&self._7)),
1729 ("_8", rt::ToValue::to_value(&self._8)),
1730 ("_9", rt::ToValue::to_value(&self._9)),
1731 ("_10", rt::ToValue::to_value(&self._10)),
1732 ("_11", rt::ToValue::to_value(&self._11)),
1733 ("_12", rt::ToValue::to_value(&self._12)),
1734 ("_13", rt::ToValue::to_value(&self._13)),
1735 ("_14", rt::ToValue::to_value(&self._14)),
1736 ("_15", rt::ToValue::to_value(&self._15)),
1737 ("_16", rt::ToValue::to_value(&self._16)),
1738 ("_17", rt::ToValue::to_value(&self._17)),
1739 ("_18", rt::ToValue::to_value(&self._18)),
1740 ])
1741 }
1742 }
1743 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
1744 rt::FromValue
1745 for Tuple18<
1746 T1,
1747 T2,
1748 T3,
1749 T4,
1750 T5,
1751 T6,
1752 T7,
1753 T8,
1754 T9,
1755 T10,
1756 T11,
1757 T12,
1758 T13,
1759 T14,
1760 T15,
1761 T16,
1762 T17,
1763 T18,
1764 >
1765 where
1766 T1: rt::FromValue,
1767 T2: rt::FromValue,
1768 T3: rt::FromValue,
1769 T4: rt::FromValue,
1770 T5: rt::FromValue,
1771 T6: rt::FromValue,
1772 T7: rt::FromValue,
1773 T8: rt::FromValue,
1774 T9: rt::FromValue,
1775 T10: rt::FromValue,
1776 T11: rt::FromValue,
1777 T12: rt::FromValue,
1778 T13: rt::FromValue,
1779 T14: rt::FromValue,
1780 T15: rt::FromValue,
1781 T16: rt::FromValue,
1782 T17: rt::FromValue,
1783 T18: rt::FromValue,
1784 {
1785 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
1786 ::core::result::Result::Ok(Self {
1787 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
1788 .map_err(|e| e.at("_1"))?,
1789 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
1790 .map_err(|e| e.at("_2"))?,
1791 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
1792 .map_err(|e| e.at("_3"))?,
1793 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
1794 .map_err(|e| e.at("_4"))?,
1795 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
1796 .map_err(|e| e.at("_5"))?,
1797 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
1798 .map_err(|e| e.at("_6"))?,
1799 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
1800 .map_err(|e| e.at("_7"))?,
1801 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
1802 .map_err(|e| e.at("_8"))?,
1803 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
1804 .map_err(|e| e.at("_9"))?,
1805 _10: rt::FromValue::from_value(rt::required_field(value, 9usize, "_10")?)
1806 .map_err(|e| e.at("_10"))?,
1807 _11: rt::FromValue::from_value(rt::required_field(value, 10usize, "_11")?)
1808 .map_err(|e| e.at("_11"))?,
1809 _12: rt::FromValue::from_value(rt::required_field(value, 11usize, "_12")?)
1810 .map_err(|e| e.at("_12"))?,
1811 _13: rt::FromValue::from_value(rt::required_field(value, 12usize, "_13")?)
1812 .map_err(|e| e.at("_13"))?,
1813 _14: rt::FromValue::from_value(rt::required_field(value, 13usize, "_14")?)
1814 .map_err(|e| e.at("_14"))?,
1815 _15: rt::FromValue::from_value(rt::required_field(value, 14usize, "_15")?)
1816 .map_err(|e| e.at("_15"))?,
1817 _16: rt::FromValue::from_value(rt::required_field(value, 15usize, "_16")?)
1818 .map_err(|e| e.at("_16"))?,
1819 _17: rt::FromValue::from_value(rt::required_field(value, 16usize, "_17")?)
1820 .map_err(|e| e.at("_17"))?,
1821 _18: rt::FromValue::from_value(rt::required_field(value, 17usize, "_18")?)
1822 .map_err(|e| e.at("_18"))?,
1823 })
1824 }
1825 }
1826 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
1827 #[serde(crate = "rt::serde")]
1828 pub struct Tuple19<
1829 T1,
1830 T2,
1831 T3,
1832 T4,
1833 T5,
1834 T6,
1835 T7,
1836 T8,
1837 T9,
1838 T10,
1839 T11,
1840 T12,
1841 T13,
1842 T14,
1843 T15,
1844 T16,
1845 T17,
1846 T18,
1847 T19,
1848 > {
1849 #[serde(rename = "_1")]
1850 pub _1: T1,
1851 #[serde(rename = "_2")]
1852 pub _2: T2,
1853 #[serde(rename = "_3")]
1854 pub _3: T3,
1855 #[serde(rename = "_4")]
1856 pub _4: T4,
1857 #[serde(rename = "_5")]
1858 pub _5: T5,
1859 #[serde(rename = "_6")]
1860 pub _6: T6,
1861 #[serde(rename = "_7")]
1862 pub _7: T7,
1863 #[serde(rename = "_8")]
1864 pub _8: T8,
1865 #[serde(rename = "_9")]
1866 pub _9: T9,
1867 #[serde(rename = "_10")]
1868 pub _10: T10,
1869 #[serde(rename = "_11")]
1870 pub _11: T11,
1871 #[serde(rename = "_12")]
1872 pub _12: T12,
1873 #[serde(rename = "_13")]
1874 pub _13: T13,
1875 #[serde(rename = "_14")]
1876 pub _14: T14,
1877 #[serde(rename = "_15")]
1878 pub _15: T15,
1879 #[serde(rename = "_16")]
1880 pub _16: T16,
1881 #[serde(rename = "_17")]
1882 pub _17: T17,
1883 #[serde(rename = "_18")]
1884 pub _18: T18,
1885 #[serde(rename = "_19")]
1886 pub _19: T19,
1887 }
1888 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
1889 rt::ToValue
1890 for Tuple19<
1891 T1,
1892 T2,
1893 T3,
1894 T4,
1895 T5,
1896 T6,
1897 T7,
1898 T8,
1899 T9,
1900 T10,
1901 T11,
1902 T12,
1903 T13,
1904 T14,
1905 T15,
1906 T16,
1907 T17,
1908 T18,
1909 T19,
1910 >
1911 where
1912 T1: rt::ToValue,
1913 T2: rt::ToValue,
1914 T3: rt::ToValue,
1915 T4: rt::ToValue,
1916 T5: rt::ToValue,
1917 T6: rt::ToValue,
1918 T7: rt::ToValue,
1919 T8: rt::ToValue,
1920 T9: rt::ToValue,
1921 T10: rt::ToValue,
1922 T11: rt::ToValue,
1923 T12: rt::ToValue,
1924 T13: rt::ToValue,
1925 T14: rt::ToValue,
1926 T15: rt::ToValue,
1927 T16: rt::ToValue,
1928 T17: rt::ToValue,
1929 T18: rt::ToValue,
1930 T19: rt::ToValue,
1931 {
1932 fn to_value(&self) -> rt::Value {
1933 rt::record(::std::vec![
1934 ("_1", rt::ToValue::to_value(&self._1)),
1935 ("_2", rt::ToValue::to_value(&self._2)),
1936 ("_3", rt::ToValue::to_value(&self._3)),
1937 ("_4", rt::ToValue::to_value(&self._4)),
1938 ("_5", rt::ToValue::to_value(&self._5)),
1939 ("_6", rt::ToValue::to_value(&self._6)),
1940 ("_7", rt::ToValue::to_value(&self._7)),
1941 ("_8", rt::ToValue::to_value(&self._8)),
1942 ("_9", rt::ToValue::to_value(&self._9)),
1943 ("_10", rt::ToValue::to_value(&self._10)),
1944 ("_11", rt::ToValue::to_value(&self._11)),
1945 ("_12", rt::ToValue::to_value(&self._12)),
1946 ("_13", rt::ToValue::to_value(&self._13)),
1947 ("_14", rt::ToValue::to_value(&self._14)),
1948 ("_15", rt::ToValue::to_value(&self._15)),
1949 ("_16", rt::ToValue::to_value(&self._16)),
1950 ("_17", rt::ToValue::to_value(&self._17)),
1951 ("_18", rt::ToValue::to_value(&self._18)),
1952 ("_19", rt::ToValue::to_value(&self._19)),
1953 ])
1954 }
1955 }
1956 impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
1957 rt::FromValue
1958 for Tuple19<
1959 T1,
1960 T2,
1961 T3,
1962 T4,
1963 T5,
1964 T6,
1965 T7,
1966 T8,
1967 T9,
1968 T10,
1969 T11,
1970 T12,
1971 T13,
1972 T14,
1973 T15,
1974 T16,
1975 T17,
1976 T18,
1977 T19,
1978 >
1979 where
1980 T1: rt::FromValue,
1981 T2: rt::FromValue,
1982 T3: rt::FromValue,
1983 T4: rt::FromValue,
1984 T5: rt::FromValue,
1985 T6: rt::FromValue,
1986 T7: rt::FromValue,
1987 T8: rt::FromValue,
1988 T9: rt::FromValue,
1989 T10: rt::FromValue,
1990 T11: rt::FromValue,
1991 T12: rt::FromValue,
1992 T13: rt::FromValue,
1993 T14: rt::FromValue,
1994 T15: rt::FromValue,
1995 T16: rt::FromValue,
1996 T17: rt::FromValue,
1997 T18: rt::FromValue,
1998 T19: rt::FromValue,
1999 {
2000 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2001 ::core::result::Result::Ok(Self {
2002 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
2003 .map_err(|e| e.at("_1"))?,
2004 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
2005 .map_err(|e| e.at("_2"))?,
2006 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
2007 .map_err(|e| e.at("_3"))?,
2008 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
2009 .map_err(|e| e.at("_4"))?,
2010 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
2011 .map_err(|e| e.at("_5"))?,
2012 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
2013 .map_err(|e| e.at("_6"))?,
2014 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
2015 .map_err(|e| e.at("_7"))?,
2016 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
2017 .map_err(|e| e.at("_8"))?,
2018 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
2019 .map_err(|e| e.at("_9"))?,
2020 _10: rt::FromValue::from_value(rt::required_field(value, 9usize, "_10")?)
2021 .map_err(|e| e.at("_10"))?,
2022 _11: rt::FromValue::from_value(rt::required_field(value, 10usize, "_11")?)
2023 .map_err(|e| e.at("_11"))?,
2024 _12: rt::FromValue::from_value(rt::required_field(value, 11usize, "_12")?)
2025 .map_err(|e| e.at("_12"))?,
2026 _13: rt::FromValue::from_value(rt::required_field(value, 12usize, "_13")?)
2027 .map_err(|e| e.at("_13"))?,
2028 _14: rt::FromValue::from_value(rt::required_field(value, 13usize, "_14")?)
2029 .map_err(|e| e.at("_14"))?,
2030 _15: rt::FromValue::from_value(rt::required_field(value, 14usize, "_15")?)
2031 .map_err(|e| e.at("_15"))?,
2032 _16: rt::FromValue::from_value(rt::required_field(value, 15usize, "_16")?)
2033 .map_err(|e| e.at("_16"))?,
2034 _17: rt::FromValue::from_value(rt::required_field(value, 16usize, "_17")?)
2035 .map_err(|e| e.at("_17"))?,
2036 _18: rt::FromValue::from_value(rt::required_field(value, 17usize, "_18")?)
2037 .map_err(|e| e.at("_18"))?,
2038 _19: rt::FromValue::from_value(rt::required_field(value, 18usize, "_19")?)
2039 .map_err(|e| e.at("_19"))?,
2040 })
2041 }
2042 }
2043 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2044 #[serde(crate = "rt::serde")]
2045 pub struct Tuple20<
2046 T1,
2047 T2,
2048 T3,
2049 T4,
2050 T5,
2051 T6,
2052 T7,
2053 T8,
2054 T9,
2055 T10,
2056 T11,
2057 T12,
2058 T13,
2059 T14,
2060 T15,
2061 T16,
2062 T17,
2063 T18,
2064 T19,
2065 T20,
2066 > {
2067 #[serde(rename = "_1")]
2068 pub _1: T1,
2069 #[serde(rename = "_2")]
2070 pub _2: T2,
2071 #[serde(rename = "_3")]
2072 pub _3: T3,
2073 #[serde(rename = "_4")]
2074 pub _4: T4,
2075 #[serde(rename = "_5")]
2076 pub _5: T5,
2077 #[serde(rename = "_6")]
2078 pub _6: T6,
2079 #[serde(rename = "_7")]
2080 pub _7: T7,
2081 #[serde(rename = "_8")]
2082 pub _8: T8,
2083 #[serde(rename = "_9")]
2084 pub _9: T9,
2085 #[serde(rename = "_10")]
2086 pub _10: T10,
2087 #[serde(rename = "_11")]
2088 pub _11: T11,
2089 #[serde(rename = "_12")]
2090 pub _12: T12,
2091 #[serde(rename = "_13")]
2092 pub _13: T13,
2093 #[serde(rename = "_14")]
2094 pub _14: T14,
2095 #[serde(rename = "_15")]
2096 pub _15: T15,
2097 #[serde(rename = "_16")]
2098 pub _16: T16,
2099 #[serde(rename = "_17")]
2100 pub _17: T17,
2101 #[serde(rename = "_18")]
2102 pub _18: T18,
2103 #[serde(rename = "_19")]
2104 pub _19: T19,
2105 #[serde(rename = "_20")]
2106 pub _20: T20,
2107 }
2108 impl<
2109 T1,
2110 T2,
2111 T3,
2112 T4,
2113 T5,
2114 T6,
2115 T7,
2116 T8,
2117 T9,
2118 T10,
2119 T11,
2120 T12,
2121 T13,
2122 T14,
2123 T15,
2124 T16,
2125 T17,
2126 T18,
2127 T19,
2128 T20,
2129 > rt::ToValue
2130 for Tuple20<
2131 T1,
2132 T2,
2133 T3,
2134 T4,
2135 T5,
2136 T6,
2137 T7,
2138 T8,
2139 T9,
2140 T10,
2141 T11,
2142 T12,
2143 T13,
2144 T14,
2145 T15,
2146 T16,
2147 T17,
2148 T18,
2149 T19,
2150 T20,
2151 >
2152 where
2153 T1: rt::ToValue,
2154 T2: rt::ToValue,
2155 T3: rt::ToValue,
2156 T4: rt::ToValue,
2157 T5: rt::ToValue,
2158 T6: rt::ToValue,
2159 T7: rt::ToValue,
2160 T8: rt::ToValue,
2161 T9: rt::ToValue,
2162 T10: rt::ToValue,
2163 T11: rt::ToValue,
2164 T12: rt::ToValue,
2165 T13: rt::ToValue,
2166 T14: rt::ToValue,
2167 T15: rt::ToValue,
2168 T16: rt::ToValue,
2169 T17: rt::ToValue,
2170 T18: rt::ToValue,
2171 T19: rt::ToValue,
2172 T20: rt::ToValue,
2173 {
2174 fn to_value(&self) -> rt::Value {
2175 rt::record(::std::vec![
2176 ("_1", rt::ToValue::to_value(&self._1)),
2177 ("_2", rt::ToValue::to_value(&self._2)),
2178 ("_3", rt::ToValue::to_value(&self._3)),
2179 ("_4", rt::ToValue::to_value(&self._4)),
2180 ("_5", rt::ToValue::to_value(&self._5)),
2181 ("_6", rt::ToValue::to_value(&self._6)),
2182 ("_7", rt::ToValue::to_value(&self._7)),
2183 ("_8", rt::ToValue::to_value(&self._8)),
2184 ("_9", rt::ToValue::to_value(&self._9)),
2185 ("_10", rt::ToValue::to_value(&self._10)),
2186 ("_11", rt::ToValue::to_value(&self._11)),
2187 ("_12", rt::ToValue::to_value(&self._12)),
2188 ("_13", rt::ToValue::to_value(&self._13)),
2189 ("_14", rt::ToValue::to_value(&self._14)),
2190 ("_15", rt::ToValue::to_value(&self._15)),
2191 ("_16", rt::ToValue::to_value(&self._16)),
2192 ("_17", rt::ToValue::to_value(&self._17)),
2193 ("_18", rt::ToValue::to_value(&self._18)),
2194 ("_19", rt::ToValue::to_value(&self._19)),
2195 ("_20", rt::ToValue::to_value(&self._20)),
2196 ])
2197 }
2198 }
2199 impl<
2200 T1,
2201 T2,
2202 T3,
2203 T4,
2204 T5,
2205 T6,
2206 T7,
2207 T8,
2208 T9,
2209 T10,
2210 T11,
2211 T12,
2212 T13,
2213 T14,
2214 T15,
2215 T16,
2216 T17,
2217 T18,
2218 T19,
2219 T20,
2220 > rt::FromValue
2221 for Tuple20<
2222 T1,
2223 T2,
2224 T3,
2225 T4,
2226 T5,
2227 T6,
2228 T7,
2229 T8,
2230 T9,
2231 T10,
2232 T11,
2233 T12,
2234 T13,
2235 T14,
2236 T15,
2237 T16,
2238 T17,
2239 T18,
2240 T19,
2241 T20,
2242 >
2243 where
2244 T1: rt::FromValue,
2245 T2: rt::FromValue,
2246 T3: rt::FromValue,
2247 T4: rt::FromValue,
2248 T5: rt::FromValue,
2249 T6: rt::FromValue,
2250 T7: rt::FromValue,
2251 T8: rt::FromValue,
2252 T9: rt::FromValue,
2253 T10: rt::FromValue,
2254 T11: rt::FromValue,
2255 T12: rt::FromValue,
2256 T13: rt::FromValue,
2257 T14: rt::FromValue,
2258 T15: rt::FromValue,
2259 T16: rt::FromValue,
2260 T17: rt::FromValue,
2261 T18: rt::FromValue,
2262 T19: rt::FromValue,
2263 T20: rt::FromValue,
2264 {
2265 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2266 ::core::result::Result::Ok(Self {
2267 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
2268 .map_err(|e| e.at("_1"))?,
2269 _2: rt::FromValue::from_value(rt::required_field(value, 1usize, "_2")?)
2270 .map_err(|e| e.at("_2"))?,
2271 _3: rt::FromValue::from_value(rt::required_field(value, 2usize, "_3")?)
2272 .map_err(|e| e.at("_3"))?,
2273 _4: rt::FromValue::from_value(rt::required_field(value, 3usize, "_4")?)
2274 .map_err(|e| e.at("_4"))?,
2275 _5: rt::FromValue::from_value(rt::required_field(value, 4usize, "_5")?)
2276 .map_err(|e| e.at("_5"))?,
2277 _6: rt::FromValue::from_value(rt::required_field(value, 5usize, "_6")?)
2278 .map_err(|e| e.at("_6"))?,
2279 _7: rt::FromValue::from_value(rt::required_field(value, 6usize, "_7")?)
2280 .map_err(|e| e.at("_7"))?,
2281 _8: rt::FromValue::from_value(rt::required_field(value, 7usize, "_8")?)
2282 .map_err(|e| e.at("_8"))?,
2283 _9: rt::FromValue::from_value(rt::required_field(value, 8usize, "_9")?)
2284 .map_err(|e| e.at("_9"))?,
2285 _10: rt::FromValue::from_value(rt::required_field(value, 9usize, "_10")?)
2286 .map_err(|e| e.at("_10"))?,
2287 _11: rt::FromValue::from_value(rt::required_field(value, 10usize, "_11")?)
2288 .map_err(|e| e.at("_11"))?,
2289 _12: rt::FromValue::from_value(rt::required_field(value, 11usize, "_12")?)
2290 .map_err(|e| e.at("_12"))?,
2291 _13: rt::FromValue::from_value(rt::required_field(value, 12usize, "_13")?)
2292 .map_err(|e| e.at("_13"))?,
2293 _14: rt::FromValue::from_value(rt::required_field(value, 13usize, "_14")?)
2294 .map_err(|e| e.at("_14"))?,
2295 _15: rt::FromValue::from_value(rt::required_field(value, 14usize, "_15")?)
2296 .map_err(|e| e.at("_15"))?,
2297 _16: rt::FromValue::from_value(rt::required_field(value, 15usize, "_16")?)
2298 .map_err(|e| e.at("_16"))?,
2299 _17: rt::FromValue::from_value(rt::required_field(value, 16usize, "_17")?)
2300 .map_err(|e| e.at("_17"))?,
2301 _18: rt::FromValue::from_value(rt::required_field(value, 17usize, "_18")?)
2302 .map_err(|e| e.at("_18"))?,
2303 _19: rt::FromValue::from_value(rt::required_field(value, 18usize, "_19")?)
2304 .map_err(|e| e.at("_19"))?,
2305 _20: rt::FromValue::from_value(rt::required_field(value, 19usize, "_20")?)
2306 .map_err(|e| e.at("_20"))?,
2307 })
2308 }
2309 }
2310 }
2311}
2312pub mod daml_prim_GHC_Tuple {
2313 pub mod GHC_Tuple {
2314 use canton_daml as rt;
2315 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2316 #[serde(crate = "rt::serde")]
2317 pub struct Unit<A> {
2318 #[serde(rename = "_1")]
2319 pub _1: A,
2320 }
2321 impl<A> rt::ToValue for Unit<A>
2322 where
2323 A: rt::ToValue,
2324 {
2325 fn to_value(&self) -> rt::Value {
2326 rt::record(::std::vec![("_1", rt::ToValue::to_value(&self._1)),])
2327 }
2328 }
2329 impl<A> rt::FromValue for Unit<A>
2330 where
2331 A: rt::FromValue,
2332 {
2333 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2334 ::core::result::Result::Ok(Self {
2335 _1: rt::FromValue::from_value(rt::required_field(value, 0usize, "_1")?)
2336 .map_err(|e| e.at("_1"))?,
2337 })
2338 }
2339 }
2340 }
2341}
2342pub mod daml_prim_GHC_Types {
2343 pub mod GHC_Types {
2344 use canton_daml as rt;
2345 #[derive(
2346 Clone, Copy, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize,
2347 )]
2348 #[serde(crate = "rt::serde")]
2349 pub enum Ordering {
2350 #[serde(rename = "LT")]
2351 LT,
2352 #[serde(rename = "EQ")]
2353 EQ,
2354 #[serde(rename = "GT")]
2355 GT,
2356 }
2357 impl rt::ToValue for Ordering {
2358 fn to_value(&self) -> rt::Value {
2359 rt::enum_value(match self {
2360 Ordering::LT => "LT",
2361 Ordering::EQ => "EQ",
2362 Ordering::GT => "GT",
2363 })
2364 }
2365 }
2366 impl rt::FromValue for Ordering {
2367 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2368 match rt::enum_constructor(value)? {
2369 "LT" => ::core::result::Result::Ok(Ordering::LT),
2370 "EQ" => ::core::result::Result::Ok(Ordering::EQ),
2371 "GT" => ::core::result::Result::Ok(Ordering::GT),
2372 other => {
2373 ::core::result::Result::Err(rt::unexpected_constructor("Ordering", other))
2374 }
2375 }
2376 }
2377 }
2378 }
2379}
2380pub mod daml_stdlib_DA_Date_Types {
2381 pub mod DA_Date_Types {
2382 use canton_daml as rt;
2383 #[derive(
2384 Clone, Copy, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize,
2385 )]
2386 #[serde(crate = "rt::serde")]
2387 pub enum DayOfWeek {
2388 #[serde(rename = "Monday")]
2389 Monday,
2390 #[serde(rename = "Tuesday")]
2391 Tuesday,
2392 #[serde(rename = "Wednesday")]
2393 Wednesday,
2394 #[serde(rename = "Thursday")]
2395 Thursday,
2396 #[serde(rename = "Friday")]
2397 Friday,
2398 #[serde(rename = "Saturday")]
2399 Saturday,
2400 #[serde(rename = "Sunday")]
2401 Sunday,
2402 }
2403 impl rt::ToValue for DayOfWeek {
2404 fn to_value(&self) -> rt::Value {
2405 rt::enum_value(match self {
2406 DayOfWeek::Monday => "Monday",
2407 DayOfWeek::Tuesday => "Tuesday",
2408 DayOfWeek::Wednesday => "Wednesday",
2409 DayOfWeek::Thursday => "Thursday",
2410 DayOfWeek::Friday => "Friday",
2411 DayOfWeek::Saturday => "Saturday",
2412 DayOfWeek::Sunday => "Sunday",
2413 })
2414 }
2415 }
2416 impl rt::FromValue for DayOfWeek {
2417 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2418 match rt::enum_constructor(value)? {
2419 "Monday" => ::core::result::Result::Ok(DayOfWeek::Monday),
2420 "Tuesday" => ::core::result::Result::Ok(DayOfWeek::Tuesday),
2421 "Wednesday" => ::core::result::Result::Ok(DayOfWeek::Wednesday),
2422 "Thursday" => ::core::result::Result::Ok(DayOfWeek::Thursday),
2423 "Friday" => ::core::result::Result::Ok(DayOfWeek::Friday),
2424 "Saturday" => ::core::result::Result::Ok(DayOfWeek::Saturday),
2425 "Sunday" => ::core::result::Result::Ok(DayOfWeek::Sunday),
2426 other => {
2427 ::core::result::Result::Err(rt::unexpected_constructor("DayOfWeek", other))
2428 }
2429 }
2430 }
2431 }
2432 #[derive(
2433 Clone, Copy, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize,
2434 )]
2435 #[serde(crate = "rt::serde")]
2436 pub enum Month {
2437 #[serde(rename = "Jan")]
2438 Jan,
2439 #[serde(rename = "Feb")]
2440 Feb,
2441 #[serde(rename = "Mar")]
2442 Mar,
2443 #[serde(rename = "Apr")]
2444 Apr,
2445 #[serde(rename = "May")]
2446 May,
2447 #[serde(rename = "Jun")]
2448 Jun,
2449 #[serde(rename = "Jul")]
2450 Jul,
2451 #[serde(rename = "Aug")]
2452 Aug,
2453 #[serde(rename = "Sep")]
2454 Sep,
2455 #[serde(rename = "Oct")]
2456 Oct,
2457 #[serde(rename = "Nov")]
2458 Nov,
2459 #[serde(rename = "Dec")]
2460 Dec,
2461 }
2462 impl rt::ToValue for Month {
2463 fn to_value(&self) -> rt::Value {
2464 rt::enum_value(match self {
2465 Month::Jan => "Jan",
2466 Month::Feb => "Feb",
2467 Month::Mar => "Mar",
2468 Month::Apr => "Apr",
2469 Month::May => "May",
2470 Month::Jun => "Jun",
2471 Month::Jul => "Jul",
2472 Month::Aug => "Aug",
2473 Month::Sep => "Sep",
2474 Month::Oct => "Oct",
2475 Month::Nov => "Nov",
2476 Month::Dec => "Dec",
2477 })
2478 }
2479 }
2480 impl rt::FromValue for Month {
2481 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2482 match rt::enum_constructor(value)? {
2483 "Jan" => ::core::result::Result::Ok(Month::Jan),
2484 "Feb" => ::core::result::Result::Ok(Month::Feb),
2485 "Mar" => ::core::result::Result::Ok(Month::Mar),
2486 "Apr" => ::core::result::Result::Ok(Month::Apr),
2487 "May" => ::core::result::Result::Ok(Month::May),
2488 "Jun" => ::core::result::Result::Ok(Month::Jun),
2489 "Jul" => ::core::result::Result::Ok(Month::Jul),
2490 "Aug" => ::core::result::Result::Ok(Month::Aug),
2491 "Sep" => ::core::result::Result::Ok(Month::Sep),
2492 "Oct" => ::core::result::Result::Ok(Month::Oct),
2493 "Nov" => ::core::result::Result::Ok(Month::Nov),
2494 "Dec" => ::core::result::Result::Ok(Month::Dec),
2495 other => {
2496 ::core::result::Result::Err(rt::unexpected_constructor("Month", other))
2497 }
2498 }
2499 }
2500 }
2501 }
2502}
2503pub mod daml_stdlib_DA_Internal_Down {
2504 pub mod DA_Internal_Down {
2505 use canton_daml as rt;
2506 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2507 #[serde(crate = "rt::serde")]
2508 pub struct Down<A> {
2509 #[serde(rename = "unpack")]
2510 pub unpack: A,
2511 }
2512 impl<A> rt::ToValue for Down<A>
2513 where
2514 A: rt::ToValue,
2515 {
2516 fn to_value(&self) -> rt::Value {
2517 rt::record(::std::vec![("unpack", rt::ToValue::to_value(&self.unpack)),])
2518 }
2519 }
2520 impl<A> rt::FromValue for Down<A>
2521 where
2522 A: rt::FromValue,
2523 {
2524 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2525 ::core::result::Result::Ok(Self {
2526 unpack: rt::FromValue::from_value(rt::required_field(value, 0usize, "unpack")?)
2527 .map_err(|e| e.at("unpack"))?,
2528 })
2529 }
2530 }
2531 }
2532}
2533pub mod ghc_stdlib_DA_Internal_Template {
2534 pub mod DA_Internal_Template {
2535 use canton_daml as rt;
2536 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2537 #[serde(crate = "rt::serde")]
2538 pub struct Archive {}
2539 impl rt::ToValue for Archive {
2540 fn to_value(&self) -> rt::Value {
2541 rt::record(::std::vec![])
2542 }
2543 }
2544 impl rt::FromValue for Archive {
2545 fn from_value(_value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2546 ::core::result::Result::Ok(Self {})
2547 }
2548 }
2549 }
2550}
2551pub mod daml_stdlib_DA_Logic_Types {
2552 pub mod DA_Logic_Types {
2553 use canton_daml as rt;
2554 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2555 #[serde(crate = "rt::serde", tag = "tag", content = "value")]
2556 pub enum Formula<A> {
2557 #[serde(rename = "Proposition")]
2558 Proposition(A),
2559 #[serde(rename = "Negation")]
2560 Negation(
2561 ::std::boxed::Box<crate::daml_stdlib_DA_Logic_Types::DA_Logic_Types::Formula<A>>,
2562 ),
2563 #[serde(rename = "Conjunction")]
2564 Conjunction(
2565 ::std::vec::Vec<crate::daml_stdlib_DA_Logic_Types::DA_Logic_Types::Formula<A>>,
2566 ),
2567 #[serde(rename = "Disjunction")]
2568 Disjunction(
2569 ::std::vec::Vec<crate::daml_stdlib_DA_Logic_Types::DA_Logic_Types::Formula<A>>,
2570 ),
2571 }
2572 impl<A> rt::ToValue for Formula<A>
2573 where
2574 A: rt::ToValue,
2575 {
2576 fn to_value(&self) -> rt::Value {
2577 match self {
2578 Formula::Proposition(inner) => {
2579 rt::variant_value("Proposition", rt::ToValue::to_value(inner))
2580 }
2581 Formula::Negation(inner) => {
2582 rt::variant_value("Negation", rt::ToValue::to_value(inner))
2583 }
2584 Formula::Conjunction(inner) => {
2585 rt::variant_value("Conjunction", rt::ToValue::to_value(inner))
2586 }
2587 Formula::Disjunction(inner) => {
2588 rt::variant_value("Disjunction", rt::ToValue::to_value(inner))
2589 }
2590 }
2591 }
2592 }
2593 impl<A> rt::FromValue for Formula<A>
2594 where
2595 A: rt::FromValue,
2596 {
2597 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2598 let (constructor, payload) = rt::variant_parts(value)?;
2599 match constructor {
2600 "Proposition" => ::core::result::Result::Ok(Formula::Proposition(
2601 rt::FromValue::from_value(payload).map_err(|e| e.at("Proposition"))?,
2602 )),
2603 "Negation" => ::core::result::Result::Ok(Formula::Negation(
2604 rt::FromValue::from_value(payload).map_err(|e| e.at("Negation"))?,
2605 )),
2606 "Conjunction" => ::core::result::Result::Ok(Formula::Conjunction(
2607 rt::FromValue::from_value(payload).map_err(|e| e.at("Conjunction"))?,
2608 )),
2609 "Disjunction" => ::core::result::Result::Ok(Formula::Disjunction(
2610 rt::FromValue::from_value(payload).map_err(|e| e.at("Disjunction"))?,
2611 )),
2612 other => {
2613 ::core::result::Result::Err(rt::unexpected_constructor("Formula", other))
2614 }
2615 }
2616 }
2617 }
2618 }
2619}
2620pub mod daml_stdlib_DA_Monoid_Types {
2621 pub mod DA_Monoid_Types {
2622 use canton_daml as rt;
2623 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2624 #[serde(crate = "rt::serde")]
2625 pub struct All {
2626 #[serde(rename = "getAll")]
2628 pub get_all: bool,
2629 }
2630 impl rt::ToValue for All {
2631 fn to_value(&self) -> rt::Value {
2632 rt::record(::std::vec![(
2633 "getAll",
2634 rt::ToValue::to_value(&self.get_all)
2635 ),])
2636 }
2637 }
2638 impl rt::FromValue for All {
2639 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2640 ::core::result::Result::Ok(Self {
2641 get_all: rt::FromValue::from_value(rt::required_field(
2642 value, 0usize, "getAll",
2643 )?)
2644 .map_err(|e| e.at("getAll"))?,
2645 })
2646 }
2647 }
2648 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2649 #[serde(crate = "rt::serde")]
2650 pub struct Any {
2651 #[serde(rename = "getAny")]
2653 pub get_any: bool,
2654 }
2655 impl rt::ToValue for Any {
2656 fn to_value(&self) -> rt::Value {
2657 rt::record(::std::vec![(
2658 "getAny",
2659 rt::ToValue::to_value(&self.get_any)
2660 ),])
2661 }
2662 }
2663 impl rt::FromValue for Any {
2664 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2665 ::core::result::Result::Ok(Self {
2666 get_any: rt::FromValue::from_value(rt::required_field(
2667 value, 0usize, "getAny",
2668 )?)
2669 .map_err(|e| e.at("getAny"))?,
2670 })
2671 }
2672 }
2673 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2674 #[serde(crate = "rt::serde")]
2675 pub struct Sum<A> {
2676 #[serde(rename = "unpack")]
2677 pub unpack: A,
2678 }
2679 impl<A> rt::ToValue for Sum<A>
2680 where
2681 A: rt::ToValue,
2682 {
2683 fn to_value(&self) -> rt::Value {
2684 rt::record(::std::vec![("unpack", rt::ToValue::to_value(&self.unpack)),])
2685 }
2686 }
2687 impl<A> rt::FromValue for Sum<A>
2688 where
2689 A: rt::FromValue,
2690 {
2691 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2692 ::core::result::Result::Ok(Self {
2693 unpack: rt::FromValue::from_value(rt::required_field(value, 0usize, "unpack")?)
2694 .map_err(|e| e.at("unpack"))?,
2695 })
2696 }
2697 }
2698 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2699 #[serde(crate = "rt::serde")]
2700 pub struct Product<A> {
2701 #[serde(rename = "unpack")]
2702 pub unpack: A,
2703 }
2704 impl<A> rt::ToValue for Product<A>
2705 where
2706 A: rt::ToValue,
2707 {
2708 fn to_value(&self) -> rt::Value {
2709 rt::record(::std::vec![("unpack", rt::ToValue::to_value(&self.unpack)),])
2710 }
2711 }
2712 impl<A> rt::FromValue for Product<A>
2713 where
2714 A: rt::FromValue,
2715 {
2716 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2717 ::core::result::Result::Ok(Self {
2718 unpack: rt::FromValue::from_value(rt::required_field(value, 0usize, "unpack")?)
2719 .map_err(|e| e.at("unpack"))?,
2720 })
2721 }
2722 }
2723 }
2724}
2725pub mod daml_stdlib_DA_NonEmpty_Types {
2726 pub mod DA_NonEmpty_Types {
2727 use canton_daml as rt;
2728 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2729 #[serde(crate = "rt::serde")]
2730 pub struct NonEmpty<A> {
2731 #[serde(rename = "hd")]
2732 pub hd: A,
2733 #[serde(rename = "tl")]
2734 pub tl: ::std::vec::Vec<A>,
2735 }
2736 impl<A> rt::ToValue for NonEmpty<A>
2737 where
2738 A: rt::ToValue,
2739 {
2740 fn to_value(&self) -> rt::Value {
2741 rt::record(::std::vec![
2742 ("hd", rt::ToValue::to_value(&self.hd)),
2743 ("tl", rt::ToValue::to_value(&self.tl)),
2744 ])
2745 }
2746 }
2747 impl<A> rt::FromValue for NonEmpty<A>
2748 where
2749 A: rt::FromValue,
2750 {
2751 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2752 ::core::result::Result::Ok(Self {
2753 hd: rt::FromValue::from_value(rt::required_field(value, 0usize, "hd")?)
2754 .map_err(|e| e.at("hd"))?,
2755 tl: rt::FromValue::from_value(rt::required_field(value, 1usize, "tl")?)
2756 .map_err(|e| e.at("tl"))?,
2757 })
2758 }
2759 }
2760 }
2761}
2762pub mod daml_stdlib_DA_Random_Types {
2763 pub mod DA_Random_Types {
2764 use canton_daml as rt;
2765 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2766 #[serde(crate = "rt::serde", tag = "tag", content = "value")]
2767 pub enum Minstd {
2768 #[serde(rename = "Minstd")]
2769 Minstd(rt::Int64),
2770 }
2771 impl rt::ToValue for Minstd {
2772 fn to_value(&self) -> rt::Value {
2773 match self {
2774 Minstd::Minstd(inner) => {
2775 rt::variant_value("Minstd", rt::ToValue::to_value(inner))
2776 }
2777 }
2778 }
2779 }
2780 impl rt::FromValue for Minstd {
2781 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2782 let (constructor, payload) = rt::variant_parts(value)?;
2783 match constructor {
2784 "Minstd" => ::core::result::Result::Ok(Minstd::Minstd(
2785 rt::FromValue::from_value(payload).map_err(|e| e.at("Minstd"))?,
2786 )),
2787 other => {
2788 ::core::result::Result::Err(rt::unexpected_constructor("Minstd", other))
2789 }
2790 }
2791 }
2792 }
2793 }
2794}
2795pub mod daml_stdlib_DA_Semigroup_Types {
2796 pub mod DA_Semigroup_Types {
2797 use canton_daml as rt;
2798 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2799 #[serde(crate = "rt::serde")]
2800 pub struct Min<A> {
2801 #[serde(rename = "unpack")]
2802 pub unpack: A,
2803 }
2804 impl<A> rt::ToValue for Min<A>
2805 where
2806 A: rt::ToValue,
2807 {
2808 fn to_value(&self) -> rt::Value {
2809 rt::record(::std::vec![("unpack", rt::ToValue::to_value(&self.unpack)),])
2810 }
2811 }
2812 impl<A> rt::FromValue for Min<A>
2813 where
2814 A: rt::FromValue,
2815 {
2816 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2817 ::core::result::Result::Ok(Self {
2818 unpack: rt::FromValue::from_value(rt::required_field(value, 0usize, "unpack")?)
2819 .map_err(|e| e.at("unpack"))?,
2820 })
2821 }
2822 }
2823 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2824 #[serde(crate = "rt::serde")]
2825 pub struct Max<A> {
2826 #[serde(rename = "unpack")]
2827 pub unpack: A,
2828 }
2829 impl<A> rt::ToValue for Max<A>
2830 where
2831 A: rt::ToValue,
2832 {
2833 fn to_value(&self) -> rt::Value {
2834 rt::record(::std::vec![("unpack", rt::ToValue::to_value(&self.unpack)),])
2835 }
2836 }
2837 impl<A> rt::FromValue for Max<A>
2838 where
2839 A: rt::FromValue,
2840 {
2841 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2842 ::core::result::Result::Ok(Self {
2843 unpack: rt::FromValue::from_value(rt::required_field(value, 0usize, "unpack")?)
2844 .map_err(|e| e.at("unpack"))?,
2845 })
2846 }
2847 }
2848 }
2849}
2850pub mod daml_stdlib_DA_Set_Types {
2851 pub mod DA_Set_Types {
2852 use canton_daml as rt;
2853 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2854 #[serde(crate = "rt::serde")]
2855 pub struct Set<K> {
2856 #[serde(rename = "map")]
2857 pub map: rt::GenMap<K, rt::Unit>,
2858 }
2859 impl<K> rt::ToValue for Set<K>
2860 where
2861 K: rt::ToValue,
2862 {
2863 fn to_value(&self) -> rt::Value {
2864 rt::record(::std::vec![("map", rt::ToValue::to_value(&self.map)),])
2865 }
2866 }
2867 impl<K> rt::FromValue for Set<K>
2868 where
2869 K: rt::FromValue,
2870 {
2871 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2872 ::core::result::Result::Ok(Self {
2873 map: rt::FromValue::from_value(rt::required_field(value, 0usize, "map")?)
2874 .map_err(|e| e.at("map"))?,
2875 })
2876 }
2877 }
2878 }
2879}
2880pub mod daml_stdlib_DA_Stack_Types {
2881 pub mod DA_Stack_Types {
2882 use canton_daml as rt;
2883 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2884 #[serde(crate = "rt::serde")]
2885 pub struct SrcLoc {
2886 #[serde(rename = "srcLocPackage")]
2888 pub src_loc_package: ::std::string::String,
2889 #[serde(rename = "srcLocModule")]
2891 pub src_loc_module: ::std::string::String,
2892 #[serde(rename = "srcLocFile")]
2894 pub src_loc_file: ::std::string::String,
2895 #[serde(rename = "srcLocStartLine")]
2897 pub src_loc_start_line: rt::Int64,
2898 #[serde(rename = "srcLocStartCol")]
2900 pub src_loc_start_col: rt::Int64,
2901 #[serde(rename = "srcLocEndLine")]
2903 pub src_loc_end_line: rt::Int64,
2904 #[serde(rename = "srcLocEndCol")]
2906 pub src_loc_end_col: rt::Int64,
2907 }
2908 impl rt::ToValue for SrcLoc {
2909 fn to_value(&self) -> rt::Value {
2910 rt::record(::std::vec![
2911 (
2912 "srcLocPackage",
2913 rt::ToValue::to_value(&self.src_loc_package)
2914 ),
2915 ("srcLocModule", rt::ToValue::to_value(&self.src_loc_module)),
2916 ("srcLocFile", rt::ToValue::to_value(&self.src_loc_file)),
2917 (
2918 "srcLocStartLine",
2919 rt::ToValue::to_value(&self.src_loc_start_line)
2920 ),
2921 (
2922 "srcLocStartCol",
2923 rt::ToValue::to_value(&self.src_loc_start_col)
2924 ),
2925 (
2926 "srcLocEndLine",
2927 rt::ToValue::to_value(&self.src_loc_end_line)
2928 ),
2929 ("srcLocEndCol", rt::ToValue::to_value(&self.src_loc_end_col)),
2930 ])
2931 }
2932 }
2933 impl rt::FromValue for SrcLoc {
2934 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
2935 ::core::result::Result::Ok(Self {
2936 src_loc_package: rt::FromValue::from_value(rt::required_field(
2937 value,
2938 0usize,
2939 "srcLocPackage",
2940 )?)
2941 .map_err(|e| e.at("srcLocPackage"))?,
2942 src_loc_module: rt::FromValue::from_value(rt::required_field(
2943 value,
2944 1usize,
2945 "srcLocModule",
2946 )?)
2947 .map_err(|e| e.at("srcLocModule"))?,
2948 src_loc_file: rt::FromValue::from_value(rt::required_field(
2949 value,
2950 2usize,
2951 "srcLocFile",
2952 )?)
2953 .map_err(|e| e.at("srcLocFile"))?,
2954 src_loc_start_line: rt::FromValue::from_value(rt::required_field(
2955 value,
2956 3usize,
2957 "srcLocStartLine",
2958 )?)
2959 .map_err(|e| e.at("srcLocStartLine"))?,
2960 src_loc_start_col: rt::FromValue::from_value(rt::required_field(
2961 value,
2962 4usize,
2963 "srcLocStartCol",
2964 )?)
2965 .map_err(|e| e.at("srcLocStartCol"))?,
2966 src_loc_end_line: rt::FromValue::from_value(rt::required_field(
2967 value,
2968 5usize,
2969 "srcLocEndLine",
2970 )?)
2971 .map_err(|e| e.at("srcLocEndLine"))?,
2972 src_loc_end_col: rt::FromValue::from_value(rt::required_field(
2973 value,
2974 6usize,
2975 "srcLocEndCol",
2976 )?)
2977 .map_err(|e| e.at("srcLocEndCol"))?,
2978 })
2979 }
2980 }
2981 }
2982}
2983pub mod daml_stdlib_DA_Time_Types {
2984 pub mod DA_Time_Types {
2985 use canton_daml as rt;
2986 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
2987 #[serde(crate = "rt::serde")]
2988 pub struct RelTime {
2989 #[serde(rename = "microseconds")]
2990 pub microseconds: rt::Int64,
2991 }
2992 impl rt::ToValue for RelTime {
2993 fn to_value(&self) -> rt::Value {
2994 rt::record(::std::vec![(
2995 "microseconds",
2996 rt::ToValue::to_value(&self.microseconds)
2997 ),])
2998 }
2999 }
3000 impl rt::FromValue for RelTime {
3001 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
3002 ::core::result::Result::Ok(Self {
3003 microseconds: rt::FromValue::from_value(rt::required_field(
3004 value,
3005 0usize,
3006 "microseconds",
3007 )?)
3008 .map_err(|e| e.at("microseconds"))?,
3009 })
3010 }
3011 }
3012 }
3013}
3014pub mod daml_stdlib_DA_Validation_Types {
3015 pub mod DA_Validation_Types {
3016 use canton_daml as rt;
3017 #[derive(Clone, Debug, PartialEq, Eq, rt::serde::Serialize, rt::serde::Deserialize)]
3018 #[serde(crate = "rt::serde", tag = "tag", content = "value")]
3019 pub enum Validation<Errs, A> {
3020 #[serde(rename = "Errors")]
3021 Errors(crate::daml_stdlib_DA_NonEmpty_Types::DA_NonEmpty_Types::NonEmpty<Errs>),
3022 #[serde(rename = "Success")]
3023 Success(A),
3024 }
3025 impl<Errs, A> rt::ToValue for Validation<Errs, A>
3026 where
3027 Errs: rt::ToValue,
3028 A: rt::ToValue,
3029 {
3030 fn to_value(&self) -> rt::Value {
3031 match self {
3032 Validation::Errors(inner) => {
3033 rt::variant_value("Errors", rt::ToValue::to_value(inner))
3034 }
3035 Validation::Success(inner) => {
3036 rt::variant_value("Success", rt::ToValue::to_value(inner))
3037 }
3038 }
3039 }
3040 }
3041 impl<Errs, A> rt::FromValue for Validation<Errs, A>
3042 where
3043 Errs: rt::FromValue,
3044 A: rt::FromValue,
3045 {
3046 fn from_value(value: &rt::Value) -> ::core::result::Result<Self, rt::ValueError> {
3047 let (constructor, payload) = rt::variant_parts(value)?;
3048 match constructor {
3049 "Errors" => ::core::result::Result::Ok(Validation::Errors(
3050 rt::FromValue::from_value(payload).map_err(|e| e.at("Errors"))?,
3051 )),
3052 "Success" => ::core::result::Result::Ok(Validation::Success(
3053 rt::FromValue::from_value(payload).map_err(|e| e.at("Success"))?,
3054 )),
3055 other => {
3056 ::core::result::Result::Err(rt::unexpected_constructor("Validation", other))
3057 }
3058 }
3059 }
3060 }
3061 }
3062}